starknet 3.18.2 → 4.0.1

package/www/docs/API/provider.md

@@ -14,17 +14,18 @@ Typically, these are _read_ calls on the blockchain.
 
 The options for the provider depends from the network. The structure of the options object is:
 
-- options.**baseUrl** - Base URL of the network
-- options.**feederGatewayUrl** - Feeder Gateway Endpoint of the network
-- options.**gatewayUrl** - Gateway Endpoint
+- options.**sequencer** - Options for sequencer provider
+- options.**rpc** - Options for RPC provider
 
 Example:
 
 ```
 const provider = new starknet.Provider({
+  sequencer: {
     baseUrl: 'https://alpha4.starknet.io',
     feederGatewayUrl: 'feeder_gateway',
     gatewayUrl: 'gateway',
+  }
 })
 ```
 
@@ -32,20 +33,9 @@ const provider = new starknet.Provider({
 
 ## Methods
 
-Gets the smart contract address on the network
-
-provider.**getContractAddresses**() => _Promise < GetContractAddressesResponse >_
-
-```
-{
-  Starknet: string;
-  GpsStatementVerifier: string;
-}
-```
-
 <hr/>
 
-provider.**callContract**(call [ , options ]) => _Promise < CallContractResponse >_
+provider.**callContract**(call [ , blockIdentifier ]) => _Promise < CallContractResponse >_
 
 Calls a function on the StarkNet contract.
 
@@ -55,10 +45,6 @@ The call object structure:
 - call.**entrypoint** - Entrypoint of the call (method name)
 - call.**calldata** - Payload for the invoking the method
 
-The options object structure:
-
-- options.**blockIdentifier**
-
 ###### CallContractResponse
 
 ```
@@ -69,7 +55,7 @@ The options object structure:
 
 <hr/>
 
-provider.**getBlock**(blockIdentifire) => _Promise < GetBlockResponse >_
+provider.**getBlock**(blockIdentifier) => _Promise < GetBlockResponse >_
 
 Gets the block information.
 
@@ -77,95 +63,178 @@ Gets the block information.
 
 ```
 {
+  accepted_time: number;
   block_hash: string;
-  parent_block_hash: string;
   block_number: number;
-  state_root: string;
+  gas_price: string;
+  new_root: string;
+  old_root?: string;
+  parent_hash: string;
+  sequencer: string;
   status: 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
-  transation: Transaction[];
-  timestamp: number;
-  transaction_receipts: [];
-  starknet_version: string;
+  transactions: Array<string>;
+  starknet_version?: string;
 }
 ```
 
 <hr/>
 
-provider.**getCode**(contractAddress, blockIdentifire) => _Promise < GetCodeResponse >_
+provider.**getClassAt**(contractAddress, blockIdentifier) => _Promise < ContractClass >_
 
-Gets the code of the deployed contract.
+Gets the contract class of the deployed contract.
 
-###### _GetCodeResponse_
+###### _ContractClass_
 
 ```
 {
-  bytecode: string[];
-  abi: Abi;
+  program: CompressedProgram;
+  entry_points_by_type: EntryPointsByType;
+  abi?: Abi;
 }
 ```
 
 <hr/>
 
-provider.**getStorageAt**(contractAddress, key, blockIdentifire) => _Promise < any >_
+provider.**getStorageAt**(contractAddress, key, blockHashOrTag) => _Promise < string >_
 
 Gets the contract's storage variable at a specific key
 
 <hr/>
 
-provider.**getTransactionStatus**(txHash) => _Promise < GetTransactionStatusResponse >_
+provider.**getTransactionReceipt**(txHash) => _Promise < GetTransactionReceiptResponse >_
 
 Gets the status of a transaction.
 
-###### _GetTransactionStatusResponse_
+###### _GetTransactionReceiptResponse_
 
 ```
 {
-  tx_status: 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
-  block_hash: string;
-  tx_failure_reason?: {
-    tx_id: number;
-    code: string;
-    error_message: string;
-  }
+  transaction_hash: string;
+  status: 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+  actual_fee?: string;
+  status_data?: string;
+  messages_sent?: Array<MessageToL1>;
+  events?: Array<Event>;
+  l1_origin_message?: MessageToL2;
 }
 ```
 
 <hr/>
 
-provider.**getTransactionReceipt**(txHash) => _Promise < TransactionReceiptResponse >_
+provider.**getTransaction**(txHash) => _Promise < GetTransactionResponse >_
 
-Gets the status of a transaction.
+Gets the transaction information from a tx hash.
 
-###### _TransactionReceiptResponse_
+###### _GetTransactionResponse_
 
 ```
 {
-  status: 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
   transaction_hash: string;
-  transaction_index: number;
-  block_hash: string;
-  block_number: 'pending' | null | number;
-  l2_to_l1_messages: string[];
-  events: string[];
+  version?: string;
+  signature?: Signature;
+  max_fee?: string;
+  nonce?: string;
+  contract_address?: string;
+  entry_point_selector?: string;
+  calldata?: RawCalldata;
+  contract_class?: ContractClass;
+  sender_address?: string;
 }
 ```
 
 <hr/>
 
-provider.**getTransaction**(txHash) => _Promise < GetTransactionResponse >_
+provider.**declareContract**(payload) => _Promise < DeclareContractResponse >_
 
-Gets the transaction information from a tx hash.
+Declares a contract on Starknet
 
-###### _GetTransactionResponse_
+###### _DeclareContractResponse_
+
+```
+{
+  transaction_hash: string;
+  class_hash: string;
+};
+
+<hr/>
+
+```
+
+provider.**deployContract**(payload [ , abi ]) => _Promise < DeployContractResponse >_
+
+Deploys a contract on Starknet
+
+###### _DeployContractResponse_
+
+```
+{
+  transaction_hash: string;
+  contract_address?: string;
+};
+```
+
+<hr/>
+
+provider.**waitForTransaction**(txHash [ , retryInterval]) => _Promise < void >_
+
+Wait for the transaction to be accepted on L2 or L1.
+
+# SequencerProvider
+
+## Creating an instance
+
+`new starknet.SequencerProvider(optionsOrProvider)`
+
+The options for the provider depends from the network. The structure of the options object is:
+
+- options.**baseUrl** - Base URL of the network
+- options.**feederGatewayUrl** - Feeder Gateway Endpoint of the network
+- options.**gatewayUrl** - Gateway Endpoint
+
+or
+
+- options.**network** - One of 'mainnet-alpha' or 'goerli-alpha'
+
+Example:
+
+```
+const provider = new starknet.Provider({
+  baseUrl: 'https://alpha4.starknet.io',
+  feederGatewayUrl: 'feeder_gateway',
+  gatewayUrl: 'gateway',
+})
+```
+
+## Methods
+
+Gets the smart contract address on the network
+
+provider.**getContractAddresses**() => _Promise < GetContractAddressesResponse >_
 
 ```
 {
-    status: 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
-    transaction: Transaction;
-    block_hash: string;
-    block_number: 'pending' | null | number;
-    transaction_index: number;
-    transaction_hash: string;
+  Starknet: string;
+  GpsStatementVerifier: string;
+}
+```
+
+<hr/>
+
+provider.**getTransactionStatus**(txHash) => _Promise < GetTransactionStatusResponse >_
+
+Gets the status of a transaction.
+
+###### _GetTransactionStatusResponse_
+
+```
+{
+  tx_status: 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+  block_hash: string;
+  tx_failure_reason?: {
+    tx_id: number;
+    code: string;
+    error_message: string;
+  }
 }
 ```
 
@@ -197,35 +266,77 @@ Gets the transaction trace from a tx hash.
 }
 ```
 
+# RpcProvider
+
+## Creating an instance
+
+`new starknet.RpcProvider(options)`
+
+- options.**nodeUrl** - Starknet RPC node url
+
+Example:
+
+```
+const provider = new starknet.RpcProvider({
+  nodeUrl: 'URL_TO_STARKNET_RPC_NODE',
+})
+```
+
+## Methods
+
+provider.**getTransactionCount**(blockIdentifier) => _Promise < number >_
+
+Gets the transaction count from a block.
+
 <hr/>
 
-provider.**declareContract**(payload) => _Promise < AddTransactionResponse >_
+provider.**getBlockNumber**() => _Promise < number >_
 
-Declares a contract on Starknet
+Gets the latest block number
 
-###### _AddTransactionResponse_
+<hr/>
+
+provider.**getSyncingStats**() => _Promise < GetSyncingStatsResponse >_
+
+Gets syncing status of the node
+
+###### GetSyncingStatsResponse
 
 ```
+boolean |
 {
-  code: 'TRANSACTION_RECEIVED';
-  transaction_hash: string;
-  class_hash: string;
-};
+  starting_block_hash: string;
+  starting_block_num: string;
+  current_block_hash: string;
+  current_block_num: string;
+  highest_block_hash: string;
+  highest_block_num: string;
+}
+```
 
 <hr/>
 
-```
+provider.**getEvents**(eventFilter) => _Promise < GetEventsResponse >_
 
-provider.**deployContract**(payload [ , abi ]) => _Promise < AddTransactionResponse >_
+##### EventFilter
 
-Deploys a contract on Starknet
+```
+type EventFilter = {
+  fromBlock: string;
+  toBlock: string;
+  address: string;
+  keys: string[];
+  page_size: number;
+  page_number: number;
+};
+```
 
-###### _AddTransactionResponse_
+###### GetSyncingStatsResponse
 
 ```
 {
-  code: 'TRANSACTION_RECEIVED';
-  transaction_hash: string;
-  address?: string;
-};
+  events: StarknetEmittedEvent[];
+  page_number: number;
+  is_last_page: number;
+}
 ```

package/www/guides/account.md

@@ -54,16 +54,9 @@ Wait for the deployment transaction to be accepted and assign the address of the
 
 ```javascript
 await defaultProvider.waitForTransaction(accountResponse.transaction_hash);
-const accountContract = new Contract(
-  compiledAccount.abi,
-  accountResponse.address
-);
-const initializeResponse = await accountContract.initialize(starkKeyPub, "0");
-
-await defaultProvider.waitForTransaction(initializeResponse.transaction_hash);
 ```
 
-Once account contract is initialized [Account](../docs/API/account.md) instance can be created. Use your new account instance to sign transactions, messages or verify signatures!
+Once account contract is deployed [Account](../docs/API/account.md) instance can be created. Use your new account instance to sign transactions, messages or verify signatures! Make sure your Account has enough funds to execute invocations.
 
 ```js
 const account = new Account(

package/www/guides/erc20.md

@@ -29,10 +29,13 @@ const erc20 = new Contract(compiledErc20.abi, erc20Address);
 Make sure you created the `Account` instance following the [Creating an Account](./account.md) guide.
 
 ```javascript
+erc20.connect(account);
+
 const { transaction_hash: mintTxHash } = await erc20.mint(
   account.address,
   "1000"
 );
+
 console.log(`Waiting for Tx to be Accepted on Starknet - Minting...`);
 await defaultProvider.waitForTransaction(mintTxHash);
 ```

package/__tests__/provider.test.ts

@@ -1,168 +0,0 @@
-import { BlockNumber, stark } from '../src';
-import { toBN } from '../src/utils/number';
-import {
-  IS_DEVNET,
-  compiledErc20,
-  compiledOpenZeppelinAccount,
-  getTestProvider,
-  testIfNotDevnet,
-} from './fixtures';
-
-const { compileCalldata } = stark;
-
-const provider = getTestProvider();
-
-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', () => {
-    testIfNotDevnet('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=${exampleBlockHash}, blockNumber=undefined)`, () => {
-      return expect(provider.getBlock(exampleBlockHash)).resolves.not.toThrow();
-    });
-    test(`getBlock(blockHash=undefined, blockNumber=${exampleBlockNumber})`, () => {
-      return expect(provider.getBlock(exampleBlockNumber)).resolves.not.toThrow();
-    });
-    test('getBlock(blockHash=undefined, blockNumber=null)', async () => {
-      const block = await provider.getBlock();
-
-      expect(block).not.toBeNull();
-
-      const { block_number, timestamp } = block;
-
-      expect(typeof block_number).toEqual('number');
-
-      return expect(typeof timestamp).toEqual('number');
-    });
-    test('getBlock() -> { blockNumber }', async () => {
-      const block = await provider.getBlock();
-      return expect(block).toHaveProperty('block_number');
-    });
-    test('getCode()', () => {
-      return expect(provider.getCode(exampleContractAddress, 36663)).resolves.not.toThrow();
-    });
-    test('getCode(blockHash=undefined, blockNumber=null)', () => {
-      return expect(provider.getCode(exampleContractAddress)).resolves.not.toThrow();
-    });
-    test('getStorageAt() with "key" type of number', () => {
-      return expect(provider.getStorageAt(exampleContractAddress, 0, 36663)).resolves.not.toThrow();
-    });
-    test('getStorageAt() with "key" type of string', () => {
-      return expect(
-        provider.getStorageAt(exampleContractAddress, '0', 36663)
-      ).resolves.not.toThrow();
-    });
-    test('getStorageAt() with "key" type of BN', () => {
-      return expect(
-        provider.getStorageAt(exampleContractAddress, toBN('0x0'), 36663)
-      ).resolves.not.toThrow();
-    });
-    test('getStorageAt(blockHash=undefined, blockNumber=null)', () => {
-      return expect(provider.getStorageAt(exampleContractAddress, 0)).resolves.not.toThrow();
-    });
-    test('getTransactionStatus()', async () => {
-      return expect(provider.getTransactionStatus(exampleTransactionHash)).resolves.not.toThrow();
-    });
-
-    test('getTransaction() - successful transaction', async () => {
-      const transaction = await provider.getTransaction(exampleTransactionHash);
-
-      expect(transaction).not.toHaveProperty('transaction_failure_reason');
-
-      expect(transaction.transaction).toHaveProperty('transaction_hash');
-
-      return expect(transaction.status).not.toEqual('REJECTED');
-    });
-
-    test('getTransactionReceipt() - successful transaction', async () => {
-      const transactionReceipt = await provider.getTransactionReceipt(exampleTransactionHash);
-
-      return expect(transactionReceipt).toHaveProperty('actual_fee');
-    });
-
-    test('callContract()', () => {
-      return expect(
-        provider.callContract({
-          contractAddress: exampleContractAddress,
-          entrypoint: 'balance_of',
-          calldata: compileCalldata({
-            user: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
-          }),
-        })
-      ).resolves.not.toThrow();
-    });
-
-    test('callContract() - gateway error', async () => {
-      const promise = provider.callContract({
-        contractAddress: exampleContractAddress,
-        entrypoint: 'non_existent_entrypoint',
-        calldata: compileCalldata({
-          user: '0xdeadbeef',
-        }),
-      });
-      expect(promise).rejects.toHaveProperty('errorCode');
-      expect(promise).rejects.toThrowErrorMatchingInlineSnapshot(
-        `"Entry point 0x23b0c8b3d98aa73d8a35f5303fe77d132c6d04279e63f6e1d6aac5946e04612 not found in contract with class hash 0x2864c45bd4ba3e66d8f7855adcadf07205c88f43806ffca664f1f624765207e."`
-      );
-
-      try {
-        await promise;
-      } catch (e) {
-        expect(e.errorCode).toMatchInlineSnapshot(
-          IS_DEVNET ? `500` : `"StarknetErrorCode.ENTRY_POINT_NOT_FOUND_IN_CONTRACT"`
-        );
-      }
-    });
-
-    test('transaction trace', async () => {
-      const transactionTrace = await provider.getTransactionTrace(exampleTransactionHash);
-      expect(transactionTrace).toHaveProperty('function_invocation');
-      expect(transactionTrace).toHaveProperty('signature');
-    });
-  });
-
-  describe('addTransaction()', () => {
-    test('declareContract()', async () => {
-      const response = await provider.declareContract({
-        contract: compiledErc20,
-      });
-
-      expect(response.code).toBe('TRANSACTION_RECEIVED');
-      expect(response.transaction_hash).toBeDefined();
-      expect(response.class_hash).toBeDefined();
-    });
-
-    test('deployContract()', async () => {
-      const response = await provider.deployContract({
-        contract: compiledOpenZeppelinAccount,
-      });
-
-      expect(response.code).toBe('TRANSACTION_RECEIVED');
-      expect(response.transaction_hash).toBeDefined();
-      expect(response.address).toBeDefined();
-    });
-  });
-});