starknet 4.7.0 → 4.9.0

package/__tests__/utils/merkle.test.ts

@@ -1,6 +1,21 @@
+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'];
@@ -38,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);
@@ -52,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);
@@ -70,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);
@@ -86,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');
     });
@@ -99,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')),
       ];
@@ -107,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';
@@ -143,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"`
     );
   });
 });

package/account/default.d.ts

@@ -2,8 +2,9 @@ import { ProviderInterface, ProviderOptions } from '../provider';
 import { Provider } from '../provider/default';
 import { BlockIdentifier } from '../provider/utils';
 import { SignerInterface } from '../signer';
-import { Abi, Call, InvocationsDetails, InvokeFunctionResponse, KeyPair, Signature } from '../types';
+import { Abi, Call, DeclareContractResponse, DeployContractResponse, EstimateFeeAction, InvocationsDetails, InvokeFunctionResponse, KeyPair, Signature } from '../types';
 import { EstimateFee, EstimateFeeDetails } from '../types/account';
+import { AllowArray, DeclareContractPayload, DeployAccountContractPayload } from '../types/lib';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData';
 import { AccountInterface } from './interface';
@@ -12,51 +13,16 @@ export declare class Account extends Provider implements AccountInterface {
     address: string;
     constructor(providerOrOptions: ProviderOptions | ProviderInterface, address: string, keyPairOrSigner: KeyPair | SignerInterface);
     getNonce(blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
-    estimateFee(calls: Call | Call[], { nonce: providedNonce, blockIdentifier }?: EstimateFeeDetails): Promise<EstimateFee>;
-    /**
-     * Invoke execute function in account contract
-     *
-     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/gateway/gateway_client.py#L13-L17)
-     *
-     * @param calls - one or more calls to be executed
-     * @param abis - one or more abis which can be used to display the calls
-     * @param transactionsDetail - optional transaction details
-     * @returns a confirmation of invoking a function on the starknet contract
-     */
-    execute(calls: Call | Call[], abis?: Abi[] | undefined, transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
-    /**
-     * Sign an JSON object with the starknet private key and return the signature
-     *
-     * @param json - JSON object to be signed
-     * @returns the signature of the JSON object
-     * @throws {Error} if the JSON object is not a valid JSON
-     */
+    estimateFee(calls: AllowArray<Call>, estimateFeeDetails?: EstimateFeeDetails | undefined): Promise<EstimateFee>;
+    estimateInvokeFee(calls: AllowArray<Call>, { nonce: providedNonce, blockIdentifier }?: EstimateFeeDetails): Promise<EstimateFee>;
+    estimateDeclareFee({ classHash, contract }: DeclareContractPayload, { blockIdentifier, nonce: providedNonce }?: EstimateFeeDetails): Promise<EstimateFee>;
+    estimateAccountDeployFee({ classHash, addressSalt, constructorCalldata, contractAddress: providedContractAddress, }: DeployAccountContractPayload, { blockIdentifier, nonce: providedNonce }?: EstimateFeeDetails): Promise<EstimateFee>;
+    execute(calls: AllowArray<Call>, abis?: Abi[] | undefined, transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
+    declare({ classHash, contract }: DeclareContractPayload, transactionsDetail?: InvocationsDetails): Promise<DeclareContractResponse>;
+    deployAccount({ classHash, constructorCalldata, addressSalt, contractAddress: providedContractAddress, }: DeployAccountContractPayload, transactionsDetail?: InvocationsDetails): Promise<DeployContractResponse>;
     signMessage(typedData: TypedData): Promise<Signature>;
-    /**
-     * Hash a JSON object with pederson hash and return the hash
-     *
-     * @param json - JSON object to be hashed
-     * @returns the hash of the JSON object
-     * @throws {Error} if the JSON object is not a valid JSON
-     */
     hashMessage(typedData: TypedData): Promise<string>;
-    /**
-     * Verify a signature of a given hash
-     * @warning This method is not recommended, use verifyMessage instead
-     *
-     * @param hash - JSON object to be verified
-     * @param signature - signature of the JSON object
-     * @returns true if the signature is valid, false otherwise
-     * @throws {Error} if the JSON object is not a valid JSON or the signature is not a valid signature
-     */
     verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean>;
-    /**
-     * Verify a signature of a JSON object
-     *
-     * @param hash - hash to be verified
-     * @param signature - signature of the hash
-     * @returns true if the signature is valid, false otherwise
-     * @throws {Error} if the signature is not a valid signature
-     */
     verifyMessage(typedData: TypedData, signature: Signature): Promise<boolean>;
+    getSuggestedMaxFee(estimateFeeAction: EstimateFeeAction, details: EstimateFeeDetails): Promise<string>;
 }