starknet 4.17.0 → 4.18.0

package/__tests__/utils/ellipticalCurve.test.ts

@@ -1,91 +0,0 @@
-import { StarknetChainId } from '../../src/constants';
-import { ec, getKeyPair, getStarkKey, sign, verify } from '../../src/utils/ellipticCurve';
-import { removeHexPrefix } from '../../src/utils/encode';
-import {
-  calculateTransactionHash,
-  computeHashOnElements,
-  pedersen,
-  transactionVersion,
-} from '../../src/utils/hash';
-import { toBN, toHex } from '../../src/utils/number';
-import { fromCallsToExecuteCalldataWithNonce } from '../../src/utils/transaction';
-
-test('getKeyPair()', () => {
-  const privateKey = '0x019800ea6a9a73f94aee6a3d2edf018fc770443e90c7ba121e8303ec6b349279';
-  const pair = getKeyPair(privateKey);
-  // somehow needed, returns error else
-  expect(toHex(toBN(getStarkKey(pair)))).toBe(
-    '0x33f45f07e1bd1a51b45fc24ec8c8c9908db9e42191be9e169bfcac0c0d99745'
-  );
-});
-
-test('pedersen()', () => {
-  const own = pedersen(['0x12773', '0x872362']);
-  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(
-    '0x66bd4335902683054d08a0572747ea78ebd9e531536fb43125424ca9f902084'
-  );
-  expect(array).toStrictEqual(['1', '2', '3', '4']);
-
-  expect(computeHashOnElements(['1', '2'])).toBe(
-    '0x501a3a8e6cd4f5241c639c74052aaa34557aafa84dd4ba983d6443c590ab7df'
-  );
-});
-
-test('hashMessage()', () => {
-  const privateKey = '0x019800ea6a9a73f94aee6a3d2edf018fc770443e90c7ba121e8303ec6b349279';
-  const account = '2007067565103695475819120104515800035851923905855118399071773059478896040938';
-  const transactions = [
-    {
-      contractAddress:
-        '3290661298119599979891444342541795905081168856323302956721669397616389152866',
-      entrypoint: 'set_number',
-      calldata: ['47'],
-    },
-  ];
-  const nonce = '3';
-  const maxFee = '0';
-  const calldata = fromCallsToExecuteCalldataWithNonce(transactions, nonce);
-
-  const hashMsg = calculateTransactionHash(
-    account,
-    transactionVersion,
-    calldata,
-    maxFee,
-    StarknetChainId.TESTNET,
-    nonce
-  );
-
-  expect(hashMsg).toMatchInlineSnapshot(
-    `"0x6d1706bd3d1ba7c517be2a2a335996f63d4738e2f182144d078a1dd9997062e"`
-  );
-  const keyPair = getKeyPair(privateKey);
-  const [r, s] = sign(keyPair, removeHexPrefix(hashMsg));
-  expect(r.toString()).toMatchInlineSnapshot(
-    `"1427981024487605678086498726488552139932400435436186597196374630267616399345"`
-  );
-  expect(s.toString()).toMatchInlineSnapshot(
-    `"1853664302719670721837677288395394946745467311923401353018029119631574115563"`
-  );
-});
-
-test('verify signed message()', () => {
-  const pk = '0x019800ea6a9a73f94aee6a3d2edf018fc770443e90c7ba121e8303ec6b349279';
-  const account = '0x33f45f07e1bd1a51b45fc24ec8c8c9908db9e42191be9e169bfcac0c0d99745';
-  const price = '1';
-  const hashMsg = pedersen([account, price]);
-  const keyPair = getKeyPair(pk);
-  const signature = sign(keyPair, removeHexPrefix(hashMsg));
-  const pubKey = keyPair.getPublic('hex');
-  const pubKeyPair = ec.keyFromPublic(pubKey, 'hex');
-  expect(verify(pubKeyPair, removeHexPrefix(hashMsg), signature)).toBe(true);
-});

package/__tests__/utils/merkle.test.ts

@@ -1,256 +0,0 @@
-import { pedersen } from '../../src/utils/hash';
-import { MerkleTree, proofMerklePath } from '../../src/utils/merkle';
-import { toBN } from '../../src/utils/number';
-
-describe('MerkleTree class', () => {
-  describe('calculate hashes', () => {
-    test('should generate hash with sorted arguments', async () => {
-      let leaves = ['0x12', '0xa']; // 18, 10
-      let merkleHash = MerkleTree.hash(leaves[0], leaves[1]);
-      let rawHash = pedersen([toBN(leaves[1]), toBN(leaves[0])]);
-      expect(merkleHash).toBe(rawHash);
-
-      leaves = ['0x5bb9440e27889a364bcb678b1f679ecd1347acdedcbf36e83494f857cc58026', '0x3'];
-      merkleHash = MerkleTree.hash(leaves[0], leaves[1]);
-      rawHash = pedersen([toBN(leaves[1]), toBN(leaves[0])]);
-      expect(merkleHash).toBe(rawHash);
-    });
-  });
-  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(MerkleTree.hash(leaves[4], leaves[5]), '0x0')
-      );
-
-      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]), MerkleTree.hash(leaves[6], '0x0'))
-      );
-
-      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'), MerkleTree.hash('0x7', '0x0')),
-      ];
-
-      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 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');
-    });
-  });
-  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 = [
-        '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')),
-      ];
-      const leaf = '0x7';
-      const { root } = tree;
-
-      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';
-      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);
-    });
-  });
-  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/shortString.test.ts

@@ -1,22 +0,0 @@
-import { decodeShortString, encodeShortString } from '../../src/utils/shortString';
-
-describe('shortString', () => {
-  test('should convert string to number', () => {
-    expect(encodeShortString('hello')).toMatchInlineSnapshot(`"0x68656c6c6f"`);
-  });
-  test('should convert number to string', () => {
-    expect(decodeShortString('0x68656c6c6f')).toMatchInlineSnapshot(`"hello"`);
-  });
-  test('should throw if string is too long', () => {
-    expect(() =>
-      encodeShortString('hello world hello world hello world hello world hello world hello world')
-    ).toThrowErrorMatchingInlineSnapshot(
-      `"hello world hello world hello world hello world hello world hello world is too long"`
-    );
-  });
-  test('should throw if string contains non ascii chars', () => {
-    expect(() => encodeShortString('hello\uD83D\uDE00')).toThrowErrorMatchingInlineSnapshot(
-      `"hello😀 is not an ASCII string"`
-    );
-  });
-});

package/__tests__/utils/starknetId.test.ts

@@ -1,53 +0,0 @@
-import { BN } from 'bn.js';
-
-import { StarknetChainId } from '../../src/constants';
-import { getStarknetIdContract, useDecoded, useEncoded } from '../../src/utils/starknetId';
-
-function randomWithSeed(seed: number) {
-  const x = Math.sin(seed) * 10000;
-  return x - Math.floor(x);
-}
-
-function generateString(length: number, seed: number): string {
-  const characters = 'abcdefghijklmnopqrstuvwxyz0123456789-这来';
-
-  let result = '';
-  const charactersLength = characters.length;
-  for (let i = 0; i < length; i += 1) {
-    result += characters.charAt(Math.floor(randomWithSeed(seed + i) * charactersLength));
-  }
-
-  return result;
-}
-
-describe('Should tets StarknetId utils', () => {
-  test('Should test useEncoded and useDecoded hook with a random string', () => {
-    for (let index = 0; index < 2500; index += 1) {
-      const randomString = generateString(10, index);
-      expect(useDecoded([useEncoded(randomString)])).toBe(randomString.concat('.stark'));
-    }
-  });
-
-  test('Should test useDecoded and useEncoded hook with an encoded number', () => {
-    for (let index = 0; index < 2500; index += 1) {
-      const decoded = useDecoded([new BN(index)]);
-      expect(useEncoded(decoded.substring(0, decoded.length - 6)).toString()).toBe(
-        index.toString()
-      );
-    }
-  });
-
-  test('Should test getStarknetIdContract', () => {
-    expect(getStarknetIdContract(StarknetChainId.TESTNET)).toBe(
-      '0x05cf267a0af6101667013fc6bd3f6c11116a14cda9b8c4b1198520d59f900b17'
-    );
-
-    expect(() => {
-      getStarknetIdContract(StarknetChainId.TESTNET2);
-    }).toThrow();
-
-    expect(getStarknetIdContract(StarknetChainId.MAINNET)).toBe(
-      '0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678'
-    );
-  });
-});

package/__tests__/utils/transactionHash.test.ts

@@ -1,17 +0,0 @@
-import { StarknetChainId, TransactionHashPrefix } from '../../src/constants';
-import { calculateTransactionHashCommon } from '../../src/utils/hash';
-
-describe('calculateTransactionHashCommon()', () => {
-  test('should match most simple python output', () => {
-    const result = calculateTransactionHashCommon(
-      TransactionHashPrefix.INVOKE,
-      '0x0',
-      '0x2a',
-      '0x64',
-      [],
-      '0x0',
-      StarknetChainId.TESTNET
-    );
-    expect(result).toBe('0x7d260744de9d8c55e7675a34512d1951a7b262c79e685d26599edd2948de959');
-  });
-});

package/__tests__/utils/typedData.test.ts

@@ -1,223 +0,0 @@
-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 {
-  StarkNetDomain,
-  encodeType,
-  encodeValue,
-  getMessageHash,
-  getStructHash,
-  getTypeHash,
-} from '../../src/utils/typedData';
-
-describe('typedData', () => {
-  test('should get right type encoding', () => {
-    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.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.types, 'StarkNetDomain');
-    expect(typeHashDomain).toMatchInlineSnapshot(
-      `"0x1bfc207425a47a5dfa1a50a4f5241203f50624ca5fdf5e18755765416b8e288"`
-    );
-    const typeHashPerson = getTypeHash(typedDataExample.types, 'Person');
-    expect(typeHashPerson).toMatchInlineSnapshot(
-      `"0x2896dbe4b96a67110f454c01e5336edc5bbc3635537efd690f122f4809cc855"`
-    );
-    const typeHashMail = getTypeHash(typedDataExample.types, 'Mail');
-    expect(typeHashMail).toMatchInlineSnapshot(
-      `"0x13d89452df9512bf750f539ba3001b945576243288137ddb6c788457d4b2f79"`
-    );
-    const typeHashPost = getTypeHash(typedDataStructArrayExample.types, 'Post');
-    expect(typeHashPost).toMatchInlineSnapshot(
-      `"0x1d71e69bf476486b43cdcfaf5a85c00bb2d954c042b281040e513080388356d"`
-    );
-    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(
-      `"0x15ac9e457789ef0c56e5d559809e7336a909c14ee2511503fa7af69be1ba639"`
-    );
-  });
-
-  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(
-      `"0x12354b159e3799dc0ebe86d62dde4ce7b300538d471e5a7fef23dcbac076011"`
-    );
-  });
-
-  test('should get right hash for StarkNetDomain', () => {
-    const hash = getStructHash(
-      typedDataExample.types,
-      'StarkNetDomain',
-      typedDataExample.domain as StarkNetDomain
-    );
-    expect(hash).toMatchInlineSnapshot(
-      `"0x54833b121883a3e3aebff48ec08a962f5742e5f7b973469c1f8f4f55d470b07"`
-    );
-  });
-
-  test('should get right hash for entire message', () => {
-    const hash = getMessageHash(typedDataExample, '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826');
-    expect(hash).toMatchInlineSnapshot(
-      `"0x6fcff244f63e38b9d88b9e3378d44757710d1b244282b435cb472053c8d78d0"`
-    );
-
-    const hashStructArr = getMessageHash(
-      typedDataStructArrayExample,
-      '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826'
-    );
-    expect(hashStructArr).toMatchInlineSnapshot(
-      `"0x5914ed2764eca2e6a41eb037feefd3d2e33d9af6225a9e7fe31ac943ff712c"`
-    );
-  });
-
-  interface StringStruct {
-    len: BigNumberish;
-    data: BigNumberish[];
-  }
-  function stringToStringStruct(str: string): StringStruct {
-    const len = str.length;
-    const data = str.split('').map((char) => number.toHex(number.toBN(char.charCodeAt(0))));
-    return { len, data };
-  }
-
-  const typedDataStringExample = {
-    types: {
-      StarkNetDomain: [
-        { name: 'name', type: 'felt' },
-        { name: 'version', type: 'felt' },
-        { name: 'chainId', type: 'felt' },
-      ],
-      Person: [
-        { name: 'name', type: 'felt' },
-        { name: 'wallet', type: 'felt' },
-      ],
-      String: [
-        { name: 'len', type: 'felt' },
-        { name: 'data', type: 'felt*' },
-      ],
-      Mail: [
-        { name: 'from', type: 'Person' },
-        { name: 'to', type: 'Person' },
-        { name: 'contents', type: 'String' },
-      ],
-    },
-    primaryType: 'Mail',
-    domain: {
-      name: 'StarkNet Mail',
-      version: '1',
-      chainId: 1,
-    },
-    message: {
-      from: {
-        name: 'Cow',
-        wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
-      },
-      to: {
-        name: 'Bob',
-        wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
-      },
-      contents: stringToStringStruct(
-        'this is way longer than just 32 characters, to test if that is possible within a typedData struct.'
-      ),
-    },
-  };
-
-  test('should transform strings correctly', () => {
-    const hash = getMessageHash(
-      typedDataStringExample,
-      '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826'
-    );
-    expect(hash).toMatchInlineSnapshot(
-      `"0x70338fb11b8f70b68b261de8a322bcb004bd85e88ac47d9147982c7f5ac66fd"`
-    );
-  });
-
-  test('should transform session message correctly', () => {
-    const hash = getMessageHash(
-      typedDataSessionExample,
-      '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826'
-    );
-    expect(hash).toMatchInlineSnapshot(
-      `"0x751fb7d98545f7649d0d0eadc80d770fcd88d8cfaa55590b284f4e1b701ef0a"`
-    );
-  });
-});