starknet 4.2.0 → 4.4.0

package/CHANGELOG.md

@@ -1,3 +1,47 @@
+# [4.4.0](https://github.com/0xs34n/starknet.js/compare/v4.3.1...v4.4.0) (2022-09-01)
+
+### Bug Fixes
+
+- delete premature session account file ([ca3e70b](https://github.com/0xs34n/starknet.js/commit/ca3e70b06d21dba8b2074512251cf232ed8be46b))
+- session ([00269bf](https://github.com/0xs34n/starknet.js/commit/00269bfd23ed647270a1efd699af7c36978965c7))
+- session account prooving ([0b56833](https://github.com/0xs34n/starknet.js/commit/0b56833f6eb7557d55725a505a01185bbc9756db))
+- tests ([4586e93](https://github.com/0xs34n/starknet.js/commit/4586e93f10a2a43c375a23d851a9778bab412fcc))
+- typo ([1c60a4d](https://github.com/0xs34n/starknet.js/commit/1c60a4d4b306879422769a6c2afc4fd6c39c4c07))
+
+### Features
+
+- add merkle trees ([e9b8674](https://github.com/0xs34n/starknet.js/commit/e9b8674f51c6d6fe57772a4c88b162c5132cfbdd))
+- add visibility modifiers ([cd1a23d](https://github.com/0xs34n/starknet.js/commit/cd1a23d74b49407c27314a12d5bc149ed40209f3))
+- allow merkle trees as native type in eip712 like messages ([65b7766](https://github.com/0xs34n/starknet.js/commit/65b7766c29eca4f4d0e89f6ad1368fedd5e0e18e))
+- session ([9ac48cc](https://github.com/0xs34n/starknet.js/commit/9ac48cc15c1c7b0e504adfc79a7f382f5d0b55d0))
+- session needs to be aware of the whole tree ([11e10bd](https://github.com/0xs34n/starknet.js/commit/11e10bda0f020a670854d941a54142d55936fc18))
+
+## [4.3.1](https://github.com/0xs34n/starknet.js/compare/v4.3.0...v4.3.1) (2022-08-31)
+
+### Bug Fixes
+
+- getClassAt and Test Fixes ([548cf6e](https://github.com/0xs34n/starknet.js/commit/548cf6e69d16292b9c216493c77e1c7a14be2ae9))
+- getCode removed from RPC 0.1.0 ([744a988](https://github.com/0xs34n/starknet.js/commit/744a9882c363331ff47f409971cacbfda977c4c2))
+- merge ([67d87fc](https://github.com/0xs34n/starknet.js/commit/67d87fc834ea5b877029445f39782457584fb4ec))
+- naming ([0c75f6f](https://github.com/0xs34n/starknet.js/commit/0c75f6f431c3828b1078d955123b2d13aef6b5d0))
+- restore GetCode to common interface for backward compatibility ([52f8e61](https://github.com/0xs34n/starknet.js/commit/52f8e61797a3f2390577b3a6e977adae11346a23))
+- rpc 0.1.0 getStorageAt ([c622913](https://github.com/0xs34n/starknet.js/commit/c6229138c57cd9a04b982c386c7278d63b931a1f))
+- **RpcProvider:** update of RpcProvider getBlock method to work with v0.3.0 of pathfinder ([3b12421](https://github.com/0xs34n/starknet.js/commit/3b124219dd25ef5a0c81583fcfe67d6a3cc5a70e))
+- test getBlock('latest') ([2c92f79](https://github.com/0xs34n/starknet.js/commit/2c92f79aefe3af68834aa9a9a16754c0ff4116cc))
+- test getBlock(latest) ([0c5e31e](https://github.com/0xs34n/starknet.js/commit/0c5e31effb63bf7afb26c9f2049b66c93c6b1366))
+- unoptimise getClassAt test to work with integration ([e98220b](https://github.com/0xs34n/starknet.js/commit/e98220bc6e6fff55bc439773bd1258844de312e2))
+
+# [4.3.0](https://github.com/0xs34n/starknet.js/compare/v4.2.0...v4.3.0) (2022-08-09)
+
+### Bug Fixes
+
+- indentations in provider.md ([4a310c6](https://github.com/0xs34n/starknet.js/commit/4a310c6c992c77f9f6729a70c1af14481cd891f7))
+- **sequenceProvider:** feedergatewayUrl and gatewayUrl ([e236d23](https://github.com/0xs34n/starknet.js/commit/e236d2352e3fbb0f78965decac5893217347ceb7))
+
+### Features
+
+- update docs ([28786ed](https://github.com/0xs34n/starknet.js/commit/28786ed550909f6a30b8cb145e93d072ed28a862))
+
 # [4.2.0](https://github.com/0xs34n/starknet.js/compare/v4.1.0...v4.2.0) (2022-08-09)
 
 ### Features

package/__mocks__/typedDataSessionExample.json

@@ -0,0 +1,42 @@
+{
+  "primaryType": "Session",
+  "types": {
+    "Policy": [
+      { "name": "contractAddress", "type": "felt" },
+      { "name": "selector", "type": "selector" }
+    ],
+    "Session": [
+      { "name": "key", "type": "felt" },
+      { "name": "expires", "type": "felt" },
+      { "name": "root", "type": "merkletree", "contains": "Policy" }
+    ],
+    "StarkNetDomain": [
+      { "name": "name", "type": "felt" },
+      { "name": "version", "type": "felt" },
+      { "name": "chain_id", "type": "felt" }
+    ]
+  },
+  "domain": {
+    "name": "StarkNet Mail",
+    "version": "1",
+    "chain_id": 1
+  },
+  "message": {
+    "key": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "expires": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "root": [
+      {
+        "contractAddress": "0x1",
+        "selector": "transfer"
+      },
+      {
+        "contractAddress": "0x2",
+        "selector": "transfer"
+      },
+      {
+        "contractAddress": "0x3",
+        "selector": "transfer"
+      }
+    ]
+  }
+}

package/__tests__/defaultProvider.test.ts

@@ -50,11 +50,11 @@ describe('defaultProvider', () => {
     test('getBlock(blockIdentifier=latest)', async () => {
       expect(exampleBlock).not.toBeNull();
 
-      const { block_number, accepted_time } = exampleBlock;
+      const { block_number, timestamp } = exampleBlock;
 
       expect(typeof block_number).toEqual('number');
 
-      return expect(typeof accepted_time).toEqual('number');
+      return expect(typeof timestamp).toEqual('number');
     });
 
     test('getBlock() -> { blockNumber }', async () => {
@@ -62,11 +62,6 @@ describe('defaultProvider', () => {
       return expect(block).toHaveProperty('block_number');
     });
 
-    test('getCode() -> { bytecode }', async () => {
-      const code = await testProvider.getCode(exampleContractAddress);
-      return expect(Array.isArray(code.bytecode)).toBe(true);
-    });
-
     describe('getStorageAt', () => {
       test('with "key" type of number', () => {
         return expect(testProvider.getStorageAt(exampleContractAddress, 0)).resolves.not.toThrow();
@@ -144,7 +139,7 @@ describe('defaultProvider', () => {
 
   describeIfNotDevnet('Provider', () => {
     const provider = getTestProvider();
-    describe(`Provider methods`, () => {
+    describe(`Provider methods if not devnet`, () => {
       describe('getBlock', () => {
         test('pending', async () => {
           const latestBlock = await provider.getBlock();
@@ -152,11 +147,8 @@ describe('defaultProvider', () => {
           expect(latestBlock).toHaveProperty('parent_hash');
           expect(latestBlock).toHaveProperty('block_number');
           expect(latestBlock).toHaveProperty('status');
-          expect(latestBlock).toHaveProperty('sequencer');
           expect(latestBlock).toHaveProperty('new_root');
-          expect(latestBlock).toHaveProperty('old_root');
-          expect(latestBlock).toHaveProperty('accepted_time');
-          expect(latestBlock).toHaveProperty('gas_price');
+          expect(latestBlock).toHaveProperty('timestamp');
           expect(latestBlock).toHaveProperty('transactions');
           expect(Array.isArray(latestBlock.transactions)).toBe(true);
         });
@@ -170,11 +162,8 @@ describe('defaultProvider', () => {
           expect(block).toHaveProperty('parent_hash');
           expect(block).toHaveProperty('block_number');
           expect(block).toHaveProperty('status');
-          expect(block).toHaveProperty('sequencer');
           expect(block).toHaveProperty('new_root');
-          expect(block).toHaveProperty('old_root');
-          expect(block).toHaveProperty('accepted_time');
-          expect(block).toHaveProperty('gas_price');
+          expect(block).toHaveProperty('timestamp');
           expect(block).toHaveProperty('transactions');
           expect(Array.isArray(block.transactions)).toBe(true);
         });
@@ -185,11 +174,8 @@ describe('defaultProvider', () => {
           expect(block).toHaveProperty('parent_hash');
           expect(block).toHaveProperty('block_number');
           expect(block).toHaveProperty('status');
-          expect(block).toHaveProperty('sequencer');
           expect(block).toHaveProperty('new_root');
-          expect(block).toHaveProperty('old_root');
-          expect(block).toHaveProperty('accepted_time');
-          expect(block).toHaveProperty('gas_price');
+          expect(block).toHaveProperty('timestamp');
           expect(block).toHaveProperty('transactions');
           expect(Array.isArray(block.transactions)).toBe(true);
         });
@@ -199,7 +185,7 @@ describe('defaultProvider', () => {
         test('pending', async () => {
           const storage = await provider.getStorageAt(
             '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
-            0
+            '0'
           );
           expect(typeof storage).toBe('string');
         });
@@ -207,7 +193,7 @@ describe('defaultProvider', () => {
         test('Block Hash 0x7104702055c2a5773a870ceada9552ec659d69c18053b14078983f07527dea8', async () => {
           const storage = await provider.getStorageAt(
             '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
-            0,
+            '0',
             '0x7225762c7ff5e7e5f0867f0a8e73594df4f44f05a65375339a76398e8ae3e64'
           );
           expect(typeof storage).toBe('string');
@@ -245,7 +231,6 @@ describe('defaultProvider', () => {
           expect(transaction.max_fee).toBeTruthy();
           expect(transaction.transaction_hash).toBeTruthy();
           expect(transaction).toHaveProperty('nonce');
-          expect(transaction).toHaveProperty('sender_address');
           expect(transaction).toHaveProperty('version');
         });
       });
@@ -269,6 +254,7 @@ describe('defaultProvider', () => {
         let contractAddress: string;
         let deployResponse: DeployContractResponse;
         let declareResponse: DeclareContractResponse;
+        let blockNumber: BlockNumber;
 
         beforeAll(async () => {
           deployResponse = await provider.deployContract({ contract: compiledErc20 });
@@ -278,6 +264,7 @@ describe('defaultProvider', () => {
             provider.waitForTransaction(deployResponse.transaction_hash),
             provider.waitForTransaction(declareResponse.transaction_hash),
           ]);
+          ({ block_number: blockNumber } = await provider.getBlock('latest'));
         });
 
         describe('deployContract', () => {
@@ -296,7 +283,7 @@ describe('defaultProvider', () => {
 
         describe('getClassAt', () => {
           test('response', async () => {
-            const classResponse = await provider.getClassAt(contractAddress);
+            const classResponse = await provider.getClassAt(contractAddress, blockNumber);
 
             expect(classResponse).toHaveProperty('program');
             expect(classResponse).toHaveProperty('entry_points_by_type');

package/__tests__/rpcProvider.test.ts

@@ -2,15 +2,15 @@ import { RpcProvider } from '../src';
 import { describeIfRpc, getTestProvider } from './fixtures';
 
 describeIfRpc('RPCProvider', () => {
-  let provider: RpcProvider;
+  let rpcProvider: RpcProvider;
 
   beforeAll(async () => {
-    provider = getTestProvider() as RpcProvider;
+    rpcProvider = getTestProvider() as RpcProvider;
   });
 
   describe('RPC methods', () => {
     test('getChainId', async () => {
-      const chainId = await provider.getChainId();
+      const chainId = await rpcProvider.getChainId();
       expect(chainId).toBe('0x534e5f474f45524c49');
     });
   });

package/__tests__/sequencerProvider.test.ts

@@ -1,4 +1,5 @@
-import { SequencerProvider } from '../src';
+import { Contract, Provider, SequencerProvider, stark } from '../src';
+import { toBN } from '../src/utils/number';
 import {
   compiledErc20,
   describeIfNotDevnet,
@@ -6,22 +7,33 @@ import {
   getTestProvider,
 } from './fixtures';
 
+// Run only if Devnet Sequencer
 describeIfSequencer('SequencerProvider', () => {
   let provider: SequencerProvider;
+  let customSequencerProvider: Provider;
+  let exampleContractAddress: string;
 
   beforeAll(async () => {
     provider = getTestProvider() as SequencerProvider;
+    customSequencerProvider = new Provider({
+      sequencer: {
+        baseUrl: 'https://alpha4.starknet.io',
+        feederGatewayUrl: 'feeder_gateway',
+        gatewayUrl: 'gateway',
+      }, // Similar to arguements used in docs
+    });
   });
 
   describe('Gateway specific methods', () => {
     let exampleTransactionHash: string;
 
     beforeAll(async () => {
-      const { transaction_hash } = await provider.deployContract({
+      const { transaction_hash, contract_address } = await provider.deployContract({
         contract: compiledErc20,
       });
       await provider.waitForTransaction(transaction_hash);
       exampleTransactionHash = transaction_hash;
+      exampleContractAddress = contract_address;
     });
 
     test('getTransactionStatus()', async () => {
@@ -34,6 +46,11 @@ describeIfSequencer('SequencerProvider', () => {
       expect(transactionTrace).toHaveProperty('signature');
     });
 
+    test('getCode() -> { bytecode }', async () => {
+      const code = await provider.getCode(exampleContractAddress);
+      return expect(Array.isArray(code.bytecode)).toBe(true);
+    });
+
     describeIfNotDevnet('which are not available on devnet', () => {
       test('getContractAddresses()', async () => {
         const { GpsStatementVerifier, Starknet } = await provider.getContractAddresses();
@@ -42,4 +59,25 @@ describeIfSequencer('SequencerProvider', () => {
       });
     });
   });
+
+  describe('Test calls with Custom Sequencer Provider', () => {
+    let erc20: Contract;
+    const wallet = stark.randomAddress();
+
+    beforeAll(async () => {
+      const { contract_address, transaction_hash } = await customSequencerProvider.deployContract({
+        contract: compiledErc20,
+      });
+
+      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 [res] = result;
+      expect(res).toStrictEqual(toBN(0));
+      expect(res).toStrictEqual(result.res);
+    });
+  });
 });

package/__tests__/utils/__snapshots__/ellipticalCurve.test.ts.snap

@@ -1,3 +1,5 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
 exports[`pedersen() 1`] = `"0x5ed2703dfdb505c587700ce2ebfcab5b3515cd7e6114817e6026ec9d4b364ca"`;
+
+exports[`pedersen() with 0 1`] = `"0x1a5c561f97b52c17a19f34c4499a745cd4e8412e29e4ed5e91e4481c7d53935"`;

package/__tests__/utils/ellipticalCurve.test.ts

@@ -25,6 +25,11 @@ test('pedersen()', () => {
   expect(own).toMatchSnapshot();
 });
 
+test('pedersen() with 0', () => {
+  const own = pedersen(['0x12773', '0x0']);
+  expect(own).toMatchSnapshot();
+});
+
 test('computeHashOnElements()', () => {
   const array = ['1', '2', '3', '4'];
   expect(computeHashOnElements(array)).toBe(

package/__tests__/utils/merkle.test.ts

@@ -0,0 +1,146 @@
+import { MerkleTree, proofMerklePath } from '../../src/utils/merkle';
+
+describe('MerkleTree class', () => {
+  describe('generate roots', () => {
+    test('should generate valid root for 1 elements', async () => {
+      const leaves = ['0x1'];
+      const tree = new MerkleTree(leaves);
+
+      const manualMerkle = leaves[0];
+
+      expect(tree.root).toBe(manualMerkle);
+    });
+    test('should generate valid root for 2 elements', async () => {
+      const leaves = ['0x1', '0x2'];
+      const tree = new MerkleTree(leaves);
+
+      const manualMerkle = MerkleTree.hash(leaves[0], leaves[1]);
+
+      expect(tree.root).toBe(manualMerkle);
+    });
+    test('should generate valid root for 4 elements', async () => {
+      const leaves = ['0x1', '0x2', '0x3', '0x4'];
+      const tree = new MerkleTree(leaves);
+
+      const manualMerkle = MerkleTree.hash(
+        MerkleTree.hash(leaves[0], leaves[1]),
+        MerkleTree.hash(leaves[2], leaves[3])
+      );
+
+      expect(tree.root).toBe(manualMerkle);
+    });
+    test('should generate valid root for 6 elements', async () => {
+      const leaves = ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6'];
+      const tree = new MerkleTree(leaves);
+
+      const manualMerkle = MerkleTree.hash(
+        MerkleTree.hash(
+          MerkleTree.hash(leaves[0], leaves[1]),
+          MerkleTree.hash(leaves[2], leaves[3])
+        ),
+        MerkleTree.hash(leaves[4], leaves[5])
+      );
+
+      expect(tree.root).toBe(manualMerkle);
+    });
+    test('should generate valid root for 7 elements', async () => {
+      const leaves = ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7'];
+      const tree = new MerkleTree(leaves);
+
+      const manualMerkle = MerkleTree.hash(
+        MerkleTree.hash(
+          MerkleTree.hash(leaves[0], leaves[1]),
+          MerkleTree.hash(leaves[2], leaves[3])
+        ),
+        MerkleTree.hash(MerkleTree.hash(leaves[4], leaves[5]), leaves[6])
+      );
+
+      expect(tree.root).toBe(manualMerkle);
+    });
+  });
+  describe('generate proofs', () => {
+    let tree: MerkleTree;
+    beforeAll(() => {
+      const leaves = ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7'];
+      tree = new MerkleTree(leaves);
+    });
+    test('should return proof path for valid child', async () => {
+      const proof = tree.getProof('0x3');
+
+      const manualProof = [
+        '0x4',
+        MerkleTree.hash('0x1', '0x2'),
+        MerkleTree.hash(MerkleTree.hash('0x5', '0x6'), '0x7'),
+      ];
+
+      expect(proof).toEqual(manualProof);
+    });
+    test('should return proof path for valid child', async () => {
+      const proof = tree.getProof('0x7');
+
+      const manualProof = [
+        '0x0', // proofs should always be as long as the tree is deep
+        MerkleTree.hash('0x5', '0x6'),
+        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');
+    });
+  });
+  describe('verify proofs', () => {
+    let tree: MerkleTree;
+    beforeAll(() => {
+      const leaves = ['0x1', '0x2', '0x3', '0x4', '0x5', '0x6', '0x7'];
+      tree = new MerkleTree(leaves);
+    });
+
+    test('should return true for valid manual proof', async () => {
+      const manualProof = [
+        MerkleTree.hash('0x5', '0x6'),
+        MerkleTree.hash(MerkleTree.hash('0x1', '0x2'), MerkleTree.hash('0x3', '0x4')),
+      ];
+      const leaf = '0x7';
+      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';
+      const { root } = tree;
+
+      expect(proofMerklePath(root, leaf, proof)).toBe(true);
+    });
+    test('should return false for invalid proof (root)', async () => {
+      const proof = tree.getProof('0x3');
+      const leaf = '0x3';
+      const root = '0x4';
+
+      expect(proofMerklePath(root, leaf, proof)).toBe(false);
+    });
+    test('should return false for invalid proof (proof[0])', async () => {
+      const proof = tree.getProof('0x3');
+      const leaf = '0x3';
+      const { root } = tree;
+      proof[0] = '0x7';
+      expect(proofMerklePath(root, leaf, proof)).toBe(false);
+    });
+    test('should return false for invalid proof (proof[1])', async () => {
+      const proof = tree.getProof('0x3');
+      const leaf = '0x3';
+      const { root } = tree;
+      proof[1] = '0x4';
+      expect(proofMerklePath(root, leaf, proof)).toBe(false);
+    });
+    test('should return false for invalid proof (proof[2])', async () => {
+      const proof = tree.getProof('0x3');
+      const leaf = '0x3';
+      const { root } = tree;
+      proof[2] = '0x4';
+      expect(proofMerklePath(root, leaf, proof)).toBe(false);
+    });
+  });
+});

package/__tests__/utils/typedData.test.ts

@@ -1,46 +1,134 @@
 import typedDataExample from '../../__mocks__/typedDataExample.json';
+import typedDataSessionExample from '../../__mocks__/typedDataSessionExample.json';
 import typedDataStructArrayExample from '../../__mocks__/typedDataStructArrayExample.json';
 import { number } from '../../src';
+import { getSelectorFromName } from '../../src/utils/hash';
+import { MerkleTree } from '../../src/utils/merkle';
 import { BigNumberish } from '../../src/utils/number';
-import { encodeType, getMessageHash, getStructHash, getTypeHash } from '../../src/utils/typedData';
+import {
+  StarkNetDomain,
+  encodeType,
+  encodeValue,
+  getMessageHash,
+  getStructHash,
+  getTypeHash,
+} from '../../src/utils/typedData';
 
 describe('typedData', () => {
   test('should get right type encoding', () => {
-    const typeEncoding = encodeType(typedDataExample, 'Mail');
+    const typeEncoding = encodeType(typedDataExample.types, 'Mail');
     expect(typeEncoding).toMatchInlineSnapshot(
       `"Mail(from:Person,to:Person,contents:felt)Person(name:felt,wallet:felt)"`
     );
-    const typeEncodingStructArr = encodeType(typedDataStructArrayExample, 'Mail');
+    const typeEncodingStructArr = encodeType(typedDataStructArrayExample.types, 'Mail');
     expect(typeEncodingStructArr).toMatchInlineSnapshot(
       `"Mail(from:Person,to:Person,posts_len:felt,posts:Post*)Person(name:felt,wallet:felt)Post(title:felt,content:felt)"`
     );
   });
 
   test('should get right type hash', () => {
-    const typeHashDomain = getTypeHash(typedDataExample, 'StarkNetDomain');
+    const typeHashDomain = getTypeHash(typedDataExample.types, 'StarkNetDomain');
     expect(typeHashDomain).toMatchInlineSnapshot(
       `"0x1bfc207425a47a5dfa1a50a4f5241203f50624ca5fdf5e18755765416b8e288"`
     );
-    const typeHashPerson = getTypeHash(typedDataExample, 'Person');
+    const typeHashPerson = getTypeHash(typedDataExample.types, 'Person');
     expect(typeHashPerson).toMatchInlineSnapshot(
       `"0x2896dbe4b96a67110f454c01e5336edc5bbc3635537efd690f122f4809cc855"`
     );
-    const typeHashMail = getTypeHash(typedDataExample, 'Mail');
+    const typeHashMail = getTypeHash(typedDataExample.types, 'Mail');
     expect(typeHashMail).toMatchInlineSnapshot(
       `"0x13d89452df9512bf750f539ba3001b945576243288137ddb6c788457d4b2f79"`
     );
-    const typeHashPost = getTypeHash(typedDataStructArrayExample, 'Post');
+    const typeHashPost = getTypeHash(typedDataStructArrayExample.types, 'Post');
     expect(typeHashPost).toMatchInlineSnapshot(
       `"0x1d71e69bf476486b43cdcfaf5a85c00bb2d954c042b281040e513080388356d"`
     );
-    const typeHashMailWithStructArray = getTypeHash(typedDataStructArrayExample, 'Mail');
+    const typeHashMailWithStructArray = getTypeHash(typedDataStructArrayExample.types, 'Mail');
     expect(typeHashMailWithStructArray).toMatchInlineSnapshot(
       `"0x873b878e35e258fc99e3085d5aaad3a81a0c821f189c08b30def2cde55ff27"`
     );
+    const selectorTypeHash = getTypeHash({}, 'selector');
+    expect(selectorTypeHash).toMatchInlineSnapshot(
+      `"0x1d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470"`
+    );
+  });
+
+  test('should transform type selector', () => {
+    const selector = 'transfer';
+    const selectorHash = getSelectorFromName(selector);
+    const rawSelectorValueHash = encodeValue({}, 'felt', selectorHash);
+    const selectorValueHash = encodeValue({}, 'selector', selector);
+    expect(selectorValueHash).toEqual(rawSelectorValueHash);
+    expect(selectorValueHash).toMatchInlineSnapshot(`
+      Array [
+        "felt",
+        "0x83afd3f4caedc6eebf44246fe54e38c95e3179a5ec9ea81740eca5b482d12e",
+      ]
+    `);
+  });
+
+  test('should transform merkle tree', () => {
+    const tree = new MerkleTree(['0x1', '0x2', '0x3']);
+    const [, merkleTreeHash] = encodeValue({}, 'merkletree', tree.leaves);
+    expect(merkleTreeHash).toBe(tree.root);
+    expect(merkleTreeHash).toMatchInlineSnapshot(
+      `"0x551b4adb6c35d49c686a00b9192da9332b18c9b262507cad0ece37f3b6918d2"`
+    );
+  });
+
+  test('should transform merkle tree with custom types', () => {
+    const leaves = [
+      {
+        contractAddress: '0x1',
+        selector: 'transfer',
+      },
+      {
+        contractAddress: '0x2',
+        selector: 'transfer',
+      },
+      {
+        contractAddress: '0x3',
+        selector: 'transfer',
+      },
+    ];
+    const hashedLeaves = leaves.map(
+      (leaf) =>
+        encodeValue(
+          {
+            Policy: [
+              { name: 'contractAddress', type: 'felt' },
+              { name: 'selector', type: 'selector' },
+            ],
+          },
+          'Policy',
+          leaf
+        )[1]
+    );
+    const tree = new MerkleTree(hashedLeaves);
+    const [, merkleTreeHash] = encodeValue(
+      {
+        Parent: [{ name: 'root', type: 'merkletree', contains: 'Policy' }],
+        Policy: [
+          { name: 'contractAddress', type: 'felt' },
+          { name: 'selector', type: 'selector' },
+        ],
+      },
+      'merkletree',
+      leaves,
+      { key: 'root', parent: 'Parent' }
+    );
+    expect(merkleTreeHash).toBe(tree.root);
+    expect(merkleTreeHash).toMatchInlineSnapshot(
+      `"0x75c4f467f4527a5348f3e302007228a6b0057fc4c015f981ffb5b3ace475727"`
+    );
   });
 
   test('should get right hash for StarkNetDomain', () => {
-    const hash = getStructHash(typedDataExample, 'StarkNetDomain', typedDataExample.domain as any);
+    const hash = getStructHash(
+      typedDataExample.types,
+      'StarkNetDomain',
+      typedDataExample.domain as StarkNetDomain
+    );
     expect(hash).toMatchInlineSnapshot(
       `"0x54833b121883a3e3aebff48ec08a962f5742e5f7b973469c1f8f4f55d470b07"`
     );
@@ -122,4 +210,14 @@ describe('typedData', () => {
       `"0x70338fb11b8f70b68b261de8a322bcb004bd85e88ac47d9147982c7f5ac66fd"`
     );
   });
+
+  test('should transform session message correctly', () => {
+    const hash = getMessageHash(
+      typedDataSessionExample,
+      '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826'
+    );
+    expect(hash).toMatchInlineSnapshot(
+      `"0x1ad0330a62a4a94eae5ea1a7ad96388179d2e4d33e6f909d17421d315110653"`
+    );
+  });
 });

package/dist/index.d.ts

@@ -16,8 +16,10 @@ export * as json from './utils/json';
 export * as number from './utils/number';
 export * as transaction from './utils/transaction';
 export * as stark from './utils/stark';
+export * as merkle from './utils/merkle';
 export * as ec from './utils/ellipticCurve';
 export * as uint256 from './utils/uint256';
 export * as shortString from './utils/shortString';
 export * as typedData from './utils/typedData';
 export * from './utils/address';
+export * from './utils/url';

package/dist/index.js

@@ -26,7 +26,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.typedData = exports.shortString = exports.uint256 = exports.ec = exports.stark = exports.transaction = exports.number = exports.json = exports.hash = exports.encode = exports.constants = void 0;
+exports.typedData = exports.shortString = exports.uint256 = exports.ec = exports.merkle = exports.stark = exports.transaction = exports.number = exports.json = exports.hash = exports.encode = exports.constants = void 0;
 /**
  * Main
  */
@@ -45,8 +45,10 @@ exports.json = __importStar(require("./utils/json"));
 exports.number = __importStar(require("./utils/number"));
 exports.transaction = __importStar(require("./utils/transaction"));
 exports.stark = __importStar(require("./utils/stark"));
+exports.merkle = __importStar(require("./utils/merkle"));
 exports.ec = __importStar(require("./utils/ellipticCurve"));
 exports.uint256 = __importStar(require("./utils/uint256"));
 exports.shortString = __importStar(require("./utils/shortString"));
 exports.typedData = __importStar(require("./utils/typedData"));
 __exportStar(require("./utils/address"), exports);
+__exportStar(require("./utils/url"), exports);