starknet 4.3.1 → 4.4.0

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+# [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

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__/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,6 +16,7 @@ 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';

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,6 +45,7 @@ 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"));

package/dist/signer/default.d.ts

@@ -3,7 +3,7 @@ import { TypedData } from '../utils/typedData';
 import { SignerInterface } from './interface';
 export declare class Signer implements SignerInterface {
     protected keyPair: KeyPair;
-    constructor(keyPair: KeyPair);
+    constructor(keyPair?: KeyPair);
     getPubKey(): Promise<string>;
     signTransaction(transactions: Invocation[], transactionsDetail: InvocationsSignerDetails, abis?: Abi[]): Promise<Signature>;
     signMessage(typedData: TypedData, accountAddress: string): Promise<Signature>;

package/dist/signer/default.js

@@ -43,6 +43,7 @@ var transaction_1 = require("../utils/transaction");
 var typedData_1 = require("../utils/typedData");
 var Signer = /** @class */ (function () {
     function Signer(keyPair) {
+        if (keyPair === void 0) { keyPair = (0, ellipticCurve_1.genKeyPair)(); }
         this.keyPair = keyPair;
     }
     Signer.prototype.getPubKey = function () {

package/dist/utils/hash.js

@@ -78,13 +78,15 @@ function pedersen(input) {
     for (var i = 0; i < input.length; i += 1) {
         var x = (0, number_1.toBN)(input[i]);
         (0, minimalistic_assert_1.default)(x.gte(constants_1.ZERO) && x.lt((0, number_1.toBN)((0, encode_1.addHexPrefix)(constants_1.FIELD_PRIME))), "Invalid input: ".concat(input[i]));
-        for (var j = 0; j < 252; j += 1) {
-            var pt = constantPoints[2 + i * 252 + j];
-            (0, minimalistic_assert_1.default)(!point.getX().eq(pt.getX()));
-            if (x.and(constants_1.ONE).toNumber() !== 0) {
-                point = point.add(pt);
+        if (!x.isZero()) {
+            for (var j = 0; j < 252; j += 1) {
+                var pt = constantPoints[2 + i * 252 + j];
+                (0, minimalistic_assert_1.default)(!point.getX().eq(pt.getX()));
+                if (x.and(constants_1.ONE).toNumber() !== 0) {
+                    point = point.add(pt);
+                }
+                x = x.shrn(1);
             }
-            x = x.shrn(1);
         }
     }
     return (0, encode_1.addHexPrefix)(point.getX().toString(16));

package/dist/utils/merkle.d.ts

@@ -0,0 +1,10 @@
+export declare class MerkleTree {
+    leaves: string[];
+    branches: string[][];
+    root: string;
+    constructor(leafHashes: string[]);
+    private build;
+    static hash(a: string, b: string): string;
+    getProof(leaf: string, branch?: string[], hashPath?: string[]): string[];
+}
+export declare function proofMerklePath(root: string, leaf: string, path: string[]): boolean;

package/dist/utils/merkle.js

@@ -0,0 +1,90 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proofMerklePath = exports.MerkleTree = void 0;
+var hash_1 = require("./hash");
+var MerkleTree = /** @class */ (function () {
+    function MerkleTree(leafHashes) {
+        this.branches = [];
+        this.leaves = leafHashes;
+        this.root = this.build(leafHashes);
+    }
+    MerkleTree.prototype.build = function (leaves) {
+        if (leaves.length === 1) {
+            return leaves[0];
+        }
+        if (leaves.length !== this.leaves.length) {
+            this.branches.push(leaves);
+        }
+        var newLeaves = [];
+        for (var i = 0; i < leaves.length; i += 2) {
+            if (i + 1 === leaves.length) {
+                newLeaves.push(leaves[i]);
+            }
+            else {
+                newLeaves.push(MerkleTree.hash(leaves[i], leaves[i + 1]));
+            }
+        }
+        return this.build(newLeaves);
+    };
+    MerkleTree.hash = function (a, b) {
+        var _a = __read([a, b].sort(), 2), aSorted = _a[0], bSorted = _a[1];
+        return (0, hash_1.pedersen)([aSorted, bSorted]);
+    };
+    MerkleTree.prototype.getProof = function (leaf, branch, hashPath) {
+        var _a, _b;
+        if (branch === void 0) { branch = this.leaves; }
+        if (hashPath === void 0) { hashPath = []; }
+        var index = branch.indexOf(leaf);
+        if (index === -1) {
+            throw new Error('leaf not found');
+        }
+        if (branch.length === 1) {
+            return hashPath;
+        }
+        var isLeft = index % 2 === 0;
+        var neededBranch = (_a = (isLeft ? branch[index + 1] : branch[index - 1])) !== null && _a !== void 0 ? _a : '0x0';
+        var newHashPath = __spreadArray(__spreadArray([], __read(hashPath), false), [neededBranch], false);
+        var currentBranchLevelIndex = this.leaves.length === branch.length
+            ? -1
+            : this.branches.findIndex(function (b) { return b.length === branch.length; });
+        var nextBranch = (_b = this.branches[currentBranchLevelIndex + 1]) !== null && _b !== void 0 ? _b : [this.root];
+        return this.getProof(neededBranch === '0x0'
+            ? leaf
+            : MerkleTree.hash(isLeft ? leaf : neededBranch, isLeft ? neededBranch : leaf), nextBranch, newHashPath);
+    };
+    return MerkleTree;
+}());
+exports.MerkleTree = MerkleTree;
+function proofMerklePath(root, leaf, path) {
+    if (path.length === 0) {
+        return root === leaf;
+    }
+    var _a = __read(path), next = _a[0], rest = _a.slice(1);
+    return proofMerklePath(root, MerkleTree.hash(leaf, next), rest);
+}
+exports.proofMerklePath = proofMerklePath;

package/dist/utils/number.js

@@ -31,7 +31,7 @@ var bn_js_1 = __importStar(require("bn.js"));
 var minimalistic_assert_1 = __importDefault(require("minimalistic-assert"));
 var encode_1 = require("./encode");
 function isHex(hex) {
-    return hex.startsWith('0x');
+    return /^0x[0-9a-f]*$/i.test(hex);
 }
 exports.isHex = isHex;
 function toBN(number, base) {

package/dist/utils/typedData/index.d.ts

@@ -1,6 +1,12 @@
 import { BigNumberish } from '../number';
-import { TypedData } from './types';
+import { StarkNetMerkleType, StarkNetType, TypedData } from './types';
 export * from './types';
+export declare function prepareSelector(selector: string): string;
+export declare function isMerkleTreeType(type: StarkNetType): type is StarkNetMerkleType;
+interface Context {
+    parent?: string;
+    key?: string;
+}
 /**
  * Get the dependencies of a struct type. If a struct has the same dependency multiple times, it's only included once
  * in the resulting array.
@@ -10,7 +16,7 @@ export * from './types';
  * @param {string[]} [dependencies]
  * @return {string[]}
  */
-export declare const getDependencies: (typedData: TypedData, type: string, dependencies?: string[]) => string[];
+export declare const getDependencies: (types: TypedData['types'], type: string, dependencies?: string[]) => string[];
 /**
  * Encode a type to a string. All dependant types are alphabetically sorted.
  *
@@ -18,7 +24,7 @@ export declare const getDependencies: (typedData: TypedData, type: string, depen
  * @param {string} type
  * @return {string}
  */
-export declare const encodeType: (typedData: TypedData, type: string) => string;
+export declare const encodeType: (types: TypedData['types'], type: string) => string;
 /**
  * Get a type string as hash.
  *
@@ -26,7 +32,17 @@ export declare const encodeType: (typedData: TypedData, type: string) => string;
  * @param {string} type
  * @return {string}
  */
-export declare const getTypeHash: (typedData: TypedData, type: string) => string;
+export declare const getTypeHash: (types: TypedData['types'], type: string) => string;
+/**
+ * Encodes a single value to an ABI serialisable string, number or Buffer. Returns the data as tuple, which consists of
+ * an array of ABI compatible types, and an array of corresponding values.
+ *
+ * @param {TypedData} typedData
+ * @param {string} type
+ * @param {any} data
+ * @returns {[string, string]}
+ */
+export declare const encodeValue: (types: TypedData['types'], type: string, data: unknown, ctx?: Context) => [string, string];
 /**
  * Encode the data to an ABI encoded Buffer. The data should be a key -> value object with all the required values. All
  * dependant types are automatically encoded.
@@ -35,7 +51,7 @@ export declare const getTypeHash: (typedData: TypedData, type: string) => string
  * @param {string} type
  * @param {Record<string, any>} data
  */
-export declare const encodeData: <T extends TypedData>(typedData: T, type: string, data: T["message"]) => string[][];
+export declare const encodeData: <T extends TypedData>(types: T["types"], type: string, data: T["message"]) => string[][];
 /**
  * Get encoded data as a hash. The data should be a key -> value object with all the required values. All dependant
  * types are automatically encoded.
@@ -45,10 +61,9 @@ export declare const encodeData: <T extends TypedData>(typedData: T, type: strin
  * @param {Record<string, any>} data
  * @return {Buffer}
  */
-export declare const getStructHash: <T extends TypedData>(typedData: T, type: string, data: T["message"]) => string;
+export declare const getStructHash: <T extends TypedData>(types: T["types"], type: string, data: T["message"]) => string;
 /**
- * Get the EIP-191 encoded message to sign, from the typedData object. If `hash` is enabled, the message will be hashed
- * with Keccak256.
+ * Get the EIP-191 encoded message to sign, from the typedData object.
  *
  * @param {TypedData} typedData
  * @param {BigNumberish} account