starknet 3.12.2 → 3.13.1

package/__tests__/account.test.ts

@@ -1,49 +1,52 @@
 import { isBN } from 'bn.js';
 
 import typedDataExample from '../__mocks__/typedDataExample.json';
-import { Account, Contract, defaultProvider, ec, number, stark } from '../src';
+import { Account, Contract, Provider, ec, number, stark } from '../src';
 import { toBN } from '../src/utils/number';
-import { compiledArgentAccount, compiledErc20, compiledTestDapp } from './fixtures';
+import {
+  compiledErc20,
+  compiledOpenZeppelinAccount,
+  compiledTestDapp,
+  getTestAccount,
+  getTestProvider,
+} from './fixtures';
 
 describe('deploy and test Wallet', () => {
-  const privateKey = stark.randomAddress();
-
-  const starkKeyPair = ec.getKeyPair(privateKey);
-  const starkKeyPub = ec.getStarkKey(starkKeyPair);
-  let account: Account;
+  const account: Account = getTestAccount();
+  const provider = getTestProvider();
   let erc20: Contract;
   let erc20Address: string;
   let dapp: Contract;
 
   beforeAll(async () => {
-    const accountResponse = await defaultProvider.deployContract({
-      contract: compiledArgentAccount,
-      addressSalt: starkKeyPub,
-    });
-    const contract = new Contract(compiledArgentAccount.abi, accountResponse.address);
-    expect(accountResponse.code).toBe('TRANSACTION_RECEIVED');
-
-    const initializeResponse = await contract.initialize(starkKeyPub, '0');
-    expect(initializeResponse.code).toBe('TRANSACTION_RECEIVED');
-
-    account = new Account(defaultProvider, accountResponse.address, starkKeyPair);
+    expect(account).toBeInstanceOf(Account);
 
-    const erc20Response = await defaultProvider.deployContract({
+    const erc20Response = await provider.deployContract({
       contract: compiledErc20,
     });
     erc20Address = erc20Response.address;
     erc20 = new Contract(compiledErc20.abi, erc20Address);
     expect(erc20Response.code).toBe('TRANSACTION_RECEIVED');
 
-    const mintResponse = await erc20.mint(account.address, '1000');
+    await provider.waitForTransaction(erc20Response.transaction_hash);
+
+    const mintResponse = await account.execute({
+      contractAddress: erc20Address,
+      entrypoint: 'mint',
+      calldata: [account.address, '1000'],
+    });
+
     expect(mintResponse.code).toBe('TRANSACTION_RECEIVED');
 
-    const dappResponse = await defaultProvider.deployContract({
+    await provider.waitForTransaction(mintResponse.transaction_hash);
+
+    const dappResponse = await provider.deployContract({
       contract: compiledTestDapp,
     });
     dapp = new Contract(compiledTestDapp.abi, dappResponse.address);
     expect(dappResponse.code).toBe('TRANSACTION_RECEIVED');
-    await defaultProvider.waitForTransaction(dappResponse.transaction_hash);
+
+    await provider.waitForTransaction(dappResponse.transaction_hash);
   });
 
   test('estimate fee', async () => {
@@ -56,20 +59,6 @@ describe('deploy and test Wallet', () => {
     expect(typeof unit).toBe('string');
   });
 
-  test('same wallet address', () => {
-    expect(account.address).toBe(account.address);
-  });
-
-  test('read nonce', async () => {
-    const { result } = await account.callContract({
-      contractAddress: account.address,
-      entrypoint: 'get_nonce',
-    });
-    const nonce = result[0];
-
-    expect(number.toBN(nonce).toString()).toStrictEqual(number.toBN(0).toString());
-  });
-
   test('read balance of wallet', async () => {
     const { res } = await erc20.balance_of(account.address);
 
@@ -77,18 +66,14 @@ describe('deploy and test Wallet', () => {
   });
 
   test('execute by wallet owner', async () => {
-    const { code, transaction_hash } = await account.execute(
-      {
-        contractAddress: erc20Address,
-        entrypoint: 'transfer',
-        calldata: [erc20.address, '10'],
-      },
-      undefined,
-      { maxFee: '0' }
-    );
+    const { code, transaction_hash } = await account.execute({
+      contractAddress: erc20Address,
+      entrypoint: 'transfer',
+      calldata: [erc20.address, '10'],
+    });
 
     expect(code).toBe('TRANSACTION_RECEIVED');
-    await defaultProvider.waitForTransaction(transaction_hash);
+    await provider.waitForTransaction(transaction_hash);
   });
 
   test('read balance of wallet after transfer', async () => {
@@ -110,33 +95,29 @@ describe('deploy and test Wallet', () => {
         calldata: [account.address, '10'],
       },
       undefined,
-      { nonce, maxFee: '0' }
+      { nonce }
     );
 
     expect(code).toBe('TRANSACTION_RECEIVED');
-    await defaultProvider.waitForTransaction(transaction_hash);
+    await provider.waitForTransaction(transaction_hash);
   });
 
   test('execute multiple transactions', async () => {
-    const { code, transaction_hash } = await account.execute(
-      [
-        {
-          contractAddress: dapp.address,
-          entrypoint: 'set_number',
-          calldata: ['47'],
-        },
-        {
-          contractAddress: dapp.address,
-          entrypoint: 'increase_number',
-          calldata: ['10'],
-        },
-      ],
-      undefined,
-      { maxFee: '0' }
-    );
+    const { code, transaction_hash } = await account.execute([
+      {
+        contractAddress: dapp.address,
+        entrypoint: 'set_number',
+        calldata: ['47'],
+      },
+      {
+        contractAddress: dapp.address,
+        entrypoint: 'increase_number',
+        calldata: ['10'],
+      },
+    ]);
 
     expect(code).toBe('TRANSACTION_RECEIVED');
-    await defaultProvider.waitForTransaction(transaction_hash);
+    await provider.waitForTransaction(transaction_hash);
 
     const response = await dapp.get_number(account.address);
     expect(toBN(response.number as string).toString()).toStrictEqual('57');
@@ -147,4 +128,60 @@ describe('deploy and test Wallet', () => {
 
     expect(await account.verifyMessage(typedDataExample, signature)).toBe(true);
   });
+
+  describe('new deployed account', () => {
+    let newAccount: Account;
+
+    beforeAll(async () => {
+      const starkKeyPair = ec.genKeyPair();
+      const starkKeyPub = ec.getStarkKey(starkKeyPair);
+
+      const accountResponse = await provider.deployContract({
+        contract: compiledOpenZeppelinAccount,
+        constructorCalldata: [starkKeyPub],
+      });
+
+      await provider.waitForTransaction(accountResponse.transaction_hash);
+
+      newAccount = new Account(provider, accountResponse.address, starkKeyPair);
+    });
+
+    test('read nonce', async () => {
+      const { result } = await account.callContract({
+        contractAddress: newAccount.address,
+        entrypoint: 'get_nonce',
+      });
+      const nonce = result[0];
+
+      expect(number.toBN(nonce).toString()).toStrictEqual(number.toBN(0).toString());
+    });
+  });
+
+  describe('Contract interaction with Account', () => {
+    const wallet = stark.randomAddress();
+
+    beforeAll(async () => {
+      const mintResponse = await account.execute({
+        contractAddress: erc20Address,
+        entrypoint: 'mint',
+        calldata: [wallet, '1000'],
+      });
+
+      expect(mintResponse.code).toBe('TRANSACTION_RECEIVED');
+
+      await provider.waitForTransaction(mintResponse.transaction_hash);
+    });
+
+    test('change from provider to account', async () => {
+      expect(erc20.providerOrAccount instanceof Provider);
+      erc20.connect(account);
+      expect(erc20.providerOrAccount instanceof Account);
+    });
+
+    test('estimate gas fee for `mint`', async () => {
+      const res = await erc20.estimateFee.mint(wallet, '10');
+      expect(res).toHaveProperty('amount');
+      expect(res).toHaveProperty('unit');
+    });
+  });
 });

package/__tests__/contract.test.ts

@@ -1,16 +1,19 @@
 import { isBN } from 'bn.js';
 
-import { Account, Contract, ContractFactory, Provider, defaultProvider, ec, stark } from '../src';
+import { Account, Contract, ContractFactory, Provider, stark } from '../src';
 import { getSelectorFromName } from '../src/utils/hash';
 import { BigNumberish, toBN } from '../src/utils/number';
 import { compileCalldata } from '../src/utils/stark';
 import {
-  compiledArgentAccount,
   compiledErc20,
   compiledMulticall,
   compiledTypeTransformation,
+  getTestAccount,
+  getTestProvider,
 } from './fixtures';
 
+const provider = getTestProvider();
+
 describe('class Contract {}', () => {
   const wallet = stark.randomAddress();
 
@@ -19,27 +22,27 @@ describe('class Contract {}', () => {
     let contract: Contract;
 
     beforeAll(async () => {
-      const { code, transaction_hash, address } = await defaultProvider.deployContract({
+      const { code, transaction_hash, address } = await provider.deployContract({
         contract: compiledErc20,
       });
-      erc20 = new Contract(compiledErc20.abi, address, defaultProvider);
+      erc20 = new Contract(compiledErc20.abi, address!, provider);
       expect(code).toBe('TRANSACTION_RECEIVED');
-      await defaultProvider.waitForTransaction(transaction_hash);
+      await provider.waitForTransaction(transaction_hash);
       // Deploy Multicall
 
       const {
         code: m_code,
         transaction_hash: m_transaction_hash,
         address: multicallAddress,
-      } = await defaultProvider.deployContract({
+      } = await provider.deployContract({
         contract: compiledMulticall,
       });
 
-      contract = new Contract(compiledMulticall.abi, multicallAddress);
+      contract = new Contract(compiledMulticall.abi, multicallAddress!);
 
       expect(m_code).toBe('TRANSACTION_RECEIVED');
 
-      await defaultProvider.waitForTransaction(m_transaction_hash);
+      await provider.waitForTransaction(m_transaction_hash);
     });
 
     test('populate transaction for initial balance of that account', async () => {
@@ -61,20 +64,6 @@ describe('class Contract {}', () => {
       expect(res).toStrictEqual(result.res);
     });
 
-    test('add 10 test ERC20 to account', async () => {
-      const response = await erc20.mint(wallet, '10');
-      expect(response.code).toBe('TRANSACTION_RECEIVED');
-
-      await defaultProvider.waitForTransaction(response.transaction_hash);
-    });
-
-    test('read balance after mint of that account', async () => {
-      const result = await erc20.balance_of(wallet);
-      const [res] = result;
-      expect(res).toStrictEqual(toBN(10));
-      expect(res).toStrictEqual(result.res);
-    });
-
     test('read balance in a multicall', async () => {
       const args1 = { user: wallet };
       const args2 = {};
@@ -103,12 +92,12 @@ describe('class Contract {}', () => {
     let contract: Contract;
 
     beforeAll(async () => {
-      const { code, transaction_hash, address } = await defaultProvider.deployContract({
+      const { code, transaction_hash, address } = await provider.deployContract({
         contract: compiledTypeTransformation,
       });
-      contract = new Contract(compiledTypeTransformation.abi, address, defaultProvider);
+      contract = new Contract(compiledTypeTransformation.abi, address!, provider);
       expect(code).toBe('TRANSACTION_RECEIVED');
-      await defaultProvider.waitForTransaction(transaction_hash);
+      await provider.waitForTransaction(transaction_hash);
     });
 
     describe('Request Type Transformation', () => {
@@ -208,39 +197,24 @@ describe('class Contract {}', () => {
   });
 
   describe('Contract interaction with Account', () => {
-    let account: Account;
+    const account = getTestAccount();
     let erc20: Contract;
     let erc20Address: string;
 
     beforeAll(async () => {
-      const starkKeyPair = ec.genKeyPair();
-      const starkKeyPub = ec.getStarkKey(starkKeyPair);
-      const { address } = await defaultProvider.deployContract({
-        contract: compiledArgentAccount,
-        addressSalt: starkKeyPub,
-      });
-      expect(address).toBeDefined();
-      account = new Account(defaultProvider, address, starkKeyPair);
-      const accountContract = new Contract(compiledArgentAccount.abi, address);
-      await accountContract.initialize(starkKeyPub, '0');
-
-      const erc20Response = await defaultProvider.deployContract({
+      const erc20Response = await provider.deployContract({
         contract: compiledErc20,
       });
-      erc20Address = erc20Response.address;
-      erc20 = new Contract(compiledErc20.abi, erc20Address, defaultProvider);
+      erc20Address = erc20Response.address!;
+      erc20 = new Contract(compiledErc20.abi, erc20Address, provider);
       expect(erc20Response.code).toBe('TRANSACTION_RECEIVED');
-      await defaultProvider.waitForTransaction(erc20Response.transaction_hash);
-
-      const mintResponse = await erc20.mint(account.address, '1000');
-
-      await defaultProvider.waitForTransaction(mintResponse.transaction_hash);
+      await provider.waitForTransaction(erc20Response.transaction_hash);
     });
 
     test('read balance of wallet', async () => {
       const result = await erc20.balance_of(account.address);
       const [res] = result;
-      expect(res).toStrictEqual(toBN(1000));
+      expect(res).toStrictEqual(toBN(0));
       expect(res).toStrictEqual(result.res);
     });
 
@@ -255,34 +229,18 @@ describe('class Contract {}', () => {
       expect(res).toHaveProperty('amount');
       expect(res).toHaveProperty('unit');
     });
-
-    test('read balance of wallet', async () => {
-      const { res } = await erc20.balance_of(account.address);
-
-      expect(res).toStrictEqual(toBN(1000));
-    });
-
-    test('invoke contract by wallet owner', async () => {
-      const { transaction_hash, code } = await erc20.transfer(erc20Address, 10, {
-        maxFee: 0,
-      });
-      expect(code).toBe('TRANSACTION_RECEIVED');
-      await defaultProvider.waitForTransaction(transaction_hash);
-      const { res } = await erc20.balance_of(account.address);
-      expect(res).toStrictEqual(toBN(990));
-    });
   });
 });
 
 describe('class ContractFactory {}', () => {
   let erc20Address: string;
   beforeAll(async () => {
-    const { code, transaction_hash, address } = await defaultProvider.deployContract({
+    const { code, transaction_hash, address } = await provider.deployContract({
       contract: compiledErc20,
     });
     expect(code).toBe('TRANSACTION_RECEIVED');
-    await defaultProvider.waitForTransaction(transaction_hash);
-    erc20Address = address;
+    await provider.waitForTransaction(transaction_hash);
+    erc20Address = address!;
   });
   test('deployment of new contract', async () => {
     const factory = new ContractFactory(compiledErc20);

package/__tests__/fixtures.ts

@@ -1,13 +1,33 @@
 import fs from 'fs';
 
-import { json } from '../src';
+import { Account, defaultProvider, ec, json } from '../src';
 import { CompiledContract } from '../src/types';
 
 const readContract = (name: string): CompiledContract =>
   json.parse(fs.readFileSync(`./__mocks__/${name}.json`).toString('ascii'));
 
+export const compiledOpenZeppelinAccount = readContract('Account');
 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');
+
+const DEFAULT_TEST_ACCOUNT_ADDRESS =
+  '0x6c0a3ca4f79e978f3b7005898aaa49bef4a24aeaa5f10c6a97887516400197e';
+
+export const getTestAccount = () => {
+  const testAccountAddress = process.env.TEST_ACCOUNT_ADDRESS || DEFAULT_TEST_ACCOUNT_ADDRESS;
+  const testAccountPrivateKey = process.env.TEST_ACCOUNT_PRIVATE_KEY;
+
+  if (!testAccountPrivateKey) {
+    throw new Error('TEST_ACCOUNT_PRIVATE_KEY is not set');
+  }
+
+  return new Account(defaultProvider, testAccountAddress, ec.getKeyPair(testAccountPrivateKey));
+};
+
+export const getTestProvider = () => {
+  // Will support both local and remote providers in the future
+  return defaultProvider;
+};

package/__tests__/provider.test.ts

@@ -1,4 +1,5 @@
 import { defaultProvider, stark } from '../src';
+import { toBN } from '../src/utils/number';
 import { compiledArgentAccount } from './fixtures';
 
 const { compileCalldata } = stark;
@@ -42,7 +43,7 @@ describe('defaultProvider', () => {
         )
       ).resolves.not.toThrow();
     });
-    test('getStorageAt()', () => {
+    test('getStorageAt() with "key" type of number', () => {
       return expect(
         defaultProvider.getStorageAt(
           '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
@@ -51,6 +52,24 @@ describe('defaultProvider', () => {
         )
       ).resolves.not.toThrow();
     });
+    test('getStorageAt() with "key" type of string', () => {
+      return expect(
+        defaultProvider.getStorageAt(
+          '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
+          '0',
+          36663
+        )
+      ).resolves.not.toThrow();
+    });
+    test('getStorageAt() with "key" type of BN', () => {
+      return expect(
+        defaultProvider.getStorageAt(
+          '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
+          toBN('0x0'),
+          36663
+        )
+      ).resolves.not.toThrow();
+    });
     test('getStorageAt(blockHash=undefined, blockNumber=null)', () => {
       return expect(
         defaultProvider.getStorageAt(

package/account/default.d.ts

@@ -1,5 +1,4 @@
 import { Provider, ProviderInterface } from '../provider';
-import { BlockIdentifier } from '../provider/utils';
 import { SignerInterface } from '../signer';
 import {
   Abi,
@@ -10,7 +9,7 @@ import {
   Signature,
   Transaction,
 } from '../types';
-import { EstimateFee } from '../types/account';
+import { EstimateFee, EstimateFeeDetails } from '../types/account';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData';
 import { AccountInterface } from './interface';
@@ -25,13 +24,7 @@ export declare class Account extends Provider implements AccountInterface {
   getNonce(): Promise<string>;
   estimateFee(
     calls: Call | Call[],
-    {
-      nonce: providedNonce,
-      blockIdentifier,
-    }?: {
-      nonce?: BigNumberish;
-      blockIdentifier?: BlockIdentifier;
-    }
+    { nonce: providedNonce, blockIdentifier }?: EstimateFeeDetails
   ): Promise<EstimateFee>;
   /**
    * Invoke execute function in account contract

package/account/index.js

@@ -4,12 +4,16 @@ var __createBinding =
   (Object.create
     ? function (o, m, k, k2) {
         if (k2 === undefined) k2 = k;
-        Object.defineProperty(o, k2, {
-          enumerable: true,
-          get: function () {
-            return m[k];
-          },
-        });
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
       }
     : function (o, m, k, k2) {
         if (k2 === undefined) k2 = k;

package/account/interface.d.ts

@@ -5,11 +5,10 @@ import {
   AddTransactionResponse,
   Call,
   DeployContractPayload,
-  Invocation,
   InvocationsDetails,
   Signature,
 } from '../types';
-import { EstimateFee } from '../types/account';
+import { EstimateFee, EstimateFeeDetails } from '../types/account';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData/types';
 export declare abstract class AccountInterface extends ProviderInterface {
@@ -40,7 +39,10 @@ export declare abstract class AccountInterface extends ProviderInterface {
    *
    * @returns response from addTransaction
    */
-  abstract estimateFee(invocation: Invocation): Promise<EstimateFee>;
+  abstract estimateFee(
+    calls: Call | Call[],
+    estimateFeeDetails?: EstimateFeeDetails
+  ): Promise<EstimateFee>;
   /**
    * Invoke execute function in account contract
    *

package/contract/default.d.ts

@@ -148,6 +148,6 @@ export declare class Contract implements ContractInterface {
       blockIdentifier?: BlockIdentifier;
     }
   ): Promise<Result>;
-  estimate(method: string, args?: Array<any>): Promise<import('../types/account').EstimateFee>;
+  estimate(method: string, args?: Array<any>): Promise<import('../types').EstimateFee>;
   populate(method: string, args?: Array<any>): Invocation;
 }