Add tests for partial account helper functions (#3745)

* Add tests for partial account helpers

* Make comments and error message checks uniform

* Increase test timeout

* Dry up the test code

* Reuse const variable in check

---------

Co-authored-by: Gabriel Rocheleau <contact@rockwaterweb.com>

Author: am1r021

packages/client/test/cli/cli.spec.ts

@@ -57,7 +57,7 @@ describe('[CLI]', () => {
       }
     }
     await clientRunHelper(cliArgs, onData)
-  }, 5000)
+  }, 10000)
   it('should successfully start client with custom inputs for PoA network', async () => {
     const cliArgs = [
       '--rpc',

packages/util/test/account.spec.ts

@@ -5,21 +5,26 @@ import {
   Account,
   KECCAK256_NULL,
   KECCAK256_RLP,
+  Units,
   accountBodyFromSlim,
   accountBodyToRLP,
   accountBodyToSlim,
+  bigIntToUnpaddedBytes,
   bytesToBigInt,
   bytesToHex,
   createAccount,
   createAccountFromBytesArray,
   createAccountFromRLP,
+  createPartialAccount,
+  createPartialAccountFromRLP,
   equalsBytes,
   generateAddress,
   generateAddress2,
   hexToBytes,
   importPublic,
   intToBytes,
   intToHex,
+  intToUnpaddedBytes,
   isValidAddress,
   isValidChecksumAddress,
   isValidPrivate,
@@ -810,3 +815,361 @@ describe('Utility Functions', () => {
     assert.equal(JSON.stringify(result), JSON.stringify(RLP.encode(body)))
   })
 })
+
+describe('createPartialAccount', () => {
+  it('should throw an error when all fields are null', () => {
+    assert.throws(
+      () =>
+        createPartialAccount({
+          nonce: null,
+          balance: null,
+          storageRoot: null,
+          codeHash: null,
+          codeSize: null,
+          version: null,
+        }),
+      'All partial fields null',
+    )
+  })
+
+  it('should return Account with correct values when fields are provided', () => {
+    const accountData = {
+      nonce: 1n,
+      balance: Units.ether(1),
+      storageRoot: KECCAK256_RLP,
+      codeHash: KECCAK256_RLP,
+      codeSize: 10,
+      version: 1,
+    }
+    const account = createPartialAccount(accountData)
+
+    assert.deepEqual(
+      account,
+      new Account(
+        accountData.nonce,
+        accountData.balance,
+        accountData.storageRoot,
+        accountData.codeHash,
+        accountData.codeSize,
+        accountData.version,
+      ),
+    )
+  })
+
+  it('should return Account with null and undefined value fields as given', () => {
+    const accountData = {
+      nonce: undefined,
+      balance: Units.ether(1),
+      storageRoot: undefined,
+      codeHash: null,
+      codeSize: 10,
+      version: undefined,
+    }
+    const account = createPartialAccount(accountData)
+
+    assert.deepEqual(
+      account,
+      new Account(
+        accountData.nonce,
+        accountData.balance,
+        accountData.storageRoot,
+        accountData.codeHash,
+        accountData.codeSize,
+        accountData.version,
+      ),
+    )
+  })
+})
+
+describe('createPartialAccountFromRLP', () => {
+  it('should throw an error for invalid serialized account input (non-array)', () => {
+    const invalidSerialized = toBytes(1n)
+    assert.throws(
+      () => createPartialAccountFromRLP(invalidSerialized),
+      /Invalid serialized account input/,
+    )
+  })
+
+  const testCases = [
+    {
+      description: 'should handle a mix of null and non-null values correctly',
+      data: [
+        [toBytes(1), toBytes(1)], // Nonce: 1
+        [toBytes(0)], // Balance: null
+        [toBytes(1), KECCAK256_RLP], // StorageRoot: KECCAK256_RLP
+        [toBytes(0)], // CodeHash: null
+        [toBytes(1), toBytes(10)], // CodeSize: 10
+        [toBytes(0)], // Version: null
+      ],
+      shouldThrow: false,
+      expected: new Account(BigInt(1), null, KECCAK256_RLP, null, 10, null),
+      errorRegex: null,
+    },
+    {
+      description: 'should throw when all fields are null',
+      data: [
+        [toBytes(0)], // Nonce: null
+        [toBytes(0)], // Balance: null
+        [toBytes(0)], // StorageRoot: null
+        [toBytes(0)], // CodeHash: null
+        [toBytes(0)], // CodeSize: null
+        [toBytes(0)], // Version: null
+      ],
+      shouldThrow: true,
+      expected: null,
+      errorRegex: /All partial fields null/,
+    },
+    {
+      description: 'should handle all non-null fields correctly',
+      data: [
+        [toBytes(1), toBytes(2)], // Nonce: 2
+        [toBytes(1), toBytes(1000)], // Balance: 1000
+        [toBytes(1), KECCAK256_RLP], // StorageRoot: KECCAK256_RLP
+        [toBytes(1), KECCAK256_RLP], // CodeHash: KECCAK256_RLP
+        [toBytes(1), toBytes(50)], // CodeSize: 50
+        [toBytes(1), toBytes(1)], // Version: 1
+      ],
+      shouldThrow: false,
+      expected: new Account(BigInt(2), BigInt(1000), KECCAK256_RLP, KECCAK256_RLP, 50, 1),
+      errorRegex: null,
+    },
+    {
+      description:
+        'should return partial account with non-null fields when isNotNullIndicator is 1',
+      data: [
+        [toBytes(1), toBytes(2)], // Nonce: 2
+        [toBytes(1), toBytes(1000)], // Balance: 1000
+        [toBytes(1), KECCAK256_RLP], // StorageRoot: KECCAK256_RLP
+        [toBytes(1), KECCAK256_RLP], // CodeHash: KECCAK256_RLP
+        [toBytes(1), toBytes(50)], // CodeSize: 50
+        [toBytes(1), toBytes(1)], // Version: 1
+      ],
+      shouldThrow: false,
+      expected: new Account(BigInt(2), BigInt(1000), KECCAK256_RLP, KECCAK256_RLP, 50, 1),
+      errorRegex: null,
+    },
+    {
+      description: 'should return a mix of null and non-null fields based on isNotNullIndicator',
+      data: [
+        [toBytes(1), toBytes(2)], // Nonce: 2
+        [toBytes(0)], // Balance: null
+        [toBytes(1), KECCAK256_RLP], // StorageRoot: KECCAK256_RLP
+        [toBytes(0)], // CodeHash: null
+        [toBytes(1), toBytes(50)], // CodeSize: 50
+        [toBytes(0)], // Version: null
+      ],
+      shouldThrow: false,
+      expected: new Account(BigInt(2), null, KECCAK256_RLP, null, 50, null),
+      errorRegex: null,
+    },
+    {
+      description:
+        'should handle cases where some fields are non-null and others are null correctly',
+      data: [
+        [toBytes(1), toBytes(2)], // Nonce: 2
+        [toBytes(0)], // Balance: null
+        [toBytes(1), KECCAK256_RLP], // StorageRoot: KECCAK256_RLP
+        [toBytes(1), KECCAK256_RLP], // CodeHash: KECCAK256_RLP
+        [toBytes(0)], // CodeSize: null
+        [toBytes(0)], // Version: null
+      ],
+      shouldThrow: false,
+      expected: new Account(BigInt(2), null, KECCAK256_RLP, KECCAK256_RLP, null, null),
+      errorRegex: null,
+    },
+    {
+      description: 'should handle fields with empty arrays (isNullIndicator=0) correctly',
+      data: [
+        [], // nonce -> empty array => null
+        [toBytes(1), toBytes(1000)], // balance: 1000
+        [], // storageRoot -> null
+        [], // codeHash -> null
+        [], // codeSize -> null
+        [], // version -> null
+      ],
+      shouldThrow: false,
+      expected: new Account(null, BigInt(1000), null, null, null, null),
+      errorRegex: null,
+    },
+    {
+      description: 'should throw: invalid partial nonce encoding',
+      data: [KECCAK256_RLP, [], [], [], [], []],
+      shouldThrow: true,
+      expected: null,
+      errorRegex: /Invalid partial nonce encoding/,
+    },
+    {
+      description: 'should throw: invalid partial balance encoding',
+      data: [[], KECCAK256_RLP, [], [], [], []],
+      shouldThrow: true,
+      expected: null,
+      errorRegex: /Invalid partial balance encoding/,
+    },
+    {
+      description: 'should throw: invalid partial storageRoot encoding',
+      data: [[], [], KECCAK256_RLP, [], [], []],
+      shouldThrow: true,
+      expected: null,
+      errorRegex: /Invalid partial storageRoot encoding/,
+    },
+    {
+      description: 'should throw: invalid partial codeHash encoding',
+      data: [[], [], [], KECCAK256_RLP, [], []],
+      shouldThrow: true,
+      expected: null,
+      errorRegex: /Invalid partial codeHash encoding/,
+    },
+    {
+      description: 'should throw: invalid partial codeSize encoding',
+      data: [[], [], [], [], KECCAK256_RLP, []],
+      shouldThrow: true,
+      expected: null,
+      errorRegex: /Invalid partial codeSize encoding/,
+    },
+    {
+      description: 'should throw: invalid partial version encoding',
+      data: [[], [], [], [], [], KECCAK256_RLP],
+      shouldThrow: true,
+      expected: null,
+      errorRegex: /Invalid partial version encoding/,
+    },
+    {
+      description: 'should throw: invalid isNullIndicator=2 for nonce',
+      data: [[toBytes(2)], [], [], [], [], []],
+      shouldThrow: true,
+      expected: null,
+      errorRegex: /Invalid isNullIndicator=2 for nonce/,
+    },
+    {
+      description: 'should throw: invalid isNullIndicator=2 for balance',
+      data: [[], [toBytes(2)], [], [], [], []],
+      shouldThrow: true,
+      expected: null,
+      errorRegex: /Invalid isNullIndicator=2 for balance/,
+    },
+    {
+      description: 'should throw: invalid isNullIndicator=2 for storageRoot',
+      data: [[], [], [toBytes(2)], [], [], []],
+      shouldThrow: true,
+      expected: null,
+      errorRegex: /Invalid isNullIndicator=2 for storageRoot/,
+    },
+    {
+      description: 'should throw: invalid isNullIndicator=2 for codeHash',
+      data: [[], [], [], [toBytes(2)], [], []],
+      shouldThrow: true,
+      expected: null,
+      errorRegex: /Invalid isNullIndicator=2 for codeHash/,
+    },
+    {
+      description: 'should throw: invalid isNullIndicator=2 for codeSize',
+      data: [[], [], [], [], [toBytes(2)], []],
+      shouldThrow: true,
+      expected: null,
+      errorRegex: /Invalid isNullIndicator=2 for codeSize/,
+    },
+    {
+      description: 'should throw: invalid isNullIndicator=2 for version',
+      data: [[], [], [], [], [], [toBytes(2)]],
+      shouldThrow: true,
+      expected: null,
+      errorRegex: /Invalid isNullIndicator=2 for version/,
+    },
+  ]
+
+  for (const { description, data, shouldThrow, expected, errorRegex } of testCases) {
+    it(description, () => {
+      const serialized = RLP.encode(data)
+      if (shouldThrow) {
+        assert.throws(() => createPartialAccountFromRLP(serialized), errorRegex as RegExp)
+      } else {
+        const account = createPartialAccountFromRLP(serialized)
+        assert.deepEqual(account, expected)
+      }
+    })
+  }
+})
+
+describe('serializeWithPartialInfo', () => {
+  const testCases = [
+    {
+      description: 'should serialize all fields as null (isNotNullIndicator=0)',
+      account: new Account(null, null, null, null, null, null),
+      expectedDecoded: [
+        [new Uint8Array()], // Nonce: null
+        [new Uint8Array()], // Balance: null
+        [new Uint8Array()], // StorageRoot: null
+        [new Uint8Array()], // CodeHash: null
+        [new Uint8Array()], // CodeSize: null
+        [new Uint8Array()], // Version: null
+      ],
+    },
+    {
+      description: 'should serialize all fields as non-null (isNotNullIndicator=1)',
+      account: new Account(BigInt(2), Units.ether(1), KECCAK256_RLP, KECCAK256_RLP, 50, 1),
+      expectedDecoded: [
+        [toBytes(1), bigIntToUnpaddedBytes(BigInt(2))], // Nonce: 2
+        [toBytes(1), bigIntToUnpaddedBytes(Units.ether(1))], // Balance: 1000
+        [toBytes(1), KECCAK256_RLP], // StorageRoot: KECCAK256_RLP
+        [toBytes(1), KECCAK256_RLP], // CodeHash: KECCAK256_RLP
+        [toBytes(1), intToUnpaddedBytes(50)], // CodeSize: 50
+        [toBytes(1), intToUnpaddedBytes(1)], // Version: 1
+      ],
+    },
+    {
+      description: 'should serialize mixed null and non-null fields',
+      account: new Account(BigInt(2), null, KECCAK256_RLP, null, 50, null),
+      expectedDecoded: [
+        [toBytes(1), bigIntToUnpaddedBytes(BigInt(2))], // Nonce: 2
+        [new Uint8Array()], // Balance: null
+        [toBytes(1), KECCAK256_RLP], // StorageRoot: KECCAK256_RLP
+        [new Uint8Array()], // CodeHash: null
+        [toBytes(1), intToUnpaddedBytes(50)], // CodeSize: 50
+        [new Uint8Array()], // Version: null
+      ],
+    },
+    {
+      description:
+        'should correctly handle serialization of null hash for storageRoot and codeHash',
+      account: new Account(BigInt(2), Units.ether(1), KECCAK256_RLP, KECCAK256_RLP, 50, 1),
+      expectedDecoded: [
+        [toBytes(1), bigIntToUnpaddedBytes(BigInt(2))], // Nonce: 2
+        [toBytes(1), bigIntToUnpaddedBytes(Units.ether(1))], // Balance: 1000
+        [toBytes(1), KECCAK256_RLP], // StorageRoot: KECCAK256_RLP
+        [toBytes(1), KECCAK256_RLP], // CodeHash: KECCAK256_RLP
+        [toBytes(1), intToUnpaddedBytes(50)], // CodeSize: 50
+        [toBytes(1), intToUnpaddedBytes(1)], // Version: 1
+      ],
+    },
+    {
+      description: 'should correctly serialize when only some fields are provided',
+      account: new Account(BigInt(123), null, KECCAK256_RLP, null, null, 42),
+      expectedDecoded: [
+        [toBytes(1), bigIntToUnpaddedBytes(BigInt(123))], // Nonce: 123
+        [new Uint8Array()], // Balance: null
+        [toBytes(1), KECCAK256_RLP], // StorageRoot: KECCAK256_RLP
+        [new Uint8Array()], // CodeHash: null
+        [new Uint8Array()], // CodeSize: null
+        [toBytes(1), intToUnpaddedBytes(42)], // Version: 42
+      ],
+    },
+  ]
+
+  for (const { description, account, expectedDecoded } of testCases) {
+    it(description, () => {
+      const serialized = account.serializeWithPartialInfo()
+      const decoded = RLP.decode(serialized)
+      assert.deepEqual(decoded, expectedDecoded)
+    })
+  }
+
+  it('should serialize and then deserialize back to the original account object', () => {
+    const account = new Account(BigInt(2), Units.ether(1), KECCAK256_RLP, KECCAK256_RLP, 50, 1)
+    const serialized = account.serializeWithPartialInfo()
+
+    // Now deserialize the serialized data back into a partial account
+    const deserializedAccount = createPartialAccountFromRLP(serialized)
+
+    assert.deepEqual(deserializedAccount, account)
+  })
+})