starknet 3.18.2 → 4.0.1

package/src/types/api/sequencer.ts

@@ -0,0 +1,331 @@
+import BN from 'bn.js';
+
+import { BlockIdentifier } from '../../provider/utils';
+import { BigNumberish } from '../../utils/number';
+import {
+  Abi,
+  BlockNumber,
+  EntryPointType,
+  RawCalldata,
+  Signature,
+  Status,
+  TransactionStatus,
+} from '../lib';
+import { ContractClass } from '../provider';
+
+export type GetTransactionStatusResponse = {
+  tx_status: Status;
+  block_hash?: string;
+  tx_failure_reason?: {
+    code: string;
+    error_message: string;
+  };
+};
+
+export type GetContractAddressesResponse = {
+  Starknet: string;
+  GpsStatementVerifier: string;
+};
+
+export type InvokeFunctionTrace = {
+  caller_address: string;
+  contract_address: string;
+  code_address: string;
+  selector: string;
+  calldata: RawCalldata;
+  result: Array<any>;
+  execution_resources: ExecutionResources;
+  internal_call: Array<InvokeFunctionTrace>;
+  events: Array<any>;
+  messages: Array<any>;
+};
+
+export type ExecutionResources = {
+  n_steps: number;
+  builtin_instance_counter: {
+    pedersen_builtin: number;
+    range_check_builtin: number;
+    bitwise_builtin: number;
+    output_builtin: number;
+    ecdsa_builtin: number;
+    ec_op_builtin?: number;
+  };
+  n_memory_holes: number;
+};
+
+export type GetCodeResponse = {
+  bytecode: string[];
+  abi: Abi;
+};
+
+export type GetTransactionTraceResponse = {
+  function_invocation: {
+    caller_address: string;
+    contract_address: string;
+    code_address: string;
+    selector: string;
+    calldata: RawArgs;
+    result: Array<any>;
+    execution_resources: ExecutionResources;
+    internal_call: Array<any>;
+    events: Array<any>;
+    messages: Array<any>;
+  };
+  signature: Signature;
+};
+
+export type RawArgs = {
+  [inputName: string]: string | string[] | { type: 'struct'; [k: string]: BigNumberish };
+};
+
+export namespace Sequencer {
+  export type DeclareTransaction = {
+    type: 'DECLARE';
+    contract_class: ContractClass;
+    nonce: BigNumberish;
+    sender_address: BigNumberish;
+    signature: Signature;
+  };
+
+  export type DeployTransaction = {
+    type: 'DEPLOY';
+    contract_definition: ContractClass;
+    contract_address_salt: BigNumberish;
+    constructor_calldata: string[];
+    nonce?: BigNumberish;
+  };
+
+  export type InvokeFunctionTransaction = {
+    type: 'INVOKE_FUNCTION';
+    contract_address: string;
+    signature?: Signature;
+    entry_point_type?: EntryPointType;
+    entry_point_selector: string;
+    calldata?: RawCalldata;
+    nonce?: BigNumberish;
+    max_fee?: BigNumberish;
+    version?: BigNumberish;
+  };
+
+  export type Transaction = DeclareTransaction | DeployTransaction | InvokeFunctionTransaction;
+
+  export type AddTransactionResponse = {
+    transaction_hash: string;
+    code?: TransactionStatus;
+    address?: string;
+    class_hash?: string;
+  };
+
+  export interface InvokeFunctionTransactionResponse extends InvokeFunctionTransaction {
+    transaction_hash: string;
+  }
+
+  export type TransactionResponse =
+    | DeclareTransaction
+    | DeployTransaction
+    | InvokeFunctionTransactionResponse;
+
+  export type SuccessfulTransactionResponse = {
+    status: Status;
+    transaction: TransactionResponse;
+    block_hash: string;
+    block_number: BlockNumber;
+    transaction_index: number;
+  };
+
+  export type FailedTransactionResponse = {
+    status: 'REJECTED';
+    transaction_failure_reason: {
+      code: string;
+      error_message: string;
+    };
+    transaction: TransactionResponse;
+  };
+
+  export type GetTransactionResponse = SuccessfulTransactionResponse | FailedTransactionResponse;
+
+  export type TransactionReceiptResponse =
+    | SuccessfulTransactionReceiptResponse
+    | FailedTransactionReceiptResponse;
+
+  export type SuccessfulTransactionReceiptResponse = {
+    status: Status;
+    transaction_hash: string;
+    transaction_index: number;
+    block_hash: string;
+    block_number: BlockNumber;
+    l2_to_l1_messages: string[];
+    events: string[];
+    actual_fee: string;
+    execution_resources: ExecutionResources;
+  };
+
+  export type FailedTransactionReceiptResponse = {
+    status: 'REJECTED';
+    transaction_failure_reason: {
+      code: string;
+      error_message: string;
+    };
+    transaction_hash: string;
+    l2_to_l1_messages: string[];
+    events: string[];
+  };
+
+  export type GetBlockResponse = {
+    block_number: number;
+    state_root: string;
+    block_hash: string;
+    transactions: {
+      [txHash: string]: TransactionResponse;
+    };
+    timestamp: number;
+    transaction_receipts: {
+      [txHash: string]: {
+        block_hash: string;
+        transaction_hash: string;
+        l2_to_l1_messages: {
+          to_address: string;
+          payload: string[];
+          from_address: string;
+        }[];
+        block_number: BlockNumber;
+        status: Status;
+        transaction_index: number;
+      };
+    };
+    parent_block_hash: string;
+    status: Status;
+    gas_price: string;
+    sequencer_address: string;
+  };
+
+  export type CallContractTransaction = Omit<
+    InvokeFunctionTransaction,
+    'type' | 'entry_point_type' | 'nonce'
+  >;
+
+  export type CallContractResponse = {
+    result: string[];
+  };
+
+  // Support 0.9.1 changes in a backward-compatible way
+  export type EstimateFeeResponse =
+    | {
+        overall_fee: number;
+        gas_price: number;
+        gas_usage: number;
+      }
+    | {
+        amount: BN;
+        unit: string;
+      };
+
+  export type Endpoints = {
+    get_contract_addresses: {
+      QUERY: never;
+      REQUEST: never;
+      RESPONSE: GetContractAddressesResponse;
+    };
+    add_transaction: {
+      QUERY: never;
+      REQUEST: Transaction;
+      RESPONSE: AddTransactionResponse;
+    };
+    get_transaction: {
+      QUERY: {
+        transactionHash: string;
+      };
+      REQUEST: never;
+      RESPONSE: GetTransactionResponse;
+    };
+    get_transaction_status: {
+      QUERY: {
+        transactionHash: string;
+      };
+      REQUEST: never;
+      RESPONSE: GetTransactionStatusResponse;
+    };
+    get_transaction_trace: {
+      QUERY: {
+        transactionHash: string;
+      };
+      REQUEST: never;
+      RESPONSE: GetTransactionTraceResponse;
+    };
+    get_transaction_receipt: {
+      QUERY: {
+        transactionHash: string;
+      };
+      REQUEST: never;
+      RESPONSE: TransactionReceiptResponse;
+    };
+    get_storage_at: {
+      QUERY: {
+        contractAddress: string;
+        key: BigNumberish;
+        blockIdentifier: BlockIdentifier;
+      };
+      REQUEST: never;
+      RESPONSE: string;
+    };
+    get_code: {
+      QUERY: {
+        contractAddress: string;
+        blockIdentifier: BlockIdentifier;
+      };
+      REQUEST: never;
+      RESPONSE: GetCodeResponse;
+    };
+    get_block: {
+      QUERY: {
+        blockIdentifier: BlockIdentifier;
+      };
+      REQUEST: never;
+      RESPONSE: GetBlockResponse;
+    };
+    call_contract: {
+      QUERY: {
+        blockIdentifier: BlockIdentifier;
+      };
+      REQUEST: CallContractTransaction;
+      RESPONSE: CallContractResponse;
+    };
+    estimate_fee: {
+      QUERY: {
+        blockIdentifier: BlockIdentifier;
+      };
+      REQUEST: CallContractTransaction;
+      RESPONSE: EstimateFeeResponse;
+    };
+    get_class_by_hash: {
+      QUERY: {
+        classHash: string;
+      };
+      REQUEST: never;
+      RESPONSE: any;
+    };
+    get_class_hash_at: {
+      QUERY: {
+        contractAddress: string;
+        blockIdentifier?: BlockIdentifier;
+      };
+      REQUEST: never;
+      RESPONSE: string;
+    };
+    get_state_update: {
+      QUERY: {
+        blockHash: string;
+      };
+      REQUEST: never;
+      RESPONSE: any;
+    };
+    get_full_contract: {
+      QUERY: {
+        contractAddress: string;
+        blockIdentifier?: BlockIdentifier;
+      };
+      REQUEST: never;
+      RESPONSE: any;
+    };
+  };
+}

package/src/types/index.ts

@@ -1,5 +1,7 @@
 export * from './lib';
-export * from './api';
+export * as api from './api';
+export { Calldata, Overrides, RawArgs } from './api';
 export * from './signer';
 export * from './contract';
 export * from './account';
+export * from './provider';

package/src/types/lib.ts

@@ -14,6 +14,7 @@ export type DeployContractPayload = {
 
 export type DeclareContractPayload = {
   contract: CompiledContract | string;
+  version?: BigNumberish;
 };
 
 export type Invocation = {
@@ -64,7 +65,8 @@ export type Abi = Array<FunctionAbi | StructAbi>;
 
 export type EntryPointsByType = object;
 export type Program = Record<any, any>;
-export type BlockNumber = 'pending' | 'latest' | null | number;
+export type BlockTag = 'pending' | 'latest';
+export type BlockNumber = BlockTag | null | number;
 
 export type CompiledContract = {
   abi: Abi;

package/src/types/provider.ts

@@ -0,0 +1,108 @@
+import BN from 'bn.js';
+
+import { Abi, CompressedProgram, EntryPointsByType, RawCalldata, Signature, Status } from './lib';
+
+export interface GetBlockResponse {
+  accepted_time: number;
+  block_hash: string;
+  block_number: number;
+  gas_price: string;
+  new_root: string;
+  old_root?: string;
+  parent_hash: string;
+  sequencer: string;
+  status: Status;
+  transactions: Array<string>;
+  starknet_version?: string;
+}
+
+export type GetTransactionResponse = InvokeTransactionResponse & DeclareTransactionResponse;
+
+export interface CommonTransactionResponse {
+  transaction_hash?: string;
+  version?: string;
+  signature?: Signature;
+  max_fee?: string;
+  nonce?: string;
+}
+
+export interface InvokeTransactionResponse extends CommonTransactionResponse {
+  contract_address?: string;
+  entry_point_selector?: string;
+  calldata: RawCalldata;
+}
+
+export interface ContractEntryPoint {
+  offset: string;
+  selector: string;
+}
+
+export interface ContractClass {
+  program: CompressedProgram;
+  entry_points_by_type: EntryPointsByType;
+  abi?: Abi;
+}
+
+export interface DeclareTransactionResponse extends CommonTransactionResponse {
+  contract_class?: any;
+  sender_address?: string;
+}
+
+export type GetTransactionReceiptResponse =
+  | InvokeTransactionReceiptResponse
+  | DeclareTransactionReceiptResponse;
+
+export interface CommonTransactionReceiptResponse {
+  transaction_hash: string;
+  status: Status;
+  actual_fee?: string;
+  status_data?: string;
+}
+
+export interface MessageToL1 {
+  to_address: string;
+  payload: Array<string>;
+}
+
+export interface Event {
+  from_address: string;
+  keys: Array<string>;
+  data: Array<string>;
+}
+
+export interface MessageToL2 {
+  from_address: string;
+  payload: Array<string>;
+}
+
+export interface InvokeTransactionReceiptResponse extends CommonTransactionReceiptResponse {
+  messages_sent: Array<MessageToL1>;
+  events: Array<Event>;
+  l1_origin_message?: MessageToL2;
+}
+
+export type DeclareTransactionReceiptResponse = CommonTransactionReceiptResponse;
+
+export interface EstimateFeeResponse {
+  overall_fee: BN;
+  gas_consumed?: BN;
+  gas_price?: BN;
+}
+
+export interface InvokeFunctionResponse {
+  transaction_hash: string;
+}
+
+export interface DeployContractResponse {
+  contract_address: string;
+  transaction_hash: string;
+}
+
+export interface DeclareContractResponse {
+  transaction_hash: string;
+  class_hash: string;
+}
+
+export type CallContractResponse = {
+  result: Array<string>;
+};

package/src/utils/fetchPonyfill.ts

@@ -0,0 +1,4 @@
+export default (typeof window !== 'undefined' && window.fetch) || // use buildin fetch in browser if available
+  (typeof global !== 'undefined' && global.fetch) || // use buildin fetch in node, react-native and service worker if available
+  // eslint-disable-next-line global-require
+  require('isomorphic-fetch'); // ponyfill fetch in node and browsers that don't have it

package/src/utils/provider.ts

@@ -0,0 +1,28 @@
+import { CompiledContract, ContractClass, RawCalldata } from '../types';
+import { parse } from './json';
+import { isHex, toBN, toHex } from './number';
+import { compressProgram } from './stark';
+
+export function wait(delay: number) {
+  return new Promise((res) => {
+    setTimeout(res, delay);
+  });
+}
+
+export function parseCalldata(calldata: RawCalldata = []) {
+  return calldata.map((data) => {
+    if (typeof data === 'string' && isHex(data as string)) {
+      return data;
+    }
+    return toHex(toBN(data));
+  });
+}
+
+export function parseContract(contract: CompiledContract | string) {
+  const parsedContract =
+    typeof contract === 'string' ? (parse(contract) as CompiledContract) : contract;
+  return {
+    ...parsedContract,
+    program: compressProgram(parsedContract.program),
+  } as ContractClass;
+}

package/src/utils/responseParser/index.ts

@@ -0,0 +1,28 @@
+import {
+  CallContractResponse,
+  DeclareContractResponse,
+  DeployContractResponse,
+  EstimateFeeResponse,
+  GetBlockResponse,
+  GetTransactionReceiptResponse,
+  GetTransactionResponse,
+  InvokeFunctionResponse,
+} from '../../types';
+
+export abstract class ResponseParser {
+  abstract parseGetBlockResponse(res: any): GetBlockResponse;
+
+  abstract parseGetTransactionResponse(res: any): GetTransactionResponse;
+
+  abstract parseGetTransactionReceiptResponse(res: any): GetTransactionReceiptResponse;
+
+  abstract parseFeeEstimateResponse(res: any): EstimateFeeResponse;
+
+  abstract parseCallContractResponse(res: any): CallContractResponse;
+
+  abstract parseInvokeFunctionResponse(res: any): InvokeFunctionResponse;
+
+  abstract parseDeployContractResponse(res: any): DeployContractResponse;
+
+  abstract parseDeclareContractResponse(res: any): DeclareContractResponse;
+}

package/src/utils/responseParser/rpc.ts

@@ -0,0 +1,93 @@
+import {
+  CallContractResponse,
+  DeclareContractResponse,
+  DeployContractResponse,
+  EstimateFeeResponse,
+  GetBlockResponse,
+  GetTransactionReceiptResponse,
+  GetTransactionResponse,
+  InvokeFunctionResponse,
+} from '../../types';
+import { RPC } from '../../types/api';
+import { toBN } from '../number';
+import { ResponseParser } from '.';
+
+export class RPCResponseParser extends ResponseParser {
+  public parseGetBlockResponse(res: RPC.GetBlockResponse): GetBlockResponse {
+    return {
+      accepted_time: res.accepted_time,
+      block_hash: res.block_hash,
+      block_number: res.block_number,
+      gas_price: res.gas_price,
+      new_root: res.new_root,
+      old_root: res.old_root,
+      parent_hash: res.parent_hash,
+      sequencer: res.sequencer,
+      status: res.status,
+      transactions: res.transactions,
+    };
+  }
+
+  public parseGetTransactionResponse(res: RPC.GetTransactionResponse): GetTransactionResponse {
+    return {
+      calldata: res.calldata || [],
+      contract_address: res.contract_address,
+      contract_class: res.contract_class,
+      entry_point_selector: res.entry_point_selector,
+      max_fee: res.max_fee,
+      nonce: res.nonce,
+      sender_address: res.sender_address,
+      signature: res.signature || [],
+      transaction_hash: res.txn_hash,
+      version: res.version,
+    };
+  }
+
+  public parseGetTransactionReceiptResponse(
+    res: RPC.GetTransactionReceiptResponse
+  ): GetTransactionReceiptResponse {
+    return {
+      transaction_hash: res.txn_hash,
+      actual_fee: res.actual_fee,
+      status: res.status,
+      status_data: res.status_data,
+      messages_sent: res.messages_sent,
+      l1_origin_message: res.l1_origin_message,
+      events: res.events,
+    };
+  }
+
+  public parseFeeEstimateResponse(res: RPC.EstimateFeeResponse): EstimateFeeResponse {
+    return {
+      overall_fee: toBN(res.overall_fee),
+      gas_consumed: toBN(res.gas_consumed),
+      gas_price: toBN(res.gas_price),
+    };
+  }
+
+  public parseCallContractResponse(res: Array<string>): CallContractResponse {
+    return {
+      result: res,
+    };
+  }
+
+  public parseInvokeFunctionResponse(res: RPC.AddTransactionResponse): InvokeFunctionResponse {
+    return {
+      transaction_hash: res.transaction_hash,
+    };
+  }
+
+  public parseDeployContractResponse(res: RPC.DeployContractResponse): DeployContractResponse {
+    return {
+      transaction_hash: res.transaction_hash,
+      contract_address: res.contract_address,
+    };
+  }
+
+  public parseDeclareContractResponse(res: RPC.DeclareResponse): DeclareContractResponse {
+    return {
+      transaction_hash: res.transaction_hash,
+      class_hash: res.class_hash,
+    };
+  }
+}