starknet 3.0.0 → 3.3.0

package/__tests__/account.test.ts

@@ -1,71 +1,59 @@
-import fs from 'fs';
-
 import typedDataExample from '../__mocks__/typedDataExample.json';
-import {
-  Account,
-  CompiledContract,
-  Contract,
-  compileCalldata,
-  defaultProvider,
-  ec,
-  json,
-  number,
-  stark,
-} from '../src';
+import { Account, Contract, defaultProvider, ec, number, stark } from '../src';
 import { toBN } from '../src/utils/number';
-
-const compiledArgentAccount: CompiledContract = json.parse(
-  fs.readFileSync('./__mocks__/ArgentAccount.json').toString('ascii')
-);
-const compiledErc20: CompiledContract = json.parse(
-  fs.readFileSync('./__mocks__/ERC20.json').toString('ascii')
-);
+import { compiledArgentAccount, compiledErc20, compiledTestDapp } from './fixtures';
 
 describe('deploy and test Wallet', () => {
   const privateKey = stark.randomAddress();
 
   const starkKeyPair = ec.getKeyPair(privateKey);
   const starkKeyPub = ec.getStarkKey(starkKeyPair);
-  let walletAddress: string;
+  let account: Account;
   let erc20: Contract;
   let erc20Address: string;
-  let account: Account;
+  let dapp: Contract;
 
   beforeAll(async () => {
-    const { code: codeErc20, address: erc20AddressLocal } = await defaultProvider.deployContract({
-      contract: compiledErc20,
-    });
-    erc20Address = erc20AddressLocal;
-    erc20 = new Contract(compiledErc20.abi, erc20Address);
-
-    expect(codeErc20).toBe('TRANSACTION_RECEIVED');
-
-    const { code, address: walletAddressLocal } = await defaultProvider.deployContract({
+    const accountResponse = await defaultProvider.deployContract({
       contract: compiledArgentAccount,
-      constructorCalldata: compileCalldata({
-        signer: starkKeyPub,
-        guardian: '0',
-        L1_address: '0',
-      }),
       addressSalt: starkKeyPub,
     });
-    walletAddress = walletAddressLocal;
-    expect(code).toBe('TRANSACTION_RECEIVED');
+    const contract = new Contract(compiledArgentAccount.abi, accountResponse.address);
+    expect(accountResponse.code).toBe('TRANSACTION_RECEIVED');
 
-    const { code: codeErc20Mint, transaction_hash: txErc20Mint } = await erc20.invoke('mint', {
-      recipient: walletAddress,
-      amount: '1000',
+    const initializeResponse = await contract.invoke('initialize', {
+      signer: starkKeyPub,
+      guardian: '0',
     });
+    expect(initializeResponse.code).toBe('TRANSACTION_RECEIVED');
 
-    expect(codeErc20Mint).toBe('TRANSACTION_RECEIVED');
+    account = new Account(defaultProvider, accountResponse.address, starkKeyPair);
+
+    const erc20Response = await defaultProvider.deployContract({
+      contract: compiledErc20,
+    });
+    erc20Address = erc20Response.address;
+    erc20 = new Contract(compiledErc20.abi, erc20Address);
+    expect(erc20Response.code).toBe('TRANSACTION_RECEIVED');
 
-    account = new Account(defaultProvider, walletAddressLocal, starkKeyPair);
+    const mintResponse = await erc20.invoke('mint', {
+      recipient: account.address,
+      amount: '1000',
+    });
+    expect(mintResponse.code).toBe('TRANSACTION_RECEIVED');
 
-    await defaultProvider.waitForTx(txErc20Mint);
+    const dappResponse = await defaultProvider.deployContract({
+      contract: compiledTestDapp,
+    });
+    dapp = new Contract(compiledTestDapp.abi, dappResponse.address);
+    expect(dappResponse.code).toBe('TRANSACTION_RECEIVED');
+    await defaultProvider.waitForTransaction(dappResponse.transaction_hash);
   });
+
   test('same wallet address', () => {
-    expect(walletAddress).toBe(account.address);
+    expect(account.address).toBe(account.address);
   });
+
   test('read nonce', async () => {
     const { result } = await account.callContract({
       contractAddress: account.address,
@@ -75,13 +63,15 @@ describe('deploy and test Wallet', () => {
 
     expect(number.toBN(nonce).toString()).toStrictEqual(number.toBN(0).toString());
   });
+
   test('read balance of wallet', async () => {
     const { res } = await erc20.call('balance_of', {
-      user: walletAddress,
+      user: account.address,
     });
 
     expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(1000).toString());
   });
+
   test('execute by wallet owner', async () => {
     const { code, transaction_hash } = await account.execute({
       contractAddress: erc20Address,
@@ -90,15 +80,17 @@ describe('deploy and test Wallet', () => {
     });
 
     expect(code).toBe('TRANSACTION_RECEIVED');
-    await defaultProvider.waitForTx(transaction_hash);
+    await defaultProvider.waitForTransaction(transaction_hash);
   });
+
   test('read balance of wallet after transfer', async () => {
     const { res } = await erc20.call('balance_of', {
-      user: walletAddress,
+      user: account.address,
     });
 
     expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(990).toString());
   });
+
   test('execute with custom nonce', async () => {
     const { result } = await account.callContract({
       contractAddress: account.address,
@@ -116,8 +108,30 @@ describe('deploy and test Wallet', () => {
     );
 
     expect(code).toBe('TRANSACTION_RECEIVED');
-    await defaultProvider.waitForTx(transaction_hash);
+    await defaultProvider.waitForTransaction(transaction_hash);
   });
+
+  test('execute multiple transactions', async () => {
+    const { code, transaction_hash } = await account.execute([
+      {
+        contractAddress: dapp.connectedTo,
+        entrypoint: 'set_number',
+        calldata: ['47'],
+      },
+      {
+        contractAddress: dapp.connectedTo,
+        entrypoint: 'increase_number',
+        calldata: ['10'],
+      },
+    ]);
+
+    expect(code).toBe('TRANSACTION_RECEIVED');
+    await defaultProvider.waitForTransaction(transaction_hash);
+
+    const response = await dapp.call('get_number', { user: account.address });
+    expect(toBN(response.number as string).toString()).toStrictEqual('57');
+  });
+
   test('sign and verify offchain message', async () => {
     const signature = await account.signMessage(typedDataExample);
 

package/__tests__/accountContract.test.ts

@@ -1,17 +1,6 @@
-import fs from 'fs';
-
-import {
-  CompiledContract,
-  Contract,
-  compileCalldata,
-  defaultProvider,
-  ec,
-  encode,
-  hash,
-  json,
-  number,
-  stark,
-} from '../src';
+import { Contract, defaultProvider, ec, hash, number, stark } from '../src';
+import { transformCallsToMulticallArrays } from '../src/utils/transaction';
+import { compiledArgentAccount, compiledErc20 } from './fixtures';
 
 describe('getStarkAccountFromPrivateKey()', () => {
   test('it works with valid privateKey', () => {
@@ -32,96 +21,87 @@ describe('getStarkAccountFromPrivateKey()', () => {
   });
 });
 
-const compiledArgentAccount: CompiledContract = json.parse(
-  fs.readFileSync('./__mocks__/ArgentAccount.json').toString('ascii')
-);
-const compiledErc20: CompiledContract = json.parse(
-  fs.readFileSync('./__mocks__/ERC20.json').toString('ascii')
-);
-
 describe('deploy and test Wallet', () => {
   const privateKey = stark.randomAddress();
 
   const starkKeyPair = ec.getKeyPair(privateKey);
   const starkKeyPub = ec.getStarkKey(starkKeyPair);
-  let wallet: Contract;
-  let walletAddress: string;
+  let accountContract: Contract;
   let erc20: Contract;
   let erc20Address: string;
-  beforeAll(async () => {
-    const { code: codeErc20, address: erc20AddressLocal } = await defaultProvider.deployContract({
-      contract: compiledErc20,
-    });
-    erc20Address = erc20AddressLocal;
-    erc20 = new Contract(compiledErc20.abi, erc20Address);
-
-    expect(codeErc20).toBe('TRANSACTION_RECEIVED');
 
-    const { code, address: walletAddressLocal } = await defaultProvider.deployContract({
+  beforeAll(async () => {
+    const accountResponse = await defaultProvider.deployContract({
       contract: compiledArgentAccount,
-      constructorCalldata: compileCalldata({
-        signer: starkKeyPub,
-        guardian: '0',
-        L1_address: '0',
-      }),
       addressSalt: starkKeyPub,
     });
-    walletAddress = walletAddressLocal;
-    wallet = new Contract(compiledArgentAccount.abi, walletAddress);
-    expect(code).toBe('TRANSACTION_RECEIVED');
+    accountContract = new Contract(compiledArgentAccount.abi, accountResponse.address);
+    expect(accountResponse.code).toBe('TRANSACTION_RECEIVED');
 
-    const { code: codeErc20Mint, transaction_hash: txErc20Mint } = await erc20.invoke('mint', {
-      recipient: walletAddress,
-      amount: '1000',
+    const initializeResponse = await accountContract.invoke('initialize', {
+      signer: starkKeyPub,
+      guardian: '0',
     });
+    expect(initializeResponse.code).toBe('TRANSACTION_RECEIVED');
 
-    expect(codeErc20Mint).toBe('TRANSACTION_RECEIVED');
+    const erc20Response = await defaultProvider.deployContract({
+      contract: compiledErc20,
+    });
+    erc20Address = erc20Response.address;
+    erc20 = new Contract(compiledErc20.abi, erc20Address);
+    expect(erc20Response.code).toBe('TRANSACTION_RECEIVED');
 
-    await defaultProvider.waitForTx(txErc20Mint);
+    const mintResponse = await erc20.invoke('mint', {
+      recipient: accountContract.connectedTo,
+      amount: '1000',
+    });
+    expect(mintResponse.code).toBe('TRANSACTION_RECEIVED');
+    await defaultProvider.waitForTransaction(mintResponse.transaction_hash);
   });
+
   test('read nonce', async () => {
-    const { nonce } = await wallet.call('get_nonce');
+    const { nonce } = await accountContract.call('get_nonce');
 
     expect(number.toBN(nonce as string).toString()).toStrictEqual(number.toBN(0).toString());
   });
+
   test('read balance of wallet', async () => {
     const { res } = await erc20.call('balance_of', {
-      user: walletAddress,
+      user: accountContract.connectedTo,
     });
 
     expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(1000).toString());
   });
+
   test('execute by wallet owner', async () => {
-    const { nonce } = await wallet.call('get_nonce');
-    const msgHash = encode.addHexPrefix(
-      hash.hashMessage(
-        wallet.connectedTo,
-        erc20Address,
-        stark.getSelectorFromName('transfer'),
-        [erc20Address, '10'],
-        nonce.toString()
-      )
-    );
+    const nonce = (await accountContract.call('get_nonce')).nonce.toString();
+
+    const calls = [
+      { contractAddress: erc20Address, entrypoint: 'transfer', calldata: [erc20Address, '10'] },
+    ];
+    const msgHash = hash.hashMulticall(accountContract.connectedTo, calls, nonce, '0');
+
+    const { callArray, calldata } = transformCallsToMulticallArrays(calls);
 
     const signature = ec.sign(starkKeyPair, msgHash);
-    const { code, transaction_hash } = await wallet.invoke(
-      'execute',
+    const { code, transaction_hash } = await accountContract.invoke(
+      '__execute__',
       {
-        to: erc20Address,
-        selector: stark.getSelectorFromName('transfer'),
-        calldata: [erc20Address, '10'],
-        nonce: nonce.toString(),
+        call_array: callArray,
+        calldata,
+        nonce,
       },
       signature
     );
 
     expect(code).toBe('TRANSACTION_RECEIVED');
 
-    await defaultProvider.waitForTx(transaction_hash);
+    await defaultProvider.waitForTransaction(transaction_hash);
   });
+
   test('read balance of wallet after transfer', async () => {
     const { res } = await erc20.call('balance_of', {
-      user: walletAddress,
+      user: accountContract.connectedTo,
     });
 
     expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(990).toString());
@@ -135,7 +115,7 @@ test('build tx', async () => {
 
   expect(address).toBe('0x04024999b9574cb7623679ce049a609db62a95098982c5b28ac61abdebd1c82b');
 
-  const selector = stark.getSelectorFromName('transfer');
+  const selector = hash.getSelectorFromName('transfer');
 
   expect(selector).toBe(
     number.toHex(
@@ -143,18 +123,19 @@ test('build tx', async () => {
     )
   );
 
-  const msgHash = hash.hashMessage(address, '1', selector, ['6', '7'], '0');
+  const calls = [{ contractAddress: '1', entrypoint: 'transfer', calldata: ['6', '7'] }];
+  const msgHash = hash.hashMulticall(address, calls, '0', '0');
   expect(number.toBN(msgHash).toString()).toStrictEqual(
     number
-      .toBN('2154230509011102177917341711834485670139815171447919056633262592518907948680')
+      .toBN('533725737276146993132325070982049323585915612981489962412873515411469143806')
       .toString()
   );
 
   const [r, s] = ec.sign(keyPair, msgHash);
   expect(r.toString()).toBe(
-    '706800951915233622090196542158919402159816118214143837213294331713137614072'
+    '3081830197073374427897814075820860503521735760640862828374253887454357679197'
   );
   expect(s.toString()).toBe(
-    '1857147121895075123389037565321926580259282654271568123966453051614350474888'
+    '384293936273611705317490990661155378189310283917528660618713929845936492551'
   );
 });

package/__tests__/contract.test.ts

@@ -1,51 +1,198 @@
-import fs from 'fs';
+import { isBN } from 'bn.js';
 
-import { CompiledContract, Contract, defaultProvider, json, number, stark } from '../src';
-
-const compiledERC20: CompiledContract = json.parse(
-  fs.readFileSync('./__mocks__/ERC20.json').toString('ascii')
-);
+import { Contract, defaultProvider, stark } from '../src';
+import { getSelectorFromName } from '../src/utils/hash';
+import { BigNumberish, toBN } from '../src/utils/number';
+import { compileCalldata } from '../src/utils/stark';
+import { compiledErc20, compiledMulticall, compiledTypeTransformation } from './fixtures';
 
 describe('class Contract {}', () => {
   const wallet = stark.randomAddress();
-  let contract: Contract;
-  beforeAll(async () => {
-    const {
-      code,
-      transaction_hash,
-      address: erc20address,
-    } = await defaultProvider.deployContract({
-      contract: compiledERC20,
+
+  describe('Basic Interaction', () => {
+    let erc20: Contract;
+    let contract: Contract;
+
+    beforeAll(async () => {
+      const { code, transaction_hash, address } = await defaultProvider.deployContract({
+        contract: compiledErc20,
+      });
+      erc20 = new Contract(compiledErc20.abi, address, defaultProvider);
+      expect(code).toBe('TRANSACTION_RECEIVED');
+      await defaultProvider.waitForTransaction(transaction_hash);
+
+      // Deploy Multicall
+
+      const {
+        code: m_code,
+        transaction_hash: m_transaction_hash,
+        address: multicallAddress,
+      } = await defaultProvider.deployContract({
+        contract: compiledMulticall,
+      });
+
+      contract = new Contract(compiledMulticall.abi, multicallAddress);
+
+      expect(m_code).toBe('TRANSACTION_RECEIVED');
+
+      await defaultProvider.waitForTransaction(m_transaction_hash);
     });
 
-    contract = new Contract(compiledERC20.abi, erc20address);
+    test('read initial balance of that account', async () => {
+      const { res } = await erc20.call('balance_of', {
+        user: wallet,
+      });
+      expect(res).toStrictEqual(toBN(0));
+    });
 
-    expect(code).toBe('TRANSACTION_RECEIVED');
+    test('add 10 test ERC20 to account', async () => {
+      const response = await erc20.invoke('mint', {
+        recipient: wallet,
+        amount: '10',
+      });
+      expect(response.code).toBe('TRANSACTION_RECEIVED');
 
-    await defaultProvider.waitForTx(transaction_hash);
-  });
-  test('read initial balance of that account', async () => {
-    const response = await contract.call('balance_of', {
-      user: wallet,
+      await defaultProvider.waitForTransaction(response.transaction_hash);
     });
-    expect(number.toBN(response.res as string).toString()).toStrictEqual(number.toBN(0).toString());
-  });
-  test('add 10 test ERC20 to account', async () => {
-    const response = await contract.invoke('mint', {
-      recipient: wallet,
-      amount: '10',
+
+    test('read balance after mint of that account', async () => {
+      const { res } = await erc20.call('balance_of', {
+        user: wallet,
+      });
+
+      expect(res).toStrictEqual(toBN(10));
     });
-    expect(response.code).toBe('TRANSACTION_RECEIVED');
 
-    await defaultProvider.waitForTx(response.transaction_hash);
+    test('read balance in a multicall', async () => {
+      const args1 = { user: wallet };
+      const args2 = {};
+      const calls = [
+        erc20.connectedTo,
+        getSelectorFromName('balance_of'),
+        Object.keys(args1).length,
+        ...compileCalldata(args1),
+
+        erc20.connectedTo,
+        getSelectorFromName('decimals'),
+        Object.keys(args2).length,
+        ...compileCalldata(args2),
+      ];
+      const { block_number, result } = await contract.call('aggregate', { calls });
+      expect(isBN(block_number));
+      expect(Array.isArray(result));
+      (result as BigNumberish[]).forEach((el) => expect(isBN(el)));
+    });
   });
-  test('read balance after mint of that account', async () => {
-    const response = await contract.call('balance_of', {
-      user: wallet,
+
+  describe('Type Transformation', () => {
+    let contract: Contract;
+
+    beforeAll(async () => {
+      const { code, transaction_hash, address } = await defaultProvider.deployContract({
+        contract: compiledTypeTransformation,
+      });
+      contract = new Contract(compiledTypeTransformation.abi, address, defaultProvider);
+      expect(code).toBe('TRANSACTION_RECEIVED');
+      await defaultProvider.waitForTransaction(transaction_hash);
+    });
+
+    describe('Request Type Transformation', () => {
+      test('Parsing the felt in request', async () => {
+        return expect(contract.call('request_felt', { num: 3 })).resolves.not.toThrow();
+      });
+
+      test('Parsing the array of felt in request', async () => {
+        return expect(
+          contract.call('request_array_of_felts', { arr: [1, 2] })
+        ).resolves.not.toThrow();
+      });
+
+      test('Parsing the struct in request', async () => {
+        return expect(
+          contract.call('request_struct', {
+            str: { x: 1, y: 2 },
+          })
+        ).resolves.not.toThrow();
+      });
+
+      test('Parsing the array of structs in request', async () => {
+        return expect(
+          contract.call('request_array_of_structs', { str: [{ x: 1, y: 2 }] })
+        ).resolves.not.toThrow();
+      });
+
+      test('Parsing the nested structs in request', async () => {
+        return expect(
+          contract.call('request_nested_structs', {
+            str: {
+              p1: { x: 1, y: 2 },
+              p2: { x: 3, y: 4 },
+              extra: 5,
+            },
+          })
+        ).resolves.not.toThrow();
+      });
+
+      test('Parsing the tuple in request', async () => {
+        return expect(contract.call('request_tuple', { tup: [1, 2] })).resolves.not.toThrow();
+      });
+
+      test('Parsing the multiple types in request', async () => {
+        return expect(
+          contract.call('request_mixed_types', {
+            num: 2,
+            point: {
+              x: 1,
+              y: 2,
+            },
+            arr: [1],
+          })
+        ).resolves.not.toThrow();
+      });
     });
 
-    expect(number.toBN(response.res as string).toString()).toStrictEqual(
-      number.toBN(10).toString()
-    );
+    describe('Response Type Transformation', () => {
+      test('Parsing the felt in response', async () => {
+        const { res } = await contract.call('get_felt');
+        expect(res).toStrictEqual(toBN(4));
+      });
+
+      test('Parsing the array of felt in response', async () => {
+        const { res } = await contract.call('get_array_of_felts');
+        expect(res).toStrictEqual([toBN(4), toBN(5)]);
+      });
+
+      test('Parsing the array of structs in response', async () => {
+        const { res } = await contract.call('get_struct');
+        expect(res).toStrictEqual({ x: toBN(1), y: toBN(2) });
+      });
+
+      test('Parsing the array of structs in response', async () => {
+        const { res } = await contract.call('get_array_of_structs');
+        expect(res).toStrictEqual([{ x: toBN(1), y: toBN(2) }]);
+      });
+
+      test('Parsing the nested structs in response', async () => {
+        const { res } = await contract.call('get_nested_structs');
+        expect(res).toStrictEqual({
+          p1: { x: toBN(1), y: toBN(2) },
+          p2: { x: toBN(3), y: toBN(4) },
+          extra: toBN(5),
+        });
+      });
+
+      test('Parsing the tuple in response', async () => {
+        const { res } = await contract.call('get_tuple');
+        expect(res).toStrictEqual([toBN(1), toBN(2), toBN(3)]);
+      });
+
+      test('Parsing the multiple types in response', async () => {
+        const { tuple, number, array, point } = await contract.call('get_mixed_types');
+        expect(tuple).toStrictEqual([toBN(1), toBN(2)]);
+        expect(number).toStrictEqual(toBN(3));
+        expect(array).toStrictEqual([toBN(4)]);
+        expect(point).toStrictEqual({ x: toBN(1), y: toBN(2) });
+      });
+    });
   });
 });

package/__tests__/fixtures.ts

@@ -0,0 +1,13 @@
+import fs from 'fs';
+
+import { json } from '../src';
+import { CompiledContract } from '../src/types';
+
+const readContract = (name: string): CompiledContract =>
+  json.parse(fs.readFileSync(`./__mocks__/${name}.json`).toString('ascii'));
+
+export const compiledArgentAccount = readContract('ArgentAccount');
+export const compiledErc20 = readContract('ERC20');
+export const compiledTypeTransformation = readContract('contract');
+export const compiledMulticall = readContract('multicall');
+export const compiledTestDapp = readContract('TestDapp');

package/__tests__/provider.test.ts

@@ -1,10 +1,7 @@
-import fs from 'fs';
+import { defaultProvider, stark } from '../src';
+import { compiledArgentAccount } from './fixtures';
 
-import { CompiledContract, compileCalldata, defaultProvider, json, stark } from '../src';
-
-const compiledArgentAccount = json.parse(
-  fs.readFileSync('./__mocks__/ArgentAccount.json').toString('ascii')
-);
+const { compileCalldata } = stark;
 
 describe('defaultProvider', () => {
   describe('feeder gateway endpoints', () => {
@@ -100,15 +97,8 @@ describe('defaultProvider', () => {
 
   describe('addTransaction()', () => {
     test('deployContract()', async () => {
-      const inputContract = compiledArgentAccount as unknown as CompiledContract;
-
       const response = await defaultProvider.deployContract({
-        contract: inputContract,
-        constructorCalldata: compileCalldata({
-          signer: stark.randomAddress(),
-          guardian: '0',
-          L1_address: '0',
-        }),
+        contract: compiledArgentAccount,
       });
 
       expect(response.code).toBe('TRANSACTION_RECEIVED');