starknet 4.4.2 → 4.6.0

package/src/provider/rpc.ts

@@ -29,13 +29,14 @@ import { parseCalldata, parseContract, wait } from '../utils/provider';
 import { RPCResponseParser } from '../utils/responseParser/rpc';
 import { randomAddress } from '../utils/stark';
 import { ProviderInterface } from './interface';
-import { BlockIdentifier, BlockIdentifierClass } from './utils';
+import { Block, BlockIdentifier } from './utils';
 
 export type RpcProviderOptions = { nodeUrl: string };
 
 export class RpcProvider implements ProviderInterface {
   public nodeUrl: string;
 
+  // from interface
   public chainId!: StarknetChainId;
 
   private responseParser = new RPCResponseParser();
@@ -49,87 +50,106 @@ export class RpcProvider implements ProviderInterface {
     });
   }
 
+  public fetch(method: any, params: any): Promise<any> {
+    return fetch(this.nodeUrl, {
+      method: 'POST',
+      body: stringify({ method, jsonrpc: '2.0', params, id: 0 }),
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  protected errorHandler(error: any) {
+    if (error) {
+      const { code, message } = error;
+      throw new Error(`${code}: ${message}`);
+    }
+  }
+
   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 rawResult = await this.fetch(method, request);
       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'];
-      }
+      this.errorHandler(error);
+      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}`);
-      }
+      this.errorHandler(error?.response?.data);
       throw error;
     }
   }
 
-  public async getChainId(): Promise<StarknetChainId> {
+  // Methods from Interface
+  public async getChainId(): Promise<any> {
     return this.fetchEndpoint('starknet_chainId');
   }
 
-  // Common Interface
+  // Methods from Interface
   public async getBlock(blockIdentifier: BlockIdentifier = 'pending'): Promise<GetBlockResponse> {
     return this.getBlockWithTxHashes(blockIdentifier).then(
       this.responseParser.parseGetBlockResponse
     );
   }
 
+  public async getBlockHashAndNumber(): Promise<RPC.BlockHashAndNumber> {
+    return this.fetchEndpoint('starknet_blockHashAndNumber');
+  }
+
   public async getBlockWithTxHashes(
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<RPC.GetBlockWithTxHashesResponse> {
-    const blockIdentifierGetter = new BlockIdentifierClass(blockIdentifier);
-    return this.fetchEndpoint('starknet_getBlockWithTxHashes', [
-      blockIdentifierGetter.getIdentifier(),
-    ]);
+    const block = new Block(blockIdentifier);
+    return this.fetchEndpoint('starknet_getBlockWithTxHashes', [block.identifier]);
   }
 
   public async getBlockWithTxs(
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<RPC.GetBlockWithTxs> {
-    const blockIdentifierGetter = new BlockIdentifierClass(blockIdentifier);
-    return this.fetchEndpoint('starknet_getBlockWithTxs', [blockIdentifierGetter.getIdentifier()]);
+    const block = new Block(blockIdentifier);
+    return this.fetchEndpoint('starknet_getBlockWithTxs', [block.identifier]);
+  }
+
+  public async getClassHashAt(
+    blockIdentifier: BlockIdentifier,
+    contractAddress: RPC.ContractAddress
+  ): Promise<RPC.Felt> {
+    const block = new Block(blockIdentifier);
+    return this.fetchEndpoint('starknet_getClassHashAt', [block.identifier, contractAddress]);
   }
 
   public async getNonce(contractAddress: string): Promise<any> {
     return this.fetchEndpoint('starknet_getNonce', [contractAddress]);
   }
 
+  public async getPendingTransactions(): Promise<RPC.PendingTransactions> {
+    return this.fetchEndpoint('starknet_pendingTransactions');
+  }
+
+  public async getProtocolVersion(): Promise<Error> {
+    throw new Error('Pathfinder does not implement this rpc 0.1.0 method');
+  }
+
+  public async getStateUpdate(blockIdentifier: BlockIdentifier): Promise<RPC.StateUpdate> {
+    const block = new Block(blockIdentifier);
+    return this.fetchEndpoint('starknet_getStateUpdate', [block.identifier]);
+  }
+
   public async getStorageAt(
     contractAddress: string,
     key: BigNumberish,
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<BigNumberish> {
     const parsedKey = toHex(toBN(key));
-    const blockIdentifierGetter = new BlockIdentifierClass(blockIdentifier);
+    const block = new Block(blockIdentifier);
     return this.fetchEndpoint('starknet_getStorageAt', [
       contractAddress,
       parsedKey,
-      blockIdentifierGetter.getIdentifier(),
+      block.identifier,
     ]);
   }
 
-  // common interface
+  // Methods from Interface
   public async getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse> {
     return this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse);
   }
@@ -144,7 +164,11 @@ export class RpcProvider implements ProviderInterface {
     blockIdentifier: BlockIdentifier,
     index: number
   ): Promise<RPC.GetTransactionByBlockIdAndIndex> {
-    return this.fetchEndpoint('starknet_getTransactionByHash', [blockIdentifier, index]);
+    const block = new Block(blockIdentifier);
+    return this.fetchEndpoint('starknet_getTransactionByBlockIdAndIndex', [
+      block.identifier,
+      index,
+    ]);
   }
 
   public async getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse> {
@@ -153,12 +177,20 @@ export class RpcProvider implements ProviderInterface {
     );
   }
 
+  public async getClass(classHash: RPC.Felt): Promise<RPC.ContractClass> {
+    return this.fetchEndpoint('starknet_getClass', [classHash]);
+  }
+
   public async getClassAt(contractAddress: string, blockIdentifier: BlockIdentifier): Promise<any> {
-    const blockIdentifierGetter = new BlockIdentifierClass(blockIdentifier);
-    return this.fetchEndpoint('starknet_getClassAt', [
-      blockIdentifierGetter.getIdentifier(),
-      contractAddress,
-    ]);
+    const block = new Block(blockIdentifier);
+    return this.fetchEndpoint('starknet_getClassAt', [block.identifier, contractAddress]);
+  }
+
+  public async getCode(
+    _contractAddress: string,
+    _blockIdentifier?: BlockIdentifier
+  ): Promise<GetCodeResponse> {
+    throw new Error('RPC 0.1.0 does not implement getCode function');
   }
 
   public async getEstimateFee(
@@ -166,6 +198,7 @@ export class RpcProvider implements ProviderInterface {
     blockIdentifier: BlockIdentifier = 'pending',
     invocationDetails: InvocationsDetails = {}
   ): Promise<EstimateFeeResponse> {
+    const block_id = new Block(blockIdentifier).identifier;
     return this.fetchEndpoint('starknet_estimateFee', [
       {
         contract_address: invocation.contractAddress,
@@ -174,7 +207,7 @@ export class RpcProvider implements ProviderInterface {
         signature: bigNumberishArrayToHexadecimalStringArray(invocation.signature || []),
         version: toHex(toBN(invocationDetails?.version || 0)),
       },
-      blockIdentifier,
+      block_id,
     ]).then(this.responseParser.parseFeeEstimateResponse);
   }
 
@@ -188,6 +221,7 @@ export class RpcProvider implements ProviderInterface {
       {
         program: contractDefinition.program,
         entry_points_by_type: contractDefinition.entry_points_by_type,
+        abi: contractDefinition.abi, // rpc 2.0
       },
       toHex(toBN(version || 0)),
     ]).then(this.responseParser.parseDeclareContractResponse);
@@ -206,6 +240,7 @@ export class RpcProvider implements ProviderInterface {
       {
         program: contractDefinition.program,
         entry_points_by_type: contractDefinition.entry_points_by_type,
+        abi: contractDefinition.abi, // rpc 2.0
       },
     ]).then(this.responseParser.parseDeployContractResponse);
   }
@@ -226,32 +261,35 @@ export class RpcProvider implements ProviderInterface {
     ]).then(this.responseParser.parseInvokeFunctionResponse);
   }
 
+  // Methods from Interface
   public async callContract(
     call: Call,
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<CallContractResponse> {
+    const block_id = new Block(blockIdentifier).identifier;
     const result = await this.fetchEndpoint('starknet_call', [
       {
         contract_address: call.contractAddress,
         entry_point_selector: getSelectorFromName(call.entrypoint),
         calldata: parseCalldata(call.calldata),
       },
-      blockIdentifier,
+      block_id,
     ]);
 
     return this.responseParser.parseCallContractResponse(result);
   }
 
-  public async getCode(
-    _contractAddress: string,
-    _blockIdentifier?: BlockIdentifier
-  ): Promise<GetCodeResponse> {
-    throw new Error('RPC 0.1.0 does not implement getCode function');
+  public async traceTransaction(transactionHash: RPC.TransactionHash): Promise<RPC.Trace> {
+    return this.fetchEndpoint('starknet_traceTransaction', [transactionHash]);
+  }
+
+  public async traceBlockTransactions(blockHash: RPC.BlockHash): Promise<RPC.Traces> {
+    return this.fetchEndpoint('starknet_traceBlockTransactions', [blockHash]);
   }
 
   public async waitForTransaction(txHash: BigNumberish, retryInterval: number = 8000) {
     let onchain = false;
-    let retries = 100;
+    let retries = 200;
 
     while (!onchain) {
       const successStates = ['ACCEPTED_ON_L1', 'ACCEPTED_ON_L2', 'PENDING'];
@@ -297,10 +335,8 @@ export class RpcProvider implements ProviderInterface {
   public async getTransactionCount(
     blockIdentifier: BlockIdentifier
   ): Promise<RPC.GetTransactionCountResponse> {
-    const blockIdentifierGetter = new BlockIdentifierClass(blockIdentifier);
-    return this.fetchEndpoint('starknet_getBlockTransactionCount', [
-      blockIdentifierGetter.getIdentifier(),
-    ]);
+    const block = new Block(blockIdentifier);
+    return this.fetchEndpoint('starknet_getBlockTransactionCount', [block.identifier]);
   }
 
   /**

package/src/provider/sequencer.ts

@@ -33,7 +33,7 @@ import { randomAddress } from '../utils/stark';
 import { buildUrl } from '../utils/url';
 import { GatewayError, HttpError } from './errors';
 import { ProviderInterface } from './interface';
-import { BlockIdentifier, getFormattedBlockIdentifier } from './utils';
+import { Block, BlockIdentifier } from './utils';
 
 type NetworkName = 'mainnet-alpha' | 'goerli-alpha';
 
@@ -129,7 +129,8 @@ export class SequencerProvider implements ProviderInterface {
     const queryString = Object.entries(query)
       .map(([key, value]) => {
         if (key === 'blockIdentifier') {
-          return `${getFormattedBlockIdentifier(value)}`;
+          const block = new Block(value);
+          return `${block.queryIdentifier}`;
         }
         return `${key}=${value}`;
       })
@@ -207,6 +208,10 @@ export class SequencerProvider implements ProviderInterface {
     }
   }
 
+  public async getChainId(): Promise<StarknetChainId> {
+    return Promise.resolve(this.chainId);
+  }
+
   public async callContract(
     { contractAddress, entrypoint: entryPointSelector, calldata = [] }: Call,
     blockIdentifier: BlockIdentifier = 'pending'

package/src/provider/utils.ts

@@ -1,3 +1,4 @@
+/* eslint-disable max-classes-per-file */
 import type { BlockNumber } from '../types';
 import { BigNumberish, isHex, toBN, toHex } from '../utils/number';
 
@@ -33,73 +34,59 @@ export function txIdentifier(txHash?: BigNumberish, txId?: BigNumberish): string
 // null appends nothing to the request url
 
 export type BlockIdentifier = BlockNumber | BigNumberish;
-type BlockIdentifierObject =
-  | { type: 'BLOCK_NUMBER'; data: BlockNumber }
-  | { type: 'BLOCK_HASH'; data: BigNumberish };
 
-export class BlockIdentifierClass {
-  blockIdentifier: BlockIdentifier;
+export class Block {
+  hash: BlockIdentifier = null;
 
-  constructor(blockIdentifier: BlockIdentifier) {
-    this.blockIdentifier = blockIdentifier;
+  number: BlockIdentifier = null;
+
+  tag: BlockIdentifier = null;
+
+  private setIdentifier: (_identifier: BlockIdentifier) => void;
+
+  constructor(_identifier: BlockIdentifier) {
+    this.setIdentifier = function (__identifier: BlockIdentifier) {
+      if (typeof __identifier === 'string' && isHex(__identifier)) {
+        this.hash = __identifier;
+      } else if (typeof __identifier === 'number') {
+        this.number = __identifier;
+      } else {
+        this.tag = __identifier;
+      }
+    };
+
+    this.setIdentifier(_identifier);
   }
 
-  getIdentifier() {
-    if (typeof this.blockIdentifier === 'string' && isHex(this.blockIdentifier)) {
-      return { block_hash: this.blockIdentifier };
+  get queryIdentifier(): any {
+    if (this.number !== null) {
+      return `blockNumber=${this.number}`;
     }
 
-    if (typeof this.blockIdentifier === 'number') {
-      return { block_number: this.blockIdentifier };
+    if (this.hash !== null) {
+      return `blockHash=${this.hash}`;
     }
 
-    return this.blockIdentifier;
+    return `blockNumber=${this.tag}`;
   }
-}
 
-/**
- * Identifies the block to be queried.
- *
- * @param blockIdentifier - block identifier
- * @returns block identifier object
- */
-export function getBlockIdentifier(blockIdentifier: BlockIdentifier): BlockIdentifierObject {
-  if (blockIdentifier === null || blockIdentifier === 'latest') {
-    return { type: 'BLOCK_NUMBER', data: 'latest' }; // default to latest block
-  }
-  if (blockIdentifier === 'pending') {
-    return { type: 'BLOCK_NUMBER', data: 'pending' };
-  }
-  if (typeof blockIdentifier === 'number' || typeof blockIdentifier === 'bigint') {
-    return { type: 'BLOCK_NUMBER', data: blockIdentifier };
-  }
-  if (typeof blockIdentifier === 'string' && blockIdentifier.startsWith('0x')) {
-    return { type: 'BLOCK_HASH', data: blockIdentifier };
-  }
-  if (typeof blockIdentifier === 'string' && !Number.isNaN(parseInt(blockIdentifier, 10))) {
-    return { type: 'BLOCK_NUMBER', data: parseInt(blockIdentifier, 10) };
-  }
-  if (typeof blockIdentifier === 'string') {
-    throw new Error(`Invalid block identifier: ${blockIdentifier}`);
-  }
-  return { type: 'BLOCK_HASH', data: blockIdentifier };
-}
+  get identifier(): any {
+    if (this.number !== null) {
+      return { block_number: this.number };
+    }
 
-/**
- * Gets the block identifier for API request
- *
- * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L164-L173)
- *
- * @param blockIdentifier
- * @returns block identifier for API request
- */
-export function getFormattedBlockIdentifier(blockIdentifier: BlockIdentifier = null): string {
-  const blockIdentifierObject = getBlockIdentifier(blockIdentifier);
-  if (blockIdentifierObject.type === 'BLOCK_NUMBER' && blockIdentifierObject.data === null) {
-    return '';
+    if (this.hash !== null) {
+      return { block_hash: this.hash };
+    }
+
+    return this.tag;
   }
-  if (blockIdentifierObject.type === 'BLOCK_NUMBER') {
-    return `blockNumber=${blockIdentifierObject.data}`;
+
+  set identifier(_identifier: BlockIdentifier) {
+    this.setIdentifier(_identifier);
   }
-  return `blockHash=${toHex(toBN(blockIdentifierObject.data))}`;
+
+  valueOf = () => this.number;
+
+  toString = () => this.hash;
 }