starknet 4.8.0 → 4.10.0

package/__tests__/rpcProvider.test.ts

@@ -1,6 +1,6 @@
 import { Account, GetBlockResponse, RpcProvider, ec } from '../src';
+import { StarknetChainId } from '../src/constants';
 import {
-  compiledErc20,
   compiledOpenZeppelinAccount,
   describeIfRpc,
   getTestAccount,
@@ -23,7 +23,7 @@ describeIfRpc('RPCProvider', () => {
 
   test('getChainId', async () => {
     const chainId = await rpcProvider.getChainId();
-    expect(chainId).toBe('0x534e5f474f45524c49');
+    expect(chainId).toBe(StarknetChainId.TESTNET2);
   });
 
   test('getPendingTransactions', async () => {
@@ -116,20 +116,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 0x00808396477a4296946bf6574afb2e14723f8d9a37bba25a1e104315ca89b1f7', async () => {
+      const contractClass = await rpcProvider.getClass(
+        '0x00808396477a4296946bf6574afb2e14723f8d9a37bba25a1e104315ca89b1f7'
+      );
+      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__/udc.test.ts

@@ -0,0 +1,41 @@
+import { encodeShortString } from '../src/utils/shortString';
+import { randomAddress } from '../src/utils/stark';
+import { IS_DEVNET, compiledErc20, getTestAccount, getTestProvider } from './fixtures';
+
+describe('Declare and UDC Deploy Flow', () => {
+  const provider = getTestProvider();
+  const account = getTestAccount(provider);
+  const erc20ClassHash = '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a';
+
+  test('ERC20 Declare', async () => {
+    const declareTx = await account.declare({
+      classHash: erc20ClassHash,
+      contract: compiledErc20,
+    });
+
+    await provider.waitForTransaction(declareTx.transaction_hash);
+
+    expect(declareTx).toHaveProperty('class_hash');
+    expect(declareTx.class_hash).toEqual(erc20ClassHash);
+  });
+
+  test('UDC Deploy', async () => {
+    const salt = randomAddress(); // use random salt
+
+    const deployment = await account.deploy({
+      classHash: erc20ClassHash,
+      constructorCalldata: [
+        encodeShortString('Token'),
+        encodeShortString('ERC20'),
+        account.address,
+      ],
+      salt,
+      unique: true, // Using true here so as not to clash with normal erc20 deploy in account and provider test
+      isDevnet: IS_DEVNET,
+    });
+
+    await provider.waitForTransaction(deployment.transaction_hash);
+
+    expect(deployment).toHaveProperty('transaction_hash');
+  });
+});

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"`
     );
   });
 });

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, UniversalDeployerContractPayload } from '../types/lib';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData';
 import { AccountInterface } from './interface';
@@ -12,51 +13,18 @@ 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>;
+    deploy({ classHash, salt, unique, constructorCalldata, isDevnet, }: UniversalDeployerContractPayload, additionalCalls?: AllowArray<Call>, // support multicall
+    transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
+    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>;
 }