Cleanup/account id numeric

bin/evd/src/main.rs

@@ -655,7 +655,11 @@ fn run_custom_genesis<S: ReadonlyKV + Storage>(
             (addr.into_array(), acc.balance)
         })
         .collect();
-    let minter = AccountId::new(genesis_config.minter_id);
+    let minter = {
+        let mut b = [0u8; 32];
+        b[16..32].copy_from_slice(&genesis_config.minter_id.to_be_bytes());
+        AccountId::from_bytes(b)
+    };
     let metadata = genesis_config.token.to_metadata();
 
     let gas_config = default_gas_config();

bin/testapp/src/lib.rs

@@ -17,7 +17,7 @@ use evolve_token::account::{Token, TokenRef};
 use evolve_tx_eth::TxContext;
 use evolve_tx_eth::{register_runtime_contract_account, resolve_or_create_eoa_account};
 
-pub const MINTER: AccountId = AccountId::new(100_002);
+pub const MINTER: AccountId = AccountId::from_u64(100002);
 
 pub struct MempoolNoOpPostTx;
 
@@ -42,7 +42,7 @@ pub type MempoolStf = Stf<
     MempoolNoOpPostTx,
 >;
 
-pub const PLACEHOLDER_ACCOUNT: AccountId = AccountId::new(u128::MAX);
+pub const PLACEHOLDER_ACCOUNT: AccountId = AccountId::from_u64(u64::MAX);
 
 /// Default gas configuration for the test application.
 pub fn default_gas_config() -> StorageGasConfig {

bin/testapp/src/main.rs

@@ -218,7 +218,11 @@ fn run_custom_genesis<S: ReadonlyKV + Storage>(
         return Err("custom genesis requires at least one account".into());
     }
 
-    let minter = AccountId::new(config.minter_id);
+    let minter = {
+        let mut b = [0u8; 32];
+        b[16..32].copy_from_slice(&config.minter_id.to_be_bytes());
+        AccountId::from_bytes(b)
+    };
     let metadata = config.token.to_metadata();
 
     let genesis_block = BlockContext::new(0, 0);

bin/testapp/tests/mempool_e2e.rs

@@ -270,7 +270,7 @@ fn setup_genesis(
 
     let init_storage = AsyncMockStorage::new();
     let gas_config = default_gas_config();
-    let stf = build_mempool_stf(gas_config.clone(), AccountId::new(0));
+    let stf = build_mempool_stf(gas_config.clone(), AccountId::from_u64(0));
 
     let (genesis_state, genesis_accounts) = do_eth_genesis(
         &stf,

bin/txload/src/main.rs

@@ -567,7 +567,7 @@ mod tests {
 
     #[test]
     fn build_transfer_calldata_has_selector_and_borsh_args() {
-        let recipient = AccountId::new(42);
+        let recipient = AccountId::from_u64(42);
         let amount = 999_u128;
 
         let calldata = build_transfer_calldata(recipient, amount).unwrap();

crates/app/genesis/Cargo.toml

@@ -13,6 +13,7 @@ evolve_stf = { workspace = true }
 evolve_stf_traits = { workspace = true }
 
 borsh = { workspace = true }
+hex = "0.4"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 thiserror = "1.0"

crates/app/genesis/src/file.rs

@@ -40,7 +40,7 @@ pub struct GenesisTxJson {
     pub id: Option<String>,
 
     /// Sender specification.
-    /// - "system": Use the system account (AccountId::new(0))
+    /// - "system": Use the system account (AccountId::from_u64(0))
     /// - "$ref": Reference a previously created account
     /// - number: Use a specific account ID
     #[serde(default = "default_sender")]
@@ -64,15 +64,25 @@ fn default_sender() -> SenderSpec {
 }
 
 /// Specification for the sender of a genesis transaction.
-#[derive(Debug, Clone, Default, Serialize)]
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
 pub enum SenderSpec {
     /// Use the system account
     #[default]
     System,
     /// Reference a previously created account (starts with $)
     Reference(String),
     /// Use a specific account ID
-    AccountId(u128),
+    AccountId(AccountId),
+}
+
+impl Serialize for SenderSpec {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        match self {
+            SenderSpec::System => serializer.serialize_str("system"),
+            SenderSpec::Reference(r) => serializer.serialize_str(r),
+            SenderSpec::AccountId(id) => serializer.serialize_str(&hex::encode(id.to_bytes())),
+        }
+    }
 }
 
 impl<'de> serde::Deserialize<'de> for SenderSpec {
@@ -86,25 +96,36 @@ impl<'de> serde::Deserialize<'de> for SenderSpec {
         match value {
             serde_json::Value::String(s) if s == "system" => Ok(SenderSpec::System),
             serde_json::Value::String(s) => Ok(SenderSpec::Reference(s)),
-            serde_json::Value::Number(n) => n
-                .as_u64()
-                .map(|v| SenderSpec::AccountId(v as u128))
-                .or_else(|| n.as_i64().map(|v| SenderSpec::AccountId(v as u128)))
-                .ok_or_else(|| D::Error::custom("invalid account ID number")),
+            serde_json::Value::Number(n) => {
+                let v = n
+                    .as_u64()
+                    .ok_or_else(|| D::Error::custom("invalid account ID number"))?;
+                Ok(SenderSpec::AccountId(AccountId::from_u64(v)))
+            }
             _ => Err(D::Error::custom("expected string or number for sender")),
         }
     }
 }
 
 /// Specification for the recipient of a genesis transaction.
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum RecipientSpec {
     /// Use the runtime account for account creation
     Runtime,
     /// Reference a previously created account (starts with $)
     Reference(String),
     /// Use a specific account ID
-    AccountId(u128),
+    AccountId(AccountId),
+}
+
+impl Serialize for RecipientSpec {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        match self {
+            RecipientSpec::Runtime => serializer.serialize_str("runtime"),
+            RecipientSpec::Reference(r) => serializer.serialize_str(r),
+            RecipientSpec::AccountId(id) => serializer.serialize_str(&hex::encode(id.to_bytes())),
+        }
+    }
 }
 
 impl<'de> serde::Deserialize<'de> for RecipientSpec {
@@ -118,11 +139,12 @@ impl<'de> serde::Deserialize<'de> for RecipientSpec {
         match value {
             serde_json::Value::String(s) if s == "runtime" => Ok(RecipientSpec::Runtime),
             serde_json::Value::String(s) => Ok(RecipientSpec::Reference(s)),
-            serde_json::Value::Number(n) => n
-                .as_u64()
-                .map(|v| RecipientSpec::AccountId(v as u128))
-                .or_else(|| n.as_i64().map(|v| RecipientSpec::AccountId(v as u128)))
-                .ok_or_else(|| D::Error::custom("invalid account ID number")),
+            serde_json::Value::Number(n) => {
+                let v = n
+                    .as_u64()
+                    .ok_or_else(|| D::Error::custom("invalid account ID number"))?;
+                Ok(RecipientSpec::AccountId(AccountId::from_u64(v)))
+            }
             _ => Err(D::Error::custom("expected string or number for recipient")),
         }
     }
@@ -189,27 +211,31 @@ impl GenesisFile {
 
         let mut txs = Vec::with_capacity(self.transactions.len());
         let mut id_to_account: HashMap<String, AccountId> = HashMap::new();
-        let mut next_account_id: u128 = 1; // Start from 1, 0 is system
+        // Start from 1, 0 is system
+        let mut next_account_id = AccountId::from_u64(1);
 
         for (idx, tx_json) in self.transactions.iter().enumerate() {
             // Resolve sender
-            let sender =
-                match &tx_json.sender {
-                    SenderSpec::System => SYSTEM_ACCOUNT_ID,
-                    SenderSpec::Reference(r) if r.starts_with('$') => {
-                        let ref_id = &r[1..];
-                        *id_to_account.get(ref_id).ok_or_else(|| {
-                            GenesisError::InvalidReference(ref_id.to_string(), idx)
-                        })?
-                    }
-                    SenderSpec::Reference(r) => {
-                        // Treat as account ID string
-                        AccountId::new(r.parse().map_err(|_| {
+            let sender = match &tx_json.sender {
+                SenderSpec::System => SYSTEM_ACCOUNT_ID,
+                SenderSpec::Reference(r) if r.starts_with('$') => {
+                    let ref_id = &r[1..];
+                    *id_to_account
+                        .get(ref_id)
+                        .ok_or_else(|| GenesisError::InvalidReference(ref_id.to_string(), idx))?
+                }
+                SenderSpec::Reference(r) => {
+                    // Treat as hex-encoded 32-byte account ID
+                    let bytes = hex::decode(r.trim_start_matches("0x"))
+                        .ok()
+                        .and_then(|b| <[u8; 32]>::try_from(b).ok())
+                        .ok_or_else(|| {
                             GenesisError::ParseError(format!("invalid sender: {}", r))
-                        })?)
-                    }
-                    SenderSpec::AccountId(id) => AccountId::new(*id),
-                };
+                        })?;
+                    AccountId::from_bytes(bytes)
+                }
+                SenderSpec::AccountId(id) => *id,
+            };
 
             // Resolve recipient
             let recipient = match &tx_json.recipient {
@@ -221,12 +247,16 @@ impl GenesisFile {
                         .ok_or_else(|| GenesisError::InvalidReference(ref_id.to_string(), idx))?
                 }
                 RecipientSpec::Reference(r) => {
-                    // Treat as account ID string
-                    AccountId::new(r.parse().map_err(|_| {
-                        GenesisError::ParseError(format!("invalid recipient: {}", r))
-                    })?)
+                    // Treat as hex-encoded 32-byte account ID
+                    let bytes = hex::decode(r.trim_start_matches("0x"))
+                        .ok()
+                        .and_then(|b| <[u8; 32]>::try_from(b).ok())
+                        .ok_or_else(|| {
+                            GenesisError::ParseError(format!("invalid recipient: {}", r))
+                        })?;
+                    AccountId::from_bytes(bytes)
                 }
-                RecipientSpec::AccountId(id) => AccountId::new(*id),
+                RecipientSpec::AccountId(id) => *id,
             };
 
             // Resolve $references in the message payload
@@ -244,9 +274,8 @@ impl GenesisFile {
             // If this transaction has an ID, assign it the next account ID
             // This assumes the transaction creates an account
             if let Some(id) = &tx_json.id {
-                let account_id = AccountId::new(next_account_id);
-                id_to_account.insert(id.clone(), account_id);
-                next_account_id += 1;
+                id_to_account.insert(id.clone(), next_account_id);
+                next_account_id = next_account_id.increase();
             }
 
             txs.push(genesis_tx);
@@ -267,8 +296,9 @@ fn resolve_references_in_value(
             let account_id = id_to_account
                 .get(ref_id)
                 .ok_or_else(|| GenesisError::InvalidReference(ref_id.to_string(), 0))?;
-            // Use string representation for u128 since JSON numbers are limited to i64/u64
-            Ok(serde_json::Value::String(account_id.inner().to_string()))
+            Ok(serde_json::Value::String(hex::encode(
+                account_id.as_bytes(),
+            )))
         }
         serde_json::Value::Array(arr) => {
             let resolved: Result<Vec<_>, _> = arr
@@ -360,7 +390,7 @@ mod tests {
     #[test]
     fn test_resolve_references_in_value() {
         let mut id_to_account = HashMap::new();
-        id_to_account.insert("alice".to_string(), AccountId::new(1));
+        id_to_account.insert("alice".to_string(), AccountId::from_u64(1));
 
         let value = serde_json::json!({
             "account": "$alice",
@@ -372,10 +402,19 @@ mod tests {
 
         let resolved = resolve_references_in_value(&value, &id_to_account).unwrap();
 
-        // Account IDs are resolved as strings (for u128 compatibility)
-        assert_eq!(resolved["account"], "1");
-        assert_eq!(resolved["nested"]["ref"], "1");
-        assert_eq!(resolved["list"][0], "1");
+        // Account IDs are resolved as hex strings
+        assert_eq!(
+            resolved["account"],
+            "0000000000000000000000000000000000000000000000000000000000000001"
+        );
+        assert_eq!(
+            resolved["nested"]["ref"],
+            "0000000000000000000000000000000000000000000000000000000000000001"
+        );
+        assert_eq!(
+            resolved["list"][0],
+            "0000000000000000000000000000000000000000000000000000000000000001"
+        );
         assert_eq!(resolved["list"][1], "literal");
     }
 
@@ -459,10 +498,10 @@ mod tests {
             ]
         }"#;
         let genesis = GenesisFile::parse(json).unwrap();
-        assert!(matches!(
+        assert_eq!(
             genesis.transactions[0].sender,
-            SenderSpec::AccountId(123)
-        ));
+            SenderSpec::AccountId(AccountId::from_u64(123))
+        );
     }
 
     #[test]
@@ -488,10 +527,10 @@ mod tests {
             ]
         }"#;
         let genesis = GenesisFile::parse(json).unwrap();
-        assert!(matches!(
+        assert_eq!(
             genesis.transactions[0].recipient,
-            RecipientSpec::AccountId(456)
-        ));
+            RecipientSpec::AccountId(AccountId::from_u64(456))
+        );
     }
 
     #[test]
@@ -577,8 +616,8 @@ mod tests {
         let txs = genesis.to_transactions(&registry).unwrap();
 
         assert_eq!(txs.len(), 3);
-        assert_eq!(txs[2].sender, AccountId::new(1));
-        assert_eq!(txs[2].recipient, AccountId::new(1));
+        assert_eq!(txs[2].sender, AccountId::from_u64(1));
+        assert_eq!(txs[2].recipient, AccountId::from_u64(1));
     }
 
     #[test]

crates/app/genesis/src/lib.rs

@@ -38,7 +38,7 @@ use std::cell::RefCell;
 /// System account ID used as sender for genesis transactions.
 /// This is a sentinel value that indicates the transaction originates
 /// from the genesis process rather than a real account.
-pub const SYSTEM_ACCOUNT_ID: AccountId = AccountId::new(0);
+pub const SYSTEM_ACCOUNT_ID: AccountId = AccountId::from_u64(0);
 
 /// Applies genesis transactions to initialize chain state.
 ///
@@ -441,7 +441,7 @@ mod tests {
         let mut codes = CodeStore::new();
         codes.add_code(TestAccount);
 
-        let test_account_id = AccountId::new(100);
+        let test_account_id = AccountId::from_u64(100);
         let storage = setup_storage_with_account(test_account_id, "test_account");
         let consensus_params = ConsensusParams::default();
 
@@ -467,8 +467,8 @@ mod tests {
         let mut codes = CodeStore::new();
         codes.add_code(TestAccount);
 
-        let account1 = AccountId::new(100);
-        let account2 = AccountId::new(101);
+        let account1 = AccountId::from_u64(100);
+        let account2 = AccountId::from_u64(101);
         let mut storage = setup_storage_with_account(account1, "test_account");
         let consensus_params = ConsensusParams::default();
         // Add second account
@@ -517,9 +517,9 @@ mod tests {
         codes.add_code(TestAccount);
         codes.add_code(FailingAccount);
 
-        let good_account = AccountId::new(100);
-        let bad_account = AccountId::new(101);
-        let after_bad = AccountId::new(102);
+        let good_account = AccountId::from_u64(100);
+        let bad_account = AccountId::from_u64(101);
+        let after_bad = AccountId::from_u64(102);
         let consensus_params = ConsensusParams::default();
 
         let mut storage = setup_storage_with_account(good_account, "test_account");
@@ -585,7 +585,7 @@ mod tests {
         let mut codes = CodeStore::new();
         codes.add_code(FailingAccount);
 
-        let bad_account = AccountId::new(100);
+        let bad_account = AccountId::from_u64(100);
         let storage = setup_storage_with_account(bad_account, "failing_account");
         let consensus_params = ConsensusParams::default();
 

crates/app/genesis/src/types.rs

@@ -47,7 +47,7 @@ pub struct GenesisTx {
     pub id: Option<String>,
 
     /// The sender account ID.
-    /// For genesis, this is typically the system account (AccountId::new(0))
+    /// For genesis, this is typically the system account (AccountId::from_u64(0))
     /// or a virtual sender specified in the genesis file.
     pub sender: AccountId,