starknet 3.18.2 → 3.19.0

package/src/provider/interface.ts

@@ -1,123 +1,90 @@
 import { StarknetChainId } from '../constants';
 import type {
-  AddTransactionResponse,
+  BlockTag,
   Call,
   CallContractResponse,
+  ContractClass,
+  DeclareContractPayload,
+  DeclareContractResponse,
   DeployContractPayload,
+  DeployContractResponse,
+  EstimateFeeResponse,
   GetBlockResponse,
-  GetCodeResponse,
-  GetContractAddressesResponse,
+  GetTransactionReceiptResponse,
   GetTransactionResponse,
-  GetTransactionStatusResponse,
   Invocation,
-  TransactionReceiptResponse,
+  InvocationsDetails,
+  InvokeFunctionResponse,
 } from '../types';
 import type { BigNumberish } from '../utils/number';
 import { BlockIdentifier } from './utils';
 
 export abstract class ProviderInterface {
-  public abstract baseUrl: string;
-
-  public abstract feederGatewayUrl: string;
-
-  public abstract gatewayUrl: string;
-
   public abstract chainId: StarknetChainId;
 
-  /**
-   * Gets the smart contract address on the goerli testnet.
-   *
-   * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L13-L15)
-   * @returns starknet smart contract addresses
-   */
-  public abstract getContractAddresses(): Promise<GetContractAddressesResponse>;
-
   /**
    * Calls a function on the StarkNet contract.
    *
-   * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L25-L39)
-   *
-   * @param invokeTransaction transaction to be invoked
+   * @param call transaction to be called
    * @param blockIdentifier block identifier
    * @returns the result of the function on the smart contract.
    */
   public abstract callContract(
-    invokeTransaction: Call,
-    options: {
-      blockIdentifier: BlockIdentifier;
-    }
+    call: Call,
+    blockIdentifier?: BlockIdentifier
   ): Promise<CallContractResponse>;
 
   /**
    * Gets the block information
    *
-   * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L41-L53)
-   *
    * @param blockIdentifier block identifier
-   * @returns the block object { block_number, previous_block_number, state_root, status, timestamp, transaction_receipts, transactions }
+   * @returns the block object
    */
-  public abstract getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
+  public abstract getBlock(blockIdentifier: BlockIdentifier): Promise<GetBlockResponse>;
 
   /**
-   * Gets the code of the deployed contract.
-   *
-   * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L55-L68)
+   * Gets the contract class of the deployed contract.
    *
    * @param contractAddress - contract address
    * @param blockIdentifier - block identifier
-   * @returns Bytecode and ABI of compiled contract
+   * @returns Contract class of compiled contract
    */
-  public abstract getCode(
+  public abstract getClassAt(
     contractAddress: string,
     blockIdentifier?: BlockIdentifier
-  ): Promise<GetCodeResponse>;
+  ): Promise<ContractClass>;
 
-  // TODO: add proper type
   /**
    * Gets the contract's storage variable at a specific key.
    *
-   * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L70-L85)
-   *
    * @param contractAddress
    * @param key - from getStorageVarAddress('<STORAGE_VARIABLE_NAME>') (WIP)
-   * @param blockIdentifier - block identifier
+   * @param blockHashOrTag - block hash or tag (pending, latest)
    * @returns the value of the storage variable
    */
   public abstract getStorageAt(
     contractAddress: string,
     key: BigNumberish,
-    blockIdentifier?: BlockIdentifier
-  ): Promise<object>;
-
-  /**
-   * Gets the status of a transaction.
-   *
-   * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L48-L52)
-   *
-   * @param txHash
-   * @returns the transaction status object { block_number, tx_status: NOT_RECEIVED | RECEIVED | PENDING | REJECTED | ACCEPTED_ONCHAIN }
-   */
-  public abstract getTransactionStatus(txHash: BigNumberish): Promise<GetTransactionStatusResponse>;
+    blockHashOrTag?: BlockTag | BigNumberish
+  ): Promise<BigNumberish>;
 
   /**
    * Gets the transaction information from a tx id.
    *
-   * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L54-L58)
-   *
    * @param txHash
    * @returns the transacton object { transaction_id, status, transaction, block_number?, block_number?, transaction_index?, transaction_failure_reason? }
    */
-  public abstract getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
+  public abstract getTransaction(transactionHash: BigNumberish): Promise<GetTransactionResponse>;
 
   /**
    * Gets the transaction receipt from a tx hash.
    *
-   * [Reference] (https://github.com/starkware-libs/cairo-lang/blob/167b28bcd940fd25ea3816204fa882a0b0a49603/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L183)
-   *
    * @param txHash
    * @returns the transaction receipt object
    */
-  public abstract getTransactionReceipt(txHash: BigNumberish): Promise<TransactionReceiptResponse>;
+  public abstract getTransactionReceipt(
+    transactionHash: BigNumberish
+  ): Promise<GetTransactionReceiptResponse>;
 
   /**
    * Deploys a given compiled contract (json) to starknet
@@ -128,7 +95,19 @@ export abstract class ProviderInterface {
    * - address salt
    * @returns a confirmation of sending a transaction on the starknet contract
    */
-  public abstract deployContract(payload: DeployContractPayload): Promise<AddTransactionResponse>;
+  public abstract deployContract(payload: DeployContractPayload): Promise<DeployContractResponse>;
+
+  /**
+   * Declares a given compiled contract (json) to starknet
+   *
+   * @param payload payload to be deployed containing:
+   * - compiled contract code
+   * - optional version
+   * @returns a confirmation of sending a transaction on the starknet contract
+   */
+  public abstract declareContract(
+    payload: DeclareContractPayload
+  ): Promise<DeclareContractResponse>;
 
   /**
    * Invokes a function on starknet
@@ -139,15 +118,41 @@ export abstract class ProviderInterface {
    * - entrypoint - the entrypoint of the contract
    * - calldata - (defaults to []) the calldata
    * - signature - (defaults to []) the signature
-   *
+   * @param details - optional details containing:
+   * - nonce - optional nonce
+   * - version - optional version
+   * - maxFee - optional maxFee
    * @returns response from addTransaction
    */
-  public abstract invokeFunction(invocation: Invocation): Promise<AddTransactionResponse>;
+  public abstract invokeFunction(
+    invocation: Invocation,
+    details?: InvocationsDetails
+  ): Promise<InvokeFunctionResponse>;
 
-  public abstract waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+  /**
+   * Estimates the fee for a given transaction
+   *
+   * @param invocation the invocation object containing:
+   * - contractAddress - the address of the contract
+   * - entrypoint - the entrypoint of the contract
+   * - calldata - (defaults to []) the calldata
+   * - signature - (defaults to []) the signature
+   * @param blockIdentifier - block identifier
+   * @param details - optional details containing:
+   * - nonce - optional nonce
+   * - version - optional version
+   * @returns the estimated fee
+   */
+  public abstract getEstimateFee(
+    invocation: Invocation,
+    blockIdentifier: BlockIdentifier,
+    details?: InvocationsDetails
+  ): Promise<EstimateFeeResponse>;
 
   /**
-   * @deprecated use `waitForTransaction` instead
+   * Wait for the transaction to be accepted
+   * @param txHash - transaction hash
+   * @param retryInterval - retry interval
    */
   public abstract waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
 }

package/src/provider/rpc.ts

@@ -0,0 +1,300 @@
+import fetch from 'cross-fetch';
+
+import { StarknetChainId } from '../constants';
+import {
+  BlockTag,
+  Call,
+  CallContractResponse,
+  DeclareContractPayload,
+  DeclareContractResponse,
+  DeployContractPayload,
+  DeployContractResponse,
+  EstimateFeeResponse,
+  GetBlockResponse,
+  GetTransactionReceiptResponse,
+  GetTransactionResponse,
+  Invocation,
+  InvocationsDetails,
+  InvokeFunctionResponse,
+} from '../types';
+import { RPC } from '../types/api';
+import { getSelectorFromName } from '../utils/hash';
+import { stringify } from '../utils/json';
+import {
+  BigNumberish,
+  bigNumberishArrayToDecimalStringArray,
+  isHex,
+  toBN,
+  toHex,
+} from '../utils/number';
+import { parseCalldata, parseContract, wait } from '../utils/provider';
+import { RPCResponseParser } from '../utils/responseParser/rpc';
+import { randomAddress } from '../utils/stark';
+import { ProviderInterface } from './interface';
+import { BlockIdentifier } from './utils';
+
+export type RpcProviderOptions = { nodeUrl: string };
+
+export class RpcProvider implements ProviderInterface {
+  public nodeUrl: string;
+
+  public chainId!: StarknetChainId;
+
+  private responseParser = new RPCResponseParser();
+
+  constructor(optionsOrProvider: RpcProviderOptions) {
+    const { nodeUrl } = optionsOrProvider;
+    this.nodeUrl = nodeUrl;
+
+    this.getChainId().then((chainId) => {
+      this.chainId = chainId;
+    });
+  }
+
+  protected async fetchEndpoint<T extends keyof RPC.Methods>(
+    method: T,
+    request?: RPC.Methods[T]['REQUEST']
+  ): Promise<RPC.Methods[T]['RESPONSE']> {
+    const requestData = {
+      method,
+      jsonrpc: '2.0',
+      params: request,
+      id: 0,
+    };
+
+    try {
+      const rawResult = await fetch(this.nodeUrl, {
+        method: 'POST',
+        body: stringify(requestData),
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      });
+      const { error, result } = await rawResult.json();
+      if (error) {
+        const { code, message } = error;
+        throw new Error(`${code}: ${message}`);
+      } else {
+        return result as RPC.Methods[T]['RESPONSE'];
+      }
+    } catch (error: any) {
+      const data = error?.response?.data;
+      if (data?.message) {
+        throw new Error(`${data.code}: ${data.message}`);
+      }
+      throw error;
+    }
+  }
+
+  public async getChainId(): Promise<StarknetChainId> {
+    return this.fetchEndpoint('starknet_chainId');
+  }
+
+  public async getBlock(blockIdentifier: BlockIdentifier = 'pending'): Promise<GetBlockResponse> {
+    const method =
+      typeof blockIdentifier === 'string' && isHex(blockIdentifier)
+        ? 'starknet_getBlockByHash'
+        : 'starknet_getBlockByNumber';
+
+    return this.fetchEndpoint(method, [blockIdentifier]).then(
+      this.responseParser.parseGetBlockResponse
+    );
+  }
+
+  public async getStorageAt(
+    contractAddress: string,
+    key: BigNumberish,
+    blockHashOrTag: BlockTag | BigNumberish = 'pending'
+  ): Promise<BigNumberish> {
+    const parsedKey = toHex(toBN(key));
+    return this.fetchEndpoint('starknet_getStorageAt', [
+      contractAddress,
+      parsedKey,
+      blockHashOrTag,
+    ]);
+  }
+
+  public async getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse> {
+    return this.fetchEndpoint('starknet_getTransactionByHash', [txHash]).then(
+      this.responseParser.parseGetTransactionResponse
+    );
+  }
+
+  public async getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse> {
+    return this.fetchEndpoint('starknet_getTransactionReceipt', [txHash]).then(
+      this.responseParser.parseGetTransactionReceiptResponse
+    );
+  }
+
+  public async getClassAt(
+    contractAddress: string,
+    _blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<any> {
+    return this.fetchEndpoint('starknet_getClassAt', [contractAddress]);
+  }
+
+  public async getEstimateFee(
+    invocation: Invocation,
+    blockIdentifier: BlockIdentifier = 'pending',
+    invocationDetails: InvocationsDetails = {}
+  ): Promise<EstimateFeeResponse> {
+    return this.fetchEndpoint('starknet_estimateFee', [
+      {
+        contract_address: invocation.contractAddress,
+        entry_point_selector: getSelectorFromName(invocation.entrypoint),
+        calldata: parseCalldata(invocation.calldata),
+        signature: bigNumberishArrayToDecimalStringArray(invocation.signature || []),
+        version: toHex(toBN(invocationDetails?.version || 0)),
+      },
+      blockIdentifier,
+    ]).then(this.responseParser.parseFeeEstimateResponse);
+  }
+
+  public async declareContract({
+    contract,
+    version,
+  }: DeclareContractPayload): Promise<DeclareContractResponse> {
+    const contractDefinition = parseContract(contract);
+
+    return this.fetchEndpoint('starknet_addDeclareTransaction', [
+      {
+        program: contractDefinition.program,
+        entry_points_by_type: contractDefinition.entry_points_by_type,
+      },
+      toHex(toBN(version || 0)),
+    ]).then(this.responseParser.parseDeclareContractResponse);
+  }
+
+  public async deployContract({
+    contract,
+    constructorCalldata,
+    addressSalt,
+  }: DeployContractPayload): Promise<DeployContractResponse> {
+    const contractDefinition = parseContract(contract);
+
+    return this.fetchEndpoint('starknet_addDeployTransaction', [
+      addressSalt ?? randomAddress(),
+      bigNumberishArrayToDecimalStringArray(constructorCalldata ?? []),
+      {
+        program: contractDefinition.program,
+        entry_points_by_type: contractDefinition.entry_points_by_type,
+      },
+    ]).then(this.responseParser.parseDeployContractResponse);
+  }
+
+  public async invokeFunction(
+    functionInvocation: Invocation,
+    details: InvocationsDetails
+  ): Promise<InvokeFunctionResponse> {
+    return this.fetchEndpoint('starknet_addInvokeTransaction', [
+      {
+        contract_address: functionInvocation.contractAddress,
+        entry_point_selector: getSelectorFromName(functionInvocation.entrypoint),
+        calldata: parseCalldata(functionInvocation.calldata),
+      },
+      bigNumberishArrayToDecimalStringArray(functionInvocation.signature || []),
+      toHex(toBN(details.maxFee || 0)),
+      toHex(toBN(details.version || 0)),
+    ]).then(this.responseParser.parseInvokeFunctionResponse);
+  }
+
+  public async callContract(
+    call: Call,
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<CallContractResponse> {
+    const result = await this.fetchEndpoint('starknet_call', [
+      {
+        contract_address: call.contractAddress,
+        entry_point_selector: getSelectorFromName(call.entrypoint),
+        calldata: parseCalldata(call.calldata),
+      },
+      blockIdentifier,
+    ]);
+
+    return this.responseParser.parseCallContractResponse(result);
+  }
+
+  public async waitForTransaction(txHash: BigNumberish, retryInterval: number = 8000) {
+    let onchain = false;
+    let retries = 100;
+
+    while (!onchain) {
+      const successStates = ['ACCEPTED_ON_L1', 'ACCEPTED_ON_L2', 'PENDING'];
+      const errorStates = ['REJECTED', 'NOT_RECEIVED'];
+
+      // eslint-disable-next-line no-await-in-loop
+      await wait(retryInterval);
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        const res = await this.getTransactionReceipt(txHash);
+
+        if (successStates.includes(res.status)) {
+          onchain = true;
+        } else if (errorStates.includes(res.status)) {
+          const message = res.status;
+          const error = new Error(message) as Error & { response: any };
+          error.response = res;
+          throw error;
+        }
+      } catch (error: unknown) {
+        if (error instanceof Error && errorStates.includes(error.message)) {
+          throw error;
+        }
+
+        if (retries === 0) {
+          throw error;
+        }
+      }
+
+      retries -= 1;
+    }
+
+    await wait(retryInterval);
+  }
+
+  /**
+   * Gets the transaction count from a block.
+   *
+   *
+   * @param blockIdentifier
+   * @returns Number of transactions
+   */
+  public async getTransactionCount(
+    blockIdentifier: BlockIdentifier
+  ): Promise<RPC.GetTransactionCountResponse> {
+    if (typeof blockIdentifier === 'number') {
+      return this.fetchEndpoint('starknet_getBlockTransactionCountByNumber', [blockIdentifier]);
+    }
+    return this.fetchEndpoint('starknet_getBlockTransactionCountByHash', [blockIdentifier]);
+  }
+
+  /**
+   * Gets the latest block number
+   *
+   *
+   * @returns Number of the latest block
+   */
+  public async getBlockNumber(): Promise<RPC.GetBlockNumberResponse> {
+    return this.fetchEndpoint('starknet_blockNumber');
+  }
+
+  /**
+   * Gets syncing status of the node
+   *
+   *
+   * @returns Object with the stats data
+   */
+  public async getSyncingStats(): Promise<RPC.GetSyncingStatsResponse> {
+    return this.fetchEndpoint('starknet_syncing');
+  }
+
+  /**
+   * Gets all the events filtered
+   *
+   *
+   * @returns events and the pagination of the events
+   */
+  public async getEvents(eventFilter: RPC.EventFilter): Promise<RPC.GetEventsResponse> {
+    return this.fetchEndpoint('starknet_getEvents', [eventFilter]);
+  }
+}