starknet 3.15.0 → 3.15.3

package/__tests__/account.test.ts

@@ -12,7 +12,7 @@ import {
 } from './fixtures';
 
 describe('deploy and test Wallet', () => {
-  const account: Account = getTestAccount();
+  const account = getTestAccount();
   const provider = getTestProvider();
   let erc20: Contract;
   let erc20Address: string;
@@ -24,8 +24,9 @@ describe('deploy and test Wallet', () => {
     const erc20Response = await provider.deployContract({
       contract: compiledErc20,
     });
-    erc20Address = erc20Response.address;
-    erc20 = new Contract(compiledErc20.abi, erc20Address);
+
+    erc20Address = erc20Response.address!;
+    erc20 = new Contract(compiledErc20.abi, erc20Address, provider);
     expect(erc20Response.code).toBe('TRANSACTION_RECEIVED');
 
     await provider.waitForTransaction(erc20Response.transaction_hash);
@@ -40,10 +41,14 @@ describe('deploy and test Wallet', () => {
 
     await provider.waitForTransaction(mintResponse.transaction_hash);
 
+    const x = await erc20.balance_of(account.address);
+
+    expect(number.toBN(x.res as string).toString()).toStrictEqual(number.toBN(1000).toString());
+
     const dappResponse = await provider.deployContract({
       contract: compiledTestDapp,
     });
-    dapp = new Contract(compiledTestDapp.abi, dappResponse.address);
+    dapp = new Contract(compiledTestDapp.abi, dappResponse.address!, provider);
     expect(dappResponse.code).toBe('TRANSACTION_RECEIVED');
 
     await provider.waitForTransaction(dappResponse.transaction_hash);
@@ -60,9 +65,9 @@ describe('deploy and test Wallet', () => {
   });
 
   test('read balance of wallet', async () => {
-    const { res } = await erc20.balance_of(account.address);
+    const x = await erc20.balance_of(account.address);
 
-    expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(1000).toString());
+    expect(number.toBN(x.res as string).toString()).toStrictEqual(number.toBN(1000).toString());
   });
 
   test('execute by wallet owner', async () => {
@@ -123,9 +128,15 @@ describe('deploy and test Wallet', () => {
     expect(toBN(response.number as string).toString()).toStrictEqual('57');
   });
 
-  test('sign and verify offchain message', async () => {
+  test('sign and verify offchain message fail', async () => {
     const signature = await account.signMessage(typedDataExample);
+    // change the signature to make it invalid
+    signature[0] += '123';
+    expect(await account.verifyMessage(typedDataExample, signature)).toBe(false);
+  });
 
+  test('sign and verify offchain message', async () => {
+    const signature = await account.signMessage(typedDataExample);
     expect(await account.verifyMessage(typedDataExample, signature)).toBe(true);
   });
 
@@ -143,7 +154,7 @@ describe('deploy and test Wallet', () => {
 
       await provider.waitForTransaction(accountResponse.transaction_hash);
 
-      newAccount = new Account(provider, accountResponse.address, starkKeyPair);
+      newAccount = new Account(provider, accountResponse.address!, starkKeyPair);
     });
 
     test('read nonce', async () => {

package/__tests__/contract.test.ts

@@ -38,7 +38,7 @@ describe('class Contract {}', () => {
         contract: compiledMulticall,
       });
 
-      contract = new Contract(compiledMulticall.abi, multicallAddress!);
+      contract = new Contract(compiledMulticall.abi, multicallAddress!, provider);
 
       expect(m_code).toBe('TRANSACTION_RECEIVED');
 
@@ -223,12 +223,6 @@ describe('class Contract {}', () => {
       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');
-    });
   });
 });
 
@@ -243,17 +237,17 @@ describe('class ContractFactory {}', () => {
     erc20Address = address!;
   });
   test('deployment of new contract', async () => {
-    const factory = new ContractFactory(compiledErc20);
+    const factory = new ContractFactory(compiledErc20, provider);
     const erc20 = await factory.deploy();
     expect(erc20 instanceof Contract);
   });
   test('wait for deployment transaction', async () => {
-    const factory = new ContractFactory(compiledErc20);
+    const factory = new ContractFactory(compiledErc20, provider);
     const contract = await factory.deploy();
     expect(contract.deployed()).resolves.not.toThrow();
   });
   test('attach new contract', async () => {
-    const factory = new ContractFactory(compiledErc20);
+    const factory = new ContractFactory(compiledErc20, provider);
     const erc20 = factory.attach(erc20Address);
     expect(erc20 instanceof Contract);
   });

package/__tests__/fixtures.ts

@@ -1,33 +1,45 @@
 import fs from 'fs';
 
-import { Account, defaultProvider, ec, json } from '../src';
+import { Account, Provider, 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';
+const DEFAULT_TEST_PROVIDER_BASE_URL = 'http://127.0.0.1:5050/';
+const DEFAULT_TEST_ACCOUNT_ADDRESS = // run `starknet-devnet --seed 0` and this will be the first account
+  '0x65d53c8ec4178096167b35a08e16e548d8075cb08ad7bc63d07966ca13569dc';
+const DEFAULT_TEST_ACCOUNT_PRIVATE_KEY = '0xe3e70682c2094cac629f6fbed82c07cd';
 
-export const getTestAccount = () => {
-  const testAccountAddress = process.env.TEST_ACCOUNT_ADDRESS || DEFAULT_TEST_ACCOUNT_ADDRESS;
-  const testAccountPrivateKey = process.env.TEST_ACCOUNT_PRIVATE_KEY;
+export const getTestProvider = () => {
+  const baseUrl = process.env.TEST_PROVIDER_BASE_URL || DEFAULT_TEST_PROVIDER_BASE_URL;
 
-  if (!testAccountPrivateKey) {
-    throw new Error('TEST_ACCOUNT_PRIVATE_KEY is not set');
+  const provider = new Provider({ baseUrl });
+
+  if (baseUrl.includes('localhost') || baseUrl.includes('127.0.0.1')) {
+    // accelerate the tests when running locally
+    const originalWaitForTransaction = provider.waitForTransaction.bind(provider);
+    provider.waitForTransaction = (txHash, retryInterval) => {
+      return originalWaitForTransaction(txHash, retryInterval || 1000);
+    };
   }
 
-  return new Account(defaultProvider, testAccountAddress, ec.getKeyPair(testAccountPrivateKey));
+  return provider;
 };
 
-export const getTestProvider = () => {
-  // Will support both local and remote providers in the future
-  return defaultProvider;
+// test account with fee token balance
+export const getTestAccount = () => {
+  const provider = getTestProvider();
+
+  const testAccountAddress = process.env.TEST_ACCOUNT_ADDRESS || DEFAULT_TEST_ACCOUNT_ADDRESS;
+  const testAccountPrivateKey =
+    process.env.TEST_ACCOUNT_PRIVATE_KEY || DEFAULT_TEST_ACCOUNT_PRIVATE_KEY;
+
+  return new Account(provider, testAccountAddress, ec.getKeyPair(testAccountPrivateKey));
 };

package/__tests__/jest.setup.ts

@@ -1,6 +1,9 @@
 /* eslint-disable no-console */
+import fetch from 'cross-fetch';
 import { register } from 'fetch-intercept';
 
+global.fetch = fetch;
+
 jest.setTimeout(50 * 60 * 1000);
 
 if (process.env.DEBUG === 'true') {

package/__tests__/provider.test.ts

@@ -1,95 +1,82 @@
-import { defaultProvider, stark } from '../src';
+import { BlockNumber, stark } from '../src';
 import { toBN } from '../src/utils/number';
-import { compiledArgentAccount, compiledErc20 } from './fixtures';
+import { compiledErc20, compiledOpenZeppelinAccount, getTestProvider } from './fixtures';
 
 const { compileCalldata } = stark;
 
+const provider = getTestProvider();
+
+const testIf = (condition: boolean) => (condition ? test : test.skip);
+
 describe('defaultProvider', () => {
+  let exampleTransactionHash: string;
+  let exampleContractAddress: string;
+  let exampleBlockHash: string;
+  let exampleBlockNumber: BlockNumber;
+  beforeAll(async () => {
+    const { code, transaction_hash, address } = await provider.deployContract({
+      contract: compiledErc20,
+    });
+    expect(code).toBe('TRANSACTION_RECEIVED');
+    await provider.waitForTransaction(transaction_hash);
+    exampleTransactionHash = transaction_hash;
+    exampleContractAddress = address!;
+    const transaction = await provider.getTransaction(transaction_hash);
+
+    if (transaction.status !== 'REJECTED') {
+      exampleBlockHash = transaction.block_hash;
+      exampleBlockNumber = transaction.block_number;
+    }
+  });
+
   describe('feeder gateway endpoints', () => {
-    test('getContractAddresses()', async () => {
-      const { GpsStatementVerifier, Starknet } = await defaultProvider.getContractAddresses();
+    testIf(provider.baseUrl.includes('starknet.io'))('getContractAddresses()', async () => {
+      // not supported in starknet-devnet
+      const { GpsStatementVerifier, Starknet } = await provider.getContractAddresses();
       expect(typeof GpsStatementVerifier).toBe('string');
       expect(typeof Starknet).toBe('string');
     });
-    test('getBlock(blockHash=0x26e33ad2807590b93e98a04e703d7d64d4ead13591b50984ae558bdbe8fbcd2, blockNumber=undefined)', () => {
-      return expect(
-        defaultProvider.getBlock(
-          '0x26e33ad2807590b93e98a04e703d7d64d4ead13591b50984ae558bdbe8fbcd2'
-        )
-      ).resolves.not.toThrow();
+    test(`getBlock(blockHash=${exampleBlockHash}, blockNumber=undefined)`, () => {
+      return expect(provider.getBlock(exampleBlockHash)).resolves.not.toThrow();
     });
-    test('getBlock(blockHash=undefined, blockNumber=168890)', () => {
-      return expect(defaultProvider.getBlock(168890)).resolves.not.toThrow();
+    test(`getBlock(blockHash=undefined, blockNumber=${exampleBlockNumber})`, () => {
+      return expect(provider.getBlock(exampleBlockNumber)).resolves.not.toThrow();
     });
     test('getBlock(blockHash=undefined, blockNumber=null)', () => {
-      return expect(defaultProvider.getBlock()).resolves.not.toThrow();
+      return expect(provider.getBlock()).resolves.not.toThrow();
     });
     test('getBlock() -> { blockNumber }', async () => {
-      const block = await defaultProvider.getBlock();
+      const block = await provider.getBlock();
       return expect(block).toHaveProperty('block_number');
     });
     test('getCode()', () => {
-      return expect(
-        defaultProvider.getCode(
-          '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
-          36663
-        )
-      ).resolves.not.toThrow();
+      return expect(provider.getCode(exampleContractAddress, 36663)).resolves.not.toThrow();
     });
     test('getCode(blockHash=undefined, blockNumber=null)', () => {
-      return expect(
-        defaultProvider.getCode(
-          '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166'
-        )
-      ).resolves.not.toThrow();
+      return expect(provider.getCode(exampleContractAddress)).resolves.not.toThrow();
     });
     test('getStorageAt() with "key" type of number', () => {
-      return expect(
-        defaultProvider.getStorageAt(
-          '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
-          0,
-          36663
-        )
-      ).resolves.not.toThrow();
+      return expect(provider.getStorageAt(exampleContractAddress, 0, 36663)).resolves.not.toThrow();
     });
     test('getStorageAt() with "key" type of string', () => {
       return expect(
-        defaultProvider.getStorageAt(
-          '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
-          '0',
-          36663
-        )
+        provider.getStorageAt(exampleContractAddress, '0', 36663)
       ).resolves.not.toThrow();
     });
     test('getStorageAt() with "key" type of BN', () => {
       return expect(
-        defaultProvider.getStorageAt(
-          '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
-          toBN('0x0'),
-          36663
-        )
+        provider.getStorageAt(exampleContractAddress, toBN('0x0'), 36663)
       ).resolves.not.toThrow();
     });
     test('getStorageAt(blockHash=undefined, blockNumber=null)', () => {
-      return expect(
-        defaultProvider.getStorageAt(
-          '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
-          0
-        )
-      ).resolves.not.toThrow();
+      return expect(provider.getStorageAt(exampleContractAddress, 0)).resolves.not.toThrow();
     });
     test('getTransactionStatus()', async () => {
-      return expect(
-        defaultProvider.getTransactionStatus(
-          '0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348'
-        )
-      ).resolves.not.toThrow();
+      return expect(provider.getTransactionStatus(exampleTransactionHash)).resolves.not.toThrow();
     });
 
     test('getTransaction() - successful transaction', async () => {
-      const transaction = await defaultProvider.getTransaction(
-        '0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348'
-      );
+      const transaction = await provider.getTransaction(exampleTransactionHash);
 
       expect(transaction).not.toHaveProperty('transaction_failure_reason');
 
@@ -98,36 +85,16 @@ describe('defaultProvider', () => {
       return expect(transaction.status).not.toEqual('REJECTED');
     });
 
-    test('getTransaction() - failed transaction', async () => {
-      const transaction = await defaultProvider.getTransaction(
-        '0x698e60db2bae3ef8d5fafda10ff83b6ba634351aa1f4fcf8455ec0cffa738d9'
-      );
-
-      expect(transaction).toHaveProperty('transaction_failure_reason');
-
-      return expect(transaction.status).toEqual('REJECTED');
-    });
-
     test('getTransactionReceipt() - successful transaction', async () => {
-      const transactionReceipt = await defaultProvider.getTransactionReceipt(
-        '0x18c49389193b40e178dfc9f2f595a7c79a7a55639e9951d956329f2ce6cfd4f'
-      );
+      const transactionReceipt = await provider.getTransactionReceipt(exampleTransactionHash);
 
       return expect(transactionReceipt).toHaveProperty('actual_fee');
     });
 
-    test('getTransactionReceipt() - failed transaction', async () => {
-      const transactionReceipt = await defaultProvider.getTransactionReceipt(
-        '0x698e60db2bae3ef8d5fafda10ff83b6ba634351aa1f4fcf8455ec0cffa738d9'
-      );
-
-      return expect(transactionReceipt).not.toHaveProperty('actual_fee');
-    });
-
     test('callContract()', () => {
       return expect(
-        defaultProvider.callContract({
-          contractAddress: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
+        provider.callContract({
+          contractAddress: exampleContractAddress,
           entrypoint: 'balance_of',
           calldata: compileCalldata({
             user: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
@@ -137,9 +104,7 @@ describe('defaultProvider', () => {
     });
 
     test('transaction trace', async () => {
-      const transactionTrace = await defaultProvider.getTransactionTrace(
-        '0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348'
-      );
+      const transactionTrace = await provider.getTransactionTrace(exampleTransactionHash);
       expect(transactionTrace).toHaveProperty('function_invocation');
       expect(transactionTrace).toHaveProperty('signature');
     });
@@ -147,7 +112,7 @@ describe('defaultProvider', () => {
 
   describe('addTransaction()', () => {
     test('declareContract()', async () => {
-      const response = await defaultProvider.declareContract({
+      const response = await provider.declareContract({
         contract: compiledErc20,
       });
 
@@ -157,8 +122,8 @@ describe('defaultProvider', () => {
     });
 
     test('deployContract()', async () => {
-      const response = await defaultProvider.deployContract({
-        contract: compiledArgentAccount,
+      const response = await provider.deployContract({
+        contract: compiledOpenZeppelinAccount,
       });
 
       expect(response.code).toBe('TRANSACTION_RECEIVED');