starknet 4.8.0 → 4.9.0

package/__tests__/account.test.ts

@@ -3,7 +3,13 @@ import { isBN } from 'bn.js';
 import typedDataExample from '../__mocks__/typedDataExample.json';
 import { Account, Contract, Provider, number, stark } from '../src';
 import { toBN } from '../src/utils/number';
-import { compiledErc20, compiledTestDapp, getTestAccount, getTestProvider } from './fixtures';
+import {
+  compiledErc20,
+  compiledTestDapp,
+  getERC20DeployPayload,
+  getTestAccount,
+  getTestProvider,
+} from './fixtures';
 
 describe('deploy and test Wallet', () => {
   const provider = getTestProvider();
@@ -15,26 +21,18 @@ describe('deploy and test Wallet', () => {
   beforeAll(async () => {
     expect(account).toBeInstanceOf(Account);
 
-    const erc20Response = await provider.deployContract({
-      contract: compiledErc20,
-    });
+    const erc20DeployPayload = getERC20DeployPayload(account.address);
+
+    const erc20Response = await provider.deployContract(erc20DeployPayload);
 
     erc20Address = erc20Response.contract_address;
     erc20 = new Contract(compiledErc20.abi, erc20Address, provider);
 
     await provider.waitForTransaction(erc20Response.transaction_hash);
 
-    const mintResponse = await account.execute({
-      contractAddress: erc20Address,
-      entrypoint: 'mint',
-      calldata: [account.address, '1000'],
-    });
-
-    await provider.waitForTransaction(mintResponse.transaction_hash);
+    const x = await erc20.balanceOf(account.address);
 
-    const x = await erc20.balance_of(account.address);
-
-    expect(number.toBN(x.res as string).toString()).toStrictEqual(number.toBN(1000).toString());
+    expect(number.toBN(x[0].low).toString()).toStrictEqual(number.toBN(1000).toString());
 
     const dappResponse = await provider.deployContract({
       contract: compiledTestDapp,
@@ -45,34 +43,34 @@ describe('deploy and test Wallet', () => {
   });
 
   test('estimate fee', async () => {
-    const { overall_fee } = await account.estimateFee({
+    const { overall_fee } = await account.estimateInvokeFee({
       contractAddress: erc20Address,
       entrypoint: 'transfer',
-      calldata: [erc20.address, '10'],
+      calldata: [erc20.address, '10', '0'],
     });
     expect(isBN(overall_fee)).toBe(true);
   });
 
   test('read balance of wallet', async () => {
-    const x = await erc20.balance_of(account.address);
+    const x = await erc20.balanceOf(account.address);
 
-    expect(number.toBN(x.res as string).toString()).toStrictEqual(number.toBN(1000).toString());
+    expect(number.toBN(x[0].low).toString()).toStrictEqual(number.toBN(1000).toString());
   });
 
   test('execute by wallet owner', async () => {
     const { transaction_hash } = await account.execute({
       contractAddress: erc20Address,
       entrypoint: 'transfer',
-      calldata: [erc20.address, '10'],
+      calldata: [erc20.address, '10', '0'],
     });
 
     await provider.waitForTransaction(transaction_hash);
   });
 
   test('read balance of wallet after transfer', async () => {
-    const { res } = await erc20.balance_of(account.address);
+    const { balance } = await erc20.balanceOf(account.address);
 
-    expect(res).toStrictEqual(toBN(990));
+    expect(balance.low).toStrictEqual(toBN(990));
   });
 
   test('execute with custom nonce', async () => {
@@ -82,7 +80,7 @@ describe('deploy and test Wallet', () => {
       {
         contractAddress: erc20Address,
         entrypoint: 'transfer',
-        calldata: [account.address, '10'],
+        calldata: [account.address, '10', '0'],
       },
       undefined,
       { nonce }
@@ -130,7 +128,7 @@ describe('deploy and test Wallet', () => {
       const mintResponse = await account.execute({
         contractAddress: erc20Address,
         entrypoint: 'mint',
-        calldata: [wallet, '1000'],
+        calldata: [wallet, '1000', '0'],
       });
 
       await provider.waitForTransaction(mintResponse.transaction_hash);
@@ -143,8 +141,18 @@ describe('deploy and test Wallet', () => {
     });
 
     test('estimate gas fee for `mint`', async () => {
-      const res = await erc20.estimateFee.mint(wallet, '10');
+      const res = await erc20.estimateFee.mint(wallet, ['10', '0']);
       expect(res).toHaveProperty('overall_fee');
     });
+
+    test('Declare Account contract', async () => {
+      const declareTx = await account.declare({
+        contract: compiledErc20,
+        classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',
+      });
+      await provider.waitForTransaction(declareTx.transaction_hash);
+
+      expect(declareTx.class_hash).toBeDefined();
+    });
   });
 });

package/__tests__/contract.test.ts

@@ -1,6 +1,7 @@
 import { isBN } from 'bn.js';
 
 import { Contract, ContractFactory, stark } from '../src';
+import { DeployContractPayload } from '../src/types/lib';
 import { getSelectorFromName } from '../src/utils/hash';
 import { BigNumberish, toBN } from '../src/utils/number';
 import { compileCalldata } from '../src/utils/stark';
@@ -8,6 +9,7 @@ import {
   compiledErc20,
   compiledMulticall,
   compiledTypeTransformation,
+  getERC20DeployPayload,
   getTestProvider,
 } from './fixtures';
 
@@ -21,9 +23,12 @@ describe('class Contract {}', () => {
     let contract: Contract;
 
     beforeAll(async () => {
-      const { transaction_hash, contract_address } = await provider.deployContract({
-        contract: compiledErc20,
-      });
+      const erc20DeployPayload = getERC20DeployPayload(wallet);
+
+      const { contract_address, transaction_hash } = await provider.deployContract(
+        erc20DeployPayload
+      );
+
       erc20 = new Contract(compiledErc20.abi, contract_address!, provider);
       await provider.waitForTransaction(transaction_hash);
       // Deploy Multicall
@@ -39,21 +44,21 @@ describe('class Contract {}', () => {
     });
 
     test('populate transaction for initial balance of that account', async () => {
-      const res = await erc20.populateTransaction.balance_of(wallet);
+      const res = await erc20.populateTransaction.balanceOf(wallet);
       expect(res).toHaveProperty('contractAddress');
       expect(res).toHaveProperty('entrypoint');
       expect(res).toHaveProperty('calldata');
     });
 
     test('estimate gas fee for `mint` should fail when connected to the provider', async () => {
-      expect(erc20.estimateFee.mint(wallet, '10')).rejects.toThrow();
+      expect(erc20.estimateFee.mint(wallet, ['10', '0'])).rejects.toThrow();
     });
 
     test('read initial balance of that account', async () => {
-      const result = await erc20.balance_of(wallet);
+      const result = await erc20.balanceOf(wallet);
       const [res] = result;
-      expect(res).toStrictEqual(toBN(0));
-      expect(res).toStrictEqual(result.res);
+      expect(res.low).toStrictEqual(toBN(1000));
+      expect(res).toStrictEqual(result.balance);
     });
 
     test('read balance in a multicall', async () => {
@@ -61,7 +66,7 @@ describe('class Contract {}', () => {
       const args2 = {};
       const calls = [
         erc20.address,
-        getSelectorFromName('balance_of'),
+        getSelectorFromName('balanceOf'),
         Object.keys(args1).length,
         ...compileCalldata(args1),
 
@@ -190,21 +195,27 @@ describe('class Contract {}', () => {
 
 describe('class ContractFactory {}', () => {
   let erc20Address: string;
+  const wallet = stark.randomAddress();
+  let erc20DeployPayload: DeployContractPayload;
+
   beforeAll(async () => {
-    const { transaction_hash, contract_address } = await provider.deployContract({
-      contract: compiledErc20,
-    });
+    erc20DeployPayload = getERC20DeployPayload(wallet);
+
+    const { contract_address, transaction_hash } = await provider.deployContract(
+      erc20DeployPayload
+    );
+
     await provider.waitForTransaction(transaction_hash);
     erc20Address = contract_address;
   });
   test('deployment of new contract', async () => {
     const factory = new ContractFactory(compiledErc20, provider);
-    const erc20 = await factory.deploy();
+    const erc20 = await factory.deploy(erc20DeployPayload.constructorCalldata);
     expect(erc20 instanceof Contract);
   });
   test('wait for deployment transaction', async () => {
     const factory = new ContractFactory(compiledErc20, provider);
-    const contract = await factory.deploy();
+    const contract = await factory.deploy(erc20DeployPayload.constructorCalldata);
     expect(contract.deployed()).resolves.not.toThrow();
   });
   test('attach new contract', async () => {

package/__tests__/defaultProvider.test.ts

@@ -1,15 +1,9 @@
-import {
-  BlockNumber,
-  DeclareContractResponse,
-  DeployContractResponse,
-  GetBlockResponse,
-  stark,
-} from '../src';
+import { BlockNumber, DeployContractResponse, GetBlockResponse, stark } from '../src';
 import { toBN } from '../src/utils/number';
 import {
-  compiledErc20,
   compiledOpenZeppelinAccount,
   describeIfNotDevnet,
+  getERC20DeployPayload,
   getTestProvider,
 } from './fixtures';
 
@@ -24,11 +18,14 @@ describe('defaultProvider', () => {
   let exampleBlock: GetBlockResponse;
   let exampleBlockNumber: BlockNumber;
   let exampleBlockHash: string;
+  const wallet = stark.randomAddress();
 
   beforeAll(async () => {
-    const { transaction_hash, contract_address } = await testProvider.deployContract({
-      contract: compiledErc20,
-    });
+    const erc20DeployPayload = getERC20DeployPayload(wallet);
+
+    const { contract_address, transaction_hash } = await testProvider.deployContract(
+      erc20DeployPayload
+    );
     await testProvider.waitForTransaction(transaction_hash);
     exampleTransactionHash = transaction_hash;
     exampleContractAddress = contract_address;
@@ -58,7 +55,7 @@ describe('defaultProvider', () => {
     });
 
     test('getBlock() -> { blockNumber }', async () => {
-      const block = await testProvider.getBlock();
+      const block = await testProvider.getBlock('latest');
       return expect(block).toHaveProperty('block_number');
     });
 
@@ -101,7 +98,7 @@ describe('defaultProvider', () => {
       return expect(
         testProvider.callContract({
           contractAddress: exampleContractAddress,
-          entrypoint: 'balance_of',
+          entrypoint: 'balanceOf',
           calldata: compileCalldata({
             user: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
           }),
@@ -123,15 +120,6 @@ describe('defaultProvider', () => {
   });
 
   describe('addTransaction()', () => {
-    test('declareContract()', async () => {
-      const response = await testProvider.declareContract({
-        contract: compiledErc20,
-      });
-
-      expect(response.transaction_hash).toBeDefined();
-      expect(response.class_hash).toBeDefined();
-    });
-
     test('deployContract()', async () => {
       const response = await testProvider.deployContract({
         contract: compiledOpenZeppelinAccount,
@@ -147,8 +135,8 @@ describe('defaultProvider', () => {
     let latestBlock;
     describe(`Provider methods if not devnet`, () => {
       describe('getBlock', () => {
-        test('getBlock by tag pending', async () => {
-          latestBlock = await provider.getBlock();
+        test('getBlock by tag latest', async () => {
+          latestBlock = await provider.getBlock('latest');
           expect(latestBlock).toHaveProperty('block_hash');
           expect(latestBlock).toHaveProperty('parent_hash');
           expect(latestBlock).toHaveProperty('block_number');
@@ -221,6 +209,7 @@ describe('defaultProvider', () => {
           expect(transaction.transaction_hash).toBeTruthy();
           expect(transaction.contract_address).toBeTruthy();
           expect(Array.isArray(transaction.calldata)).toBe(true);
+          // expect(transaction.entry_point_selector).toBeTruthy();
           expect(Array.isArray(transaction.signature)).toBe(true);
           expect(transaction.max_fee).toBeTruthy();
         });
@@ -242,28 +231,22 @@ describe('defaultProvider', () => {
           const receipt = await provider.getTransactionReceipt(
             '0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348'
           );
-
           expect(receipt).toHaveProperty('transaction_hash');
           expect(receipt).toHaveProperty('status');
-          expect(receipt).toHaveProperty('messages_sent');
-          expect(receipt).toHaveProperty('events');
+          expect(receipt).toHaveProperty('actual_fee');
         });
       });
 
       describe('Contract methods', () => {
         let contractAddress: string;
         let deployResponse: DeployContractResponse;
-        let declareResponse: DeclareContractResponse;
         let blockNumber: BlockNumber;
 
         beforeAll(async () => {
-          deployResponse = await provider.deployContract({ contract: compiledErc20 });
+          const erc20DeployPayload = getERC20DeployPayload(wallet);
+          deployResponse = await provider.deployContract(erc20DeployPayload);
           contractAddress = deployResponse.contract_address;
-          declareResponse = await provider.declareContract({ contract: compiledErc20 });
-          await Promise.all([
-            provider.waitForTransaction(deployResponse.transaction_hash),
-            provider.waitForTransaction(declareResponse.transaction_hash),
-          ]);
+          await provider.waitForTransaction(deployResponse.transaction_hash);
           ({ block_number: blockNumber } = await provider.getBlock('latest'));
         });
 
@@ -274,13 +257,6 @@ describe('defaultProvider', () => {
           });
         });
 
-        describe('declareContract', () => {
-          test('response', async () => {
-            expect(declareResponse.class_hash).toBeTruthy();
-            expect(declareResponse.transaction_hash).toBeTruthy();
-          });
-        });
-
         describe('getClassAt', () => {
           test('response', async () => {
             const classResponse = await provider.getClassAt(contractAddress, blockNumber);
@@ -296,9 +272,9 @@ describe('defaultProvider', () => {
               provider
                 .callContract({
                   contractAddress: deployResponse.contract_address,
-                  entrypoint: 'balance_of',
+                  entrypoint: 'balanceOf',
                   calldata: compileCalldata({
-                    user: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
+                    user: wallet,
                   }),
                 })
                 .then((res) => {

package/__tests__/fixtures.ts

@@ -1,7 +1,8 @@
 import fs from 'fs';
 
 import { Account, ProviderInterface, RpcProvider, SequencerProvider, ec, json } from '../src';
-import { CompiledContract } from '../src/types';
+import { CompiledContract, DeployContractPayload } from '../src/types';
+import { encodeShortString } from '../src/utils/shortString';
 
 const readContract = (name: string): CompiledContract =>
   json.parse(fs.readFileSync(`./__mocks__/${name}.json`).toString('ascii'));
@@ -71,3 +72,10 @@ const describeIf = (condition: boolean) => (condition ? describe : describe.skip
 export const describeIfSequencer = describeIf(IS_DEVNET);
 export const describeIfRpc = describeIf(IS_RPC);
 export const describeIfNotDevnet = describeIf(!IS_DEVNET);
+
+export const getERC20DeployPayload = (recipient: string): DeployContractPayload => {
+  return {
+    contract: compiledErc20,
+    constructorCalldata: [encodeShortString('Token'), encodeShortString('ERC20'), recipient],
+  };
+};

package/__tests__/rpcProvider.test.ts

@@ -1,6 +1,5 @@
 import { Account, GetBlockResponse, RpcProvider, ec } from '../src';
 import {
-  compiledErc20,
   compiledOpenZeppelinAccount,
   describeIfRpc,
   getTestAccount,
@@ -116,20 +115,12 @@ describeIfRpc('RPCProvider', () => {
       });
     });
 
-    describe('declare contract related tests', () => {
-      let class_hash;
-
-      beforeAll(async () => {
-        ({ class_hash } = await rpcProvider.declareContract({
-          contract: compiledErc20,
-        }));
-      });
-
-      test('getClass', async () => {
-        const contractClass = await rpcProvider.getClass(class_hash);
-        expect(contractClass).toHaveProperty('program');
-        expect(contractClass).toHaveProperty('entry_points_by_type');
-      });
+    test('getClass classHash 0x0733734fa0dab1158bccdfe0df7b0becf3827f908971fac8d39cc73d99ad8645', async () => {
+      const contractClass = await rpcProvider.getClass(
+        '0x0733734fa0dab1158bccdfe0df7b0becf3827f908971fac8d39cc73d99ad8645'
+      );
+      expect(contractClass).toHaveProperty('program');
+      expect(contractClass).toHaveProperty('entry_points_by_type');
     });
 
     test.todo('getEstimateFee');

package/__tests__/sequencerProvider.test.ts

@@ -6,6 +6,7 @@ import {
   compiledL1L2,
   describeIfNotDevnet,
   describeIfSequencer,
+  getERC20DeployPayload,
   getTestProvider,
 } from './fixtures';
 
@@ -19,7 +20,7 @@ describeIfSequencer('SequencerProvider', () => {
     sequencerProvider = getTestProvider() as SequencerProvider;
     customSequencerProvider = new Provider({
       sequencer: {
-        baseUrl: 'https://alpha4.starknet.io',
+        baseUrl: 'http://127.0.0.1:5050/',
         feederGatewayUrl: 'feeder_gateway',
         gatewayUrl: 'gateway',
       }, // Similar to arguements used in docs
@@ -28,11 +29,15 @@ describeIfSequencer('SequencerProvider', () => {
 
   describe('Gateway specific methods', () => {
     let exampleTransactionHash: string;
+    const wallet = stark.randomAddress();
 
     beforeAll(async () => {
-      const { transaction_hash, contract_address } = await sequencerProvider.deployContract({
-        contract: compiledErc20,
-      });
+      const erc20DeployPayload = getERC20DeployPayload(wallet);
+
+      const { contract_address, transaction_hash } = await sequencerProvider.deployContract(
+        erc20DeployPayload
+      );
+
       await sequencerProvider.waitForTransaction(transaction_hash);
       exampleTransactionHash = transaction_hash;
       exampleContractAddress = contract_address;
@@ -69,19 +74,21 @@ describeIfSequencer('SequencerProvider', () => {
     const wallet = stark.randomAddress();
 
     beforeAll(async () => {
-      const { contract_address, transaction_hash } = await customSequencerProvider.deployContract({
-        contract: compiledErc20,
-      });
+      const erc20DeployPayload = getERC20DeployPayload(wallet);
+
+      const { contract_address, transaction_hash } = await customSequencerProvider.deployContract(
+        erc20DeployPayload
+      );
 
       await customSequencerProvider.waitForTransaction(transaction_hash);
       erc20 = new Contract(compiledErc20.abi, contract_address, customSequencerProvider);
     });
 
     test('Check ERC20 balance using Custom Sequencer Provider', async () => {
-      const result = await erc20.balance_of(wallet);
+      const result = await erc20.balanceOf(wallet);
       const [res] = result;
-      expect(res).toStrictEqual(toBN(0));
-      expect(res).toStrictEqual(result.res);
+      expect(res.low).toStrictEqual(toBN(1000));
+      expect(res).toStrictEqual(result.balance);
     });
   });
 

package/__tests__/utils/merkle.test.ts

@@ -53,7 +53,7 @@ describe('MerkleTree class', () => {
           MerkleTree.hash(leaves[0], leaves[1]),
           MerkleTree.hash(leaves[2], leaves[3])
         ),
-        MerkleTree.hash(leaves[4], leaves[5])
+        MerkleTree.hash(MerkleTree.hash(leaves[4], leaves[5]), '0x0')
       );
 
       expect(tree.root).toBe(manualMerkle);
@@ -67,7 +67,7 @@ describe('MerkleTree class', () => {
           MerkleTree.hash(leaves[0], leaves[1]),
           MerkleTree.hash(leaves[2], leaves[3])
         ),
-        MerkleTree.hash(MerkleTree.hash(leaves[4], leaves[5]), leaves[6])
+        MerkleTree.hash(MerkleTree.hash(leaves[4], leaves[5]), MerkleTree.hash(leaves[6], '0x0'))
       );
 
       expect(tree.root).toBe(manualMerkle);
@@ -85,7 +85,7 @@ describe('MerkleTree class', () => {
       const manualProof = [
         '0x4',
         MerkleTree.hash('0x1', '0x2'),
-        MerkleTree.hash(MerkleTree.hash('0x5', '0x6'), '0x7'),
+        MerkleTree.hash(MerkleTree.hash('0x5', '0x6'), MerkleTree.hash('0x7', '0x0')),
       ];
 
       expect(proof).toEqual(manualProof);
@@ -101,6 +101,17 @@ describe('MerkleTree class', () => {
 
       expect(proof).toEqual(manualProof);
     });
+    test('should return proof path for valid child', async () => {
+      const proof = tree.getProof('0x5');
+
+      const manualProof = [
+        '0x6',
+        MerkleTree.hash('0x7', '0x0'), // tree should be padded with 0x0 so that all proofs are equals in size
+        MerkleTree.hash(MerkleTree.hash('0x1', '0x2'), MerkleTree.hash('0x3', '0x4')),
+      ];
+
+      expect(proof).toEqual(manualProof);
+    });
     test('should throw for invalid child', () => {
       expect(() => tree.getProof('0x8')).toThrow('leaf not found');
     });
@@ -114,6 +125,7 @@ describe('MerkleTree class', () => {
 
     test('should return true for valid manual proof', async () => {
       const manualProof = [
+        '0x0', // tree should be padded with 0x0 so that all proofs are equals in size
         MerkleTree.hash('0x5', '0x6'),
         MerkleTree.hash(MerkleTree.hash('0x1', '0x2'), MerkleTree.hash('0x3', '0x4')),
       ];
@@ -122,6 +134,17 @@ describe('MerkleTree class', () => {
 
       expect(proofMerklePath(root, leaf, manualProof)).toBe(true);
     });
+    test('should return true for valid manual proof', async () => {
+      const manualProof = [
+        '0x6',
+        MerkleTree.hash('0x7', '0x0'), // tree should be padded with 0x0 so that all proofs are equals in size
+        MerkleTree.hash(MerkleTree.hash('0x1', '0x2'), MerkleTree.hash('0x3', '0x4')),
+      ];
+      const leaf = '0x5';
+      const { root } = tree;
+
+      expect(proofMerklePath(root, leaf, manualProof)).toBe(true);
+    });
     test('should return true for valid proof', async () => {
       const proof = tree.getProof('0x3');
       const leaf = '0x3';
@@ -158,4 +181,76 @@ describe('MerkleTree class', () => {
       expect(proofMerklePath(root, leaf, proof)).toBe(false);
     });
   });
+  describe('verify 2-deep tree with empty data on the right', () => {
+    let tree: MerkleTree;
+    beforeAll(() => {
+      const leaves = ['0x1', '0x2', '0x3'];
+      tree = new MerkleTree(leaves);
+    });
+    test('should return 1-length proof in a 2-length tree', async () => {
+      const proof = tree.getProof('0x3');
+      const manualProof = ['0x0', MerkleTree.hash('0x1', '0x2')];
+      expect(proof).toEqual(manualProof);
+    });
+    test('should check the previous proof works fine', async () => {
+      const manualMerkle = MerkleTree.hash(
+        MerkleTree.hash('0x3', '0x0'),
+        MerkleTree.hash('0x1', '0x2')
+      );
+      expect(tree.root).toBe(manualMerkle);
+    });
+  });
+  describe('verify 3-deep tree with empty data on the right', () => {
+    let tree: MerkleTree;
+    beforeAll(() => {
+      const leaves = ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6'];
+      tree = new MerkleTree(leaves);
+    });
+    test('should return 2-length proof with the 2nd place skipped', async () => {
+      const proof = tree.getProof('0x5');
+      const manualProof = [
+        '0x6',
+        '0x0',
+        MerkleTree.hash(MerkleTree.hash('0x1', '0x2'), MerkleTree.hash('0x3', '0x4')),
+      ];
+      expect(proof).toEqual(manualProof);
+    });
+    test('should check the previous proof works fine', async () => {
+      const manualMerkle = MerkleTree.hash(
+        MerkleTree.hash(MerkleTree.hash('0x5', '0x6'), '0x0'),
+        MerkleTree.hash(MerkleTree.hash('0x1', '0x2'), MerkleTree.hash('0x3', '0x4'))
+      );
+      expect(tree.root).toBe(manualMerkle);
+    });
+  });
+  describe('verify 4-deep tree with empty data on the right', () => {
+    let tree: MerkleTree;
+    beforeAll(() => {
+      const leaves = ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7', '0x8', '0x9'];
+      tree = new MerkleTree(leaves);
+    });
+    test('should return 2-length proof with the 2nd place skipped', async () => {
+      const proof = tree.getProof('0x9');
+      const manualProof = [
+        '0x0',
+        '0x0',
+        '0x0',
+        MerkleTree.hash(
+          MerkleTree.hash(MerkleTree.hash('0x1', '0x2'), MerkleTree.hash('0x3', '0x4')),
+          MerkleTree.hash(MerkleTree.hash('0x5', '0x6'), MerkleTree.hash('0x7', '0x8'))
+        ),
+      ];
+      expect(proof).toEqual(manualProof);
+    });
+    test('should check the previous proof works fine', async () => {
+      const manualMerkle = MerkleTree.hash(
+        MerkleTree.hash(MerkleTree.hash(MerkleTree.hash('0x9', '0x0'), '0x0'), '0x0'),
+        MerkleTree.hash(
+          MerkleTree.hash(MerkleTree.hash('0x1', '0x2'), MerkleTree.hash('0x3', '0x4')),
+          MerkleTree.hash(MerkleTree.hash('0x5', '0x6'), MerkleTree.hash('0x7', '0x8'))
+        )
+      );
+      expect(tree.root).toBe(manualMerkle);
+    });
+  });
 });

package/__tests__/utils/typedData.test.ts

@@ -72,7 +72,7 @@ describe('typedData', () => {
     const [, merkleTreeHash] = encodeValue({}, 'merkletree', tree.leaves);
     expect(merkleTreeHash).toBe(tree.root);
     expect(merkleTreeHash).toMatchInlineSnapshot(
-      `"0x551b4adb6c35d49c686a00b9192da9332b18c9b262507cad0ece37f3b6918d2"`
+      `"0x15ac9e457789ef0c56e5d559809e7336a909c14ee2511503fa7af69be1ba639"`
     );
   });
 
@@ -119,7 +119,7 @@ describe('typedData', () => {
     );
     expect(merkleTreeHash).toBe(tree.root);
     expect(merkleTreeHash).toMatchInlineSnapshot(
-      `"0x75c4f467f4527a5348f3e302007228a6b0057fc4c015f981ffb5b3ace475727"`
+      `"0x12354b159e3799dc0ebe86d62dde4ce7b300538d471e5a7fef23dcbac076011"`
     );
   });
 
@@ -217,7 +217,7 @@ describe('typedData', () => {
       '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826'
     );
     expect(hash).toMatchInlineSnapshot(
-      `"0x1ad0330a62a4a94eae5ea1a7ad96388179d2e4d33e6f909d17421d315110653"`
+      `"0x751fb7d98545f7649d0d0eadc80d770fcd88d8cfaa55590b284f4e1b701ef0a"`
     );
   });
 });