starknet 4.7.0 → 4.9.0

package/__tests__/account.test.ts

@@ -3,7 +3,13 @@ import { isBN } from 'bn.js';
 import typedDataExample from '../__mocks__/typedDataExample.json';
 import { Account, Contract, Provider, number, stark } from '../src';
 import { toBN } from '../src/utils/number';
-import { compiledErc20, compiledTestDapp, getTestAccount, getTestProvider } from './fixtures';
+import {
+  compiledErc20,
+  compiledTestDapp,
+  getERC20DeployPayload,
+  getTestAccount,
+  getTestProvider,
+} from './fixtures';
 
 describe('deploy and test Wallet', () => {
   const provider = getTestProvider();
@@ -15,26 +21,18 @@ describe('deploy and test Wallet', () => {
   beforeAll(async () => {
     expect(account).toBeInstanceOf(Account);
 
-    const erc20Response = await provider.deployContract({
-      contract: compiledErc20,
-    });
+    const erc20DeployPayload = getERC20DeployPayload(account.address);
+
+    const erc20Response = await provider.deployContract(erc20DeployPayload);
 
     erc20Address = erc20Response.contract_address;
     erc20 = new Contract(compiledErc20.abi, erc20Address, provider);
 
     await provider.waitForTransaction(erc20Response.transaction_hash);
 
-    const mintResponse = await account.execute({
-      contractAddress: erc20Address,
-      entrypoint: 'mint',
-      calldata: [account.address, '1000'],
-    });
-
-    await provider.waitForTransaction(mintResponse.transaction_hash);
+    const x = await erc20.balanceOf(account.address);
 
-    const x = await erc20.balance_of(account.address);
-
-    expect(number.toBN(x.res as string).toString()).toStrictEqual(number.toBN(1000).toString());
+    expect(number.toBN(x[0].low).toString()).toStrictEqual(number.toBN(1000).toString());
 
     const dappResponse = await provider.deployContract({
       contract: compiledTestDapp,
@@ -45,34 +43,34 @@ describe('deploy and test Wallet', () => {
   });
 
   test('estimate fee', async () => {
-    const { overall_fee } = await account.estimateFee({
+    const { overall_fee } = await account.estimateInvokeFee({
       contractAddress: erc20Address,
       entrypoint: 'transfer',
-      calldata: [erc20.address, '10'],
+      calldata: [erc20.address, '10', '0'],
     });
     expect(isBN(overall_fee)).toBe(true);
   });
 
   test('read balance of wallet', async () => {
-    const x = await erc20.balance_of(account.address);
+    const x = await erc20.balanceOf(account.address);
 
-    expect(number.toBN(x.res as string).toString()).toStrictEqual(number.toBN(1000).toString());
+    expect(number.toBN(x[0].low).toString()).toStrictEqual(number.toBN(1000).toString());
   });
 
   test('execute by wallet owner', async () => {
     const { transaction_hash } = await account.execute({
       contractAddress: erc20Address,
       entrypoint: 'transfer',
-      calldata: [erc20.address, '10'],
+      calldata: [erc20.address, '10', '0'],
     });
 
     await provider.waitForTransaction(transaction_hash);
   });
 
   test('read balance of wallet after transfer', async () => {
-    const { res } = await erc20.balance_of(account.address);
+    const { balance } = await erc20.balanceOf(account.address);
 
-    expect(res).toStrictEqual(toBN(990));
+    expect(balance.low).toStrictEqual(toBN(990));
   });
 
   test('execute with custom nonce', async () => {
@@ -82,7 +80,7 @@ describe('deploy and test Wallet', () => {
       {
         contractAddress: erc20Address,
         entrypoint: 'transfer',
-        calldata: [account.address, '10'],
+        calldata: [account.address, '10', '0'],
       },
       undefined,
       { nonce }
@@ -130,7 +128,7 @@ describe('deploy and test Wallet', () => {
       const mintResponse = await account.execute({
         contractAddress: erc20Address,
         entrypoint: 'mint',
-        calldata: [wallet, '1000'],
+        calldata: [wallet, '1000', '0'],
       });
 
       await provider.waitForTransaction(mintResponse.transaction_hash);
@@ -143,8 +141,18 @@ describe('deploy and test Wallet', () => {
     });
 
     test('estimate gas fee for `mint`', async () => {
-      const res = await erc20.estimateFee.mint(wallet, '10');
+      const res = await erc20.estimateFee.mint(wallet, ['10', '0']);
       expect(res).toHaveProperty('overall_fee');
     });
+
+    test('Declare Account contract', async () => {
+      const declareTx = await account.declare({
+        contract: compiledErc20,
+        classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',
+      });
+      await provider.waitForTransaction(declareTx.transaction_hash);
+
+      expect(declareTx.class_hash).toBeDefined();
+    });
   });
 });

package/__tests__/contract.test.ts

@@ -1,6 +1,7 @@
 import { isBN } from 'bn.js';
 
 import { Contract, ContractFactory, stark } from '../src';
+import { DeployContractPayload } from '../src/types/lib';
 import { getSelectorFromName } from '../src/utils/hash';
 import { BigNumberish, toBN } from '../src/utils/number';
 import { compileCalldata } from '../src/utils/stark';
@@ -8,6 +9,7 @@ import {
   compiledErc20,
   compiledMulticall,
   compiledTypeTransformation,
+  getERC20DeployPayload,
   getTestProvider,
 } from './fixtures';
 
@@ -21,9 +23,12 @@ describe('class Contract {}', () => {
     let contract: Contract;
 
     beforeAll(async () => {
-      const { transaction_hash, contract_address } = await provider.deployContract({
-        contract: compiledErc20,
-      });
+      const erc20DeployPayload = getERC20DeployPayload(wallet);
+
+      const { contract_address, transaction_hash } = await provider.deployContract(
+        erc20DeployPayload
+      );
+
       erc20 = new Contract(compiledErc20.abi, contract_address!, provider);
       await provider.waitForTransaction(transaction_hash);
       // Deploy Multicall
@@ -39,21 +44,21 @@ describe('class Contract {}', () => {
     });
 
     test('populate transaction for initial balance of that account', async () => {
-      const res = await erc20.populateTransaction.balance_of(wallet);
+      const res = await erc20.populateTransaction.balanceOf(wallet);
       expect(res).toHaveProperty('contractAddress');
       expect(res).toHaveProperty('entrypoint');
       expect(res).toHaveProperty('calldata');
     });
 
     test('estimate gas fee for `mint` should fail when connected to the provider', async () => {
-      expect(erc20.estimateFee.mint(wallet, '10')).rejects.toThrow();
+      expect(erc20.estimateFee.mint(wallet, ['10', '0'])).rejects.toThrow();
     });
 
     test('read initial balance of that account', 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);
     });
 
     test('read balance in a multicall', async () => {
@@ -61,7 +66,7 @@ describe('class Contract {}', () => {
       const args2 = {};
       const calls = [
         erc20.address,
-        getSelectorFromName('balance_of'),
+        getSelectorFromName('balanceOf'),
         Object.keys(args1).length,
         ...compileCalldata(args1),
 
@@ -190,21 +195,27 @@ describe('class Contract {}', () => {
 
 describe('class ContractFactory {}', () => {
   let erc20Address: string;
+  const wallet = stark.randomAddress();
+  let erc20DeployPayload: DeployContractPayload;
+
   beforeAll(async () => {
-    const { transaction_hash, contract_address } = await provider.deployContract({
-      contract: compiledErc20,
-    });
+    erc20DeployPayload = getERC20DeployPayload(wallet);
+
+    const { contract_address, transaction_hash } = await provider.deployContract(
+      erc20DeployPayload
+    );
+
     await provider.waitForTransaction(transaction_hash);
     erc20Address = contract_address;
   });
   test('deployment of new contract', async () => {
     const factory = new ContractFactory(compiledErc20, provider);
-    const erc20 = await factory.deploy();
+    const erc20 = await factory.deploy(erc20DeployPayload.constructorCalldata);
     expect(erc20 instanceof Contract);
   });
   test('wait for deployment transaction', async () => {
     const factory = new ContractFactory(compiledErc20, provider);
-    const contract = await factory.deploy();
+    const contract = await factory.deploy(erc20DeployPayload.constructorCalldata);
     expect(contract.deployed()).resolves.not.toThrow();
   });
   test('attach new contract', async () => {

package/__tests__/defaultProvider.test.ts

@@ -1,15 +1,9 @@
-import {
-  BlockNumber,
-  DeclareContractResponse,
-  DeployContractResponse,
-  GetBlockResponse,
-  stark,
-} from '../src';
+import { BlockNumber, DeployContractResponse, GetBlockResponse, stark } from '../src';
 import { toBN } from '../src/utils/number';
 import {
-  compiledErc20,
   compiledOpenZeppelinAccount,
   describeIfNotDevnet,
+  getERC20DeployPayload,
   getTestProvider,
 } from './fixtures';
 
@@ -24,11 +18,14 @@ describe('defaultProvider', () => {
   let exampleBlock: GetBlockResponse;
   let exampleBlockNumber: BlockNumber;
   let exampleBlockHash: string;
+  const wallet = stark.randomAddress();
 
   beforeAll(async () => {
-    const { transaction_hash, contract_address } = await testProvider.deployContract({
-      contract: compiledErc20,
-    });
+    const erc20DeployPayload = getERC20DeployPayload(wallet);
+
+    const { contract_address, transaction_hash } = await testProvider.deployContract(
+      erc20DeployPayload
+    );
     await testProvider.waitForTransaction(transaction_hash);
     exampleTransactionHash = transaction_hash;
     exampleContractAddress = contract_address;
@@ -58,7 +55,7 @@ describe('defaultProvider', () => {
     });
 
     test('getBlock() -> { blockNumber }', async () => {
-      const block = await testProvider.getBlock();
+      const block = await testProvider.getBlock('latest');
       return expect(block).toHaveProperty('block_number');
     });
 
@@ -101,7 +98,7 @@ describe('defaultProvider', () => {
       return expect(
         testProvider.callContract({
           contractAddress: exampleContractAddress,
-          entrypoint: 'balance_of',
+          entrypoint: 'balanceOf',
           calldata: compileCalldata({
             user: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
           }),
@@ -123,15 +120,6 @@ describe('defaultProvider', () => {
   });
 
   describe('addTransaction()', () => {
-    test('declareContract()', async () => {
-      const response = await testProvider.declareContract({
-        contract: compiledErc20,
-      });
-
-      expect(response.transaction_hash).toBeDefined();
-      expect(response.class_hash).toBeDefined();
-    });
-
     test('deployContract()', async () => {
       const response = await testProvider.deployContract({
         contract: compiledOpenZeppelinAccount,
@@ -147,8 +135,8 @@ describe('defaultProvider', () => {
     let latestBlock;
     describe(`Provider methods if not devnet`, () => {
       describe('getBlock', () => {
-        test('getBlock by tag pending', async () => {
-          latestBlock = await provider.getBlock();
+        test('getBlock by tag latest', async () => {
+          latestBlock = await provider.getBlock('latest');
           expect(latestBlock).toHaveProperty('block_hash');
           expect(latestBlock).toHaveProperty('parent_hash');
           expect(latestBlock).toHaveProperty('block_number');
@@ -221,6 +209,7 @@ describe('defaultProvider', () => {
           expect(transaction.transaction_hash).toBeTruthy();
           expect(transaction.contract_address).toBeTruthy();
           expect(Array.isArray(transaction.calldata)).toBe(true);
+          // expect(transaction.entry_point_selector).toBeTruthy();
           expect(Array.isArray(transaction.signature)).toBe(true);
           expect(transaction.max_fee).toBeTruthy();
         });
@@ -242,34 +231,22 @@ describe('defaultProvider', () => {
           const receipt = await provider.getTransactionReceipt(
             '0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348'
           );
-
           expect(receipt).toHaveProperty('transaction_hash');
           expect(receipt).toHaveProperty('status');
-          expect(receipt).toHaveProperty('status_data');
-          expect(receipt).toHaveProperty('messages_sent');
-          expect(receipt).toHaveProperty('l1_origin_message');
-          expect(receipt).toHaveProperty('events');
+          expect(receipt).toHaveProperty('actual_fee');
         });
       });
 
       describe('Contract methods', () => {
         let contractAddress: string;
         let deployResponse: DeployContractResponse;
-        let declareResponse: DeclareContractResponse;
         let blockNumber: BlockNumber;
 
         beforeAll(async () => {
-          deployResponse = await provider.deployContract({ contract: compiledErc20 });
-          console.log(
-            '🚀 ~ file: defaultProvider.test.ts ~ line 264 ~ beforeAll ~ deployResponse',
-            deployResponse
-          );
+          const erc20DeployPayload = getERC20DeployPayload(wallet);
+          deployResponse = await provider.deployContract(erc20DeployPayload);
           contractAddress = deployResponse.contract_address;
-          declareResponse = await provider.declareContract({ contract: compiledErc20 });
-          await Promise.all([
-            provider.waitForTransaction(deployResponse.transaction_hash),
-            provider.waitForTransaction(declareResponse.transaction_hash),
-          ]);
+          await provider.waitForTransaction(deployResponse.transaction_hash);
           ({ block_number: blockNumber } = await provider.getBlock('latest'));
         });
 
@@ -280,13 +257,6 @@ describe('defaultProvider', () => {
           });
         });
 
-        describe('declareContract', () => {
-          test('response', async () => {
-            expect(declareResponse.class_hash).toBeTruthy();
-            expect(declareResponse.transaction_hash).toBeTruthy();
-          });
-        });
-
         describe('getClassAt', () => {
           test('response', async () => {
             const classResponse = await provider.getClassAt(contractAddress, blockNumber);
@@ -302,9 +272,9 @@ describe('defaultProvider', () => {
               provider
                 .callContract({
                   contractAddress: deployResponse.contract_address,
-                  entrypoint: 'balance_of',
+                  entrypoint: 'balanceOf',
                   calldata: compileCalldata({
-                    user: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
+                    user: wallet,
                   }),
                 })
                 .then((res) => {

package/__tests__/fixtures.ts

@@ -1,13 +1,15 @@
 import fs from 'fs';
 
 import { Account, ProviderInterface, RpcProvider, SequencerProvider, ec, json } from '../src';
-import { CompiledContract } from '../src/types';
+import { CompiledContract, DeployContractPayload } from '../src/types';
+import { encodeShortString } from '../src/utils/shortString';
 
 const readContract = (name: string): CompiledContract =>
   json.parse(fs.readFileSync(`./__mocks__/${name}.json`).toString('ascii'));
 
 export const compiledOpenZeppelinAccount = readContract('Account');
 export const compiledErc20 = readContract('ERC20');
+export const compiledL1L2 = readContract('l1l2_compiled');
 export const compiledTypeTransformation = readContract('contract');
 export const compiledMulticall = readContract('multicall');
 export const compiledTestDapp = readContract('TestDapp');
@@ -26,6 +28,7 @@ const IS_RPC_DEVNET = Boolean(
 );
 const IS_SEQUENCER = !IS_RPC;
 const IS_SEQUENCER_DEVNET = !BASE_URL.includes('starknet.io');
+export const IS_SEQUENCER_GOERLI = BASE_URL === 'https://alpha4.starknet.io';
 export const IS_DEVNET = IS_SEQUENCER ? IS_SEQUENCER_DEVNET : IS_RPC_DEVNET;
 
 export const getTestProvider = () => {
@@ -69,3 +72,10 @@ const describeIf = (condition: boolean) => (condition ? describe : describe.skip
 export const describeIfSequencer = describeIf(IS_DEVNET);
 export const describeIfRpc = describeIf(IS_RPC);
 export const describeIfNotDevnet = describeIf(!IS_DEVNET);
+
+export const getERC20DeployPayload = (recipient: string): DeployContractPayload => {
+  return {
+    contract: compiledErc20,
+    constructorCalldata: [encodeShortString('Token'), encodeShortString('ERC20'), recipient],
+  };
+};

package/__tests__/rpcProvider.test.ts

@@ -1,6 +1,5 @@
 import { Account, GetBlockResponse, RpcProvider, ec } from '../src';
 import {
-  compiledErc20,
   compiledOpenZeppelinAccount,
   describeIfRpc,
   getTestAccount,
@@ -116,20 +115,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 0x0733734fa0dab1158bccdfe0df7b0becf3827f908971fac8d39cc73d99ad8645', async () => {
+      const contractClass = await rpcProvider.getClass(
+        '0x0733734fa0dab1158bccdfe0df7b0becf3827f908971fac8d39cc73d99ad8645'
+      );
+      expect(contractClass).toHaveProperty('program');
+      expect(contractClass).toHaveProperty('entry_points_by_type');
     });
 
     test.todo('getEstimateFee');

package/__tests__/sequencerProvider.test.ts

@@ -1,9 +1,12 @@
 import { Contract, Provider, SequencerProvider, stark } from '../src';
 import { toBN } from '../src/utils/number';
 import {
+  IS_SEQUENCER_GOERLI,
   compiledErc20,
+  compiledL1L2,
   describeIfNotDevnet,
   describeIfSequencer,
+  getERC20DeployPayload,
   getTestProvider,
 } from './fixtures';
 
@@ -17,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
@@ -26,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;
@@ -44,7 +51,7 @@ describeIfSequencer('SequencerProvider', () => {
 
     test('transaction trace', async () => {
       const transactionTrace = await sequencerProvider.getTransactionTrace(exampleTransactionHash);
-      expect(transactionTrace).toHaveProperty('function_invocation');
+      // TODO test optional properties
       expect(transactionTrace).toHaveProperty('signature');
     });
 
@@ -67,19 +74,58 @@ 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);
+    });
+  });
+
+  describe('Test Estimate message fee', () => {
+    const L1_ADDRESS = '0x8359E4B0152ed5A731162D3c7B0D8D56edB165A0';
+    let l1l2ContractAddress: string;
+
+    beforeAll(async () => {
+      if (IS_SEQUENCER_GOERLI) {
+        l1l2ContractAddress = '0x2863141e0d9a74e9b484c1f5b1e3a2f6cbb6b84df8233c7c1cbe31334d9aed8';
+      } else {
+        const { transaction_hash, contract_address } = await sequencerProvider.deployContract({
+          contract: compiledL1L2,
+        });
+        await sequencerProvider.waitForTransaction(transaction_hash);
+        l1l2ContractAddress = contract_address;
+      }
+    });
+
+    test('estimate message fee', async () => {
+      const estimation = await sequencerProvider.estimateMessageFee(
+        {
+          from_address: L1_ADDRESS,
+          to_address: l1l2ContractAddress,
+          entry_point_selector: 'deposit',
+          payload: ['556', '123'],
+        },
+        'latest'
+      );
+      expect(estimation).toEqual(
+        expect.objectContaining({
+          overall_fee: expect.anything(),
+          gas_price: expect.anything(),
+          gas_usage: expect.anything(),
+          unit: 'wei',
+        })
+      );
     });
   });
 });