starknet 3.18.2 → 4.0.1

package/src/utils/responseParser/sequencer.ts

@@ -0,0 +1,127 @@
+import {
+  CallContractResponse,
+  DeclareContractResponse,
+  DeployContractResponse,
+  EstimateFeeResponse,
+  GetBlockResponse,
+  GetTransactionReceiptResponse,
+  GetTransactionResponse,
+  InvokeFunctionResponse,
+} from '../../types';
+import { Sequencer } from '../../types/api';
+import { toBN } from '../number';
+import { ResponseParser } from '.';
+
+export class SequencerAPIResponseParser extends ResponseParser {
+  public parseGetBlockResponse(res: Sequencer.GetBlockResponse): GetBlockResponse {
+    return {
+      accepted_time: res.timestamp,
+      block_hash: res.block_hash,
+      block_number: res.block_number,
+      gas_price: res.gas_price,
+      new_root: res.state_root,
+      old_root: undefined,
+      parent_hash: res.parent_block_hash,
+      sequencer: res.sequencer_address,
+      status: res.status,
+      transactions: Object.values(res.transactions)
+        .map((value) => 'transaction_hash' in value && value.transaction_hash)
+        .filter(Boolean) as Array<string>,
+    };
+  }
+
+  public parseGetTransactionResponse(
+    res: Sequencer.GetTransactionResponse
+  ): GetTransactionResponse {
+    return {
+      calldata: 'calldata' in res.transaction ? (res.transaction.calldata as Array<string>) : [],
+      contract_address:
+        'contract_address' in res.transaction ? res.transaction.contract_address : undefined,
+      contract_class:
+        'contract_class' in res.transaction ? (res.transaction.contract_class as any) : undefined,
+      entry_point_selector:
+        'entry_point_selector' in res.transaction
+          ? res.transaction.entry_point_selector
+          : undefined,
+      max_fee: 'max_fee' in res.transaction ? (res.transaction.max_fee as string) : undefined,
+      nonce: res.transaction.nonce as string,
+      sender_address:
+        'sender_address' in res.transaction
+          ? (res.transaction.sender_address as string)
+          : undefined,
+      signature: 'signature' in res.transaction ? res.transaction.signature : undefined,
+      transaction_hash:
+        'transaction_hash' in res.transaction ? res.transaction.transaction_hash : undefined,
+      version: 'version' in res.transaction ? (res.transaction.version as string) : undefined,
+    };
+  }
+
+  public parseGetTransactionReceiptResponse(
+    res: Sequencer.TransactionReceiptResponse
+  ): GetTransactionReceiptResponse {
+    return {
+      transaction_hash: res.transaction_hash,
+      actual_fee: 'actual_fee' in res ? res.actual_fee : undefined,
+      status: res.status,
+      status_data: undefined,
+      messages_sent: res.l2_to_l1_messages as any, // TODO: parse
+      events: res.events as any,
+      l1_origin_message: undefined,
+    };
+  }
+
+  public parseFeeEstimateResponse(res: Sequencer.EstimateFeeResponse): EstimateFeeResponse {
+    if ('overall_fee' in res) {
+      let gasInfo = {};
+
+      try {
+        gasInfo = {
+          gas_consumed: toBN(res.gas_usage),
+          gas_price: toBN(res.gas_price),
+        };
+      } catch {
+        // do nothing
+      }
+
+      return {
+        overall_fee: toBN(res.overall_fee),
+        ...gasInfo,
+      };
+    }
+    return {
+      overall_fee: toBN(res.amount),
+    };
+  }
+
+  public parseCallContractResponse(res: Sequencer.CallContractResponse): CallContractResponse {
+    return {
+      result: res.result,
+    };
+  }
+
+  public parseInvokeFunctionResponse(
+    res: Sequencer.AddTransactionResponse
+  ): InvokeFunctionResponse {
+    return {
+      transaction_hash: res.transaction_hash,
+    };
+  }
+
+  public parseDeployContractResponse(
+    res: Sequencer.AddTransactionResponse
+  ): DeployContractResponse {
+    return {
+      transaction_hash: res.transaction_hash,
+      contract_address: res.address as string,
+    };
+  }
+
+  public parseDeclareContractResponse(
+    res: Sequencer.AddTransactionResponse
+  ): DeclareContractResponse {
+    return {
+      transaction_hash: res.transaction_hash,
+      class_hash: res.class_hash as string,
+    };
+  }
+}

package/types/account.d.ts

@@ -1,13 +1,11 @@
 import BN from 'bn.js';
-
 import { BlockIdentifier } from '../provider/utils';
 import { BigNumberish } from '../utils/number';
-export interface EstimateFee {
-  amount: BN;
-  unit: string;
-  suggestedMaxFee: BN;
+import { EstimateFeeResponse } from './provider';
+export interface EstimateFee extends EstimateFeeResponse {
+    suggestedMaxFee: BN;
 }
 export interface EstimateFeeDetails {
-  nonce?: BigNumberish;
-  blockIdentifier?: BlockIdentifier;
+    nonce?: BigNumberish;
+    blockIdentifier?: BlockIdentifier;
 }

package/types/account.js

@@ -1,2 +1,2 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/api/index.d.ts

@@ -0,0 +1,16 @@
+import { BigNumberish } from '../../utils/number';
+import { Signature } from '../lib';
+export declare type RawArgs = {
+    [inputName: string]: string | string[] | {
+        type: 'struct';
+        [k: string]: BigNumberish;
+    };
+};
+export declare type Calldata = string[];
+export declare type Overrides = {
+    maxFee?: BigNumberish;
+    nonce?: BigNumberish;
+    signature?: Signature;
+};
+export * from './sequencer';
+export * from './rpc';

package/types/api/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sequencer"), exports);
+__exportStar(require("./rpc"), exports);

package/types/api/rpc.d.ts

@@ -0,0 +1,221 @@
+import { StarknetChainId } from '../../constants';
+import { Status } from '../lib';
+export declare namespace RPC {
+    export type Response = {
+        id: number;
+        result: any;
+        jsonrpc: string;
+        error?: {
+            code: string;
+            message: string;
+        };
+    };
+    export type AddTransactionResponse = {
+        transaction_hash: string;
+    };
+    export type GetClassResponse = {
+        program: string;
+        entry_point_by_type: any;
+    };
+    export type DeclareResponse = {
+        transaction_hash: string;
+        class_hash: string;
+    };
+    export type EstimateFeeResponse = {
+        overall_fee: number;
+        gas_consumed: number;
+        gas_price: number;
+    };
+    export type GetBlockResponse = {
+        block_hash: string;
+        parent_hash: string;
+        block_number: number;
+        status: Status;
+        sequencer: string;
+        new_root: string;
+        old_root: string;
+        accepted_time: number;
+        gas_price: string;
+        transactions: string[];
+    };
+    export type GetCodeResponse = {
+        bytecode: string[];
+        abi: string;
+    };
+    export type GetStorageAtResponse = string;
+    export type GetTransactionReceiptResponse = {
+        txn_hash: string;
+        actual_fee: string;
+        status: Status;
+        status_data: string;
+        messages_sent: Array<MessageToL1>;
+        l1_origin_message: MessageToL2;
+        events: Array<StarknetEvent>;
+    };
+    interface CommonTransactionProperties {
+        txn_hash: string;
+        max_fee: string;
+        version: string;
+        nonce: string;
+        signature: Array<string>;
+    }
+    export interface InvokeTransactionResponse extends CommonTransactionProperties {
+        contract_address?: string;
+        entry_point_selector?: string;
+        calldata?: Array<string>;
+    }
+    export interface DeclareTransactionResponse extends CommonTransactionProperties {
+        contract_class?: GetClassResponse;
+        sender_address?: string;
+    }
+    export type GetTransactionResponse = InvokeTransactionResponse & DeclareTransactionResponse;
+    export type GetTransactionCountResponse = number;
+    export type GetBlockNumberResponse = number;
+    export type GetSyncingStatsResponse = {
+        starting_block_hash: string;
+        starting_block_num: string;
+        current_block_hash: string;
+        current_block_num: string;
+        highest_block_hash: string;
+        highest_block_num: string;
+    } | boolean;
+    export type EventFilter = {
+        fromBlock: string;
+        toBlock: string;
+        address: string;
+        keys: string[];
+        page_size: number;
+        page_number: number;
+    };
+    export type GetEventsResponse = {
+        events: StarknetEmittedEvent[];
+        page_number: number;
+        is_last_page: number;
+    };
+    export type DeployContractResponse = {
+        transaction_hash: string;
+        contract_address: string;
+    };
+    export type StarknetEvent = {
+        from_address: string;
+        keys: string[];
+        data: string[];
+    };
+    export type StarknetEmittedEvent = {
+        event: StarknetEvent;
+        block_hash: string;
+        block_number: number;
+        transaction_hash: string;
+    };
+    export type MessageToL1 = {
+        to_address: string;
+        payload: string[];
+    };
+    export type MessageToL2 = {
+        from_address: string;
+        payload: string[];
+    };
+    export type Methods = {
+        starknet_getBlockByHash: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetBlockResponse;
+        };
+        starknet_getBlockByNumber: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetBlockResponse;
+        };
+        starknet_getStorageAt: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetStorageAtResponse;
+        };
+        starknet_getTransactionByHash: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetTransactionResponse;
+        };
+        starknet_getTransactionByBlockHashAndIndex: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetTransactionResponse;
+        };
+        starknet_getTransactionByBlockNumberAndIndex: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetTransactionResponse;
+        };
+        starknet_getTransactionReceipt: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetTransactionReceiptResponse;
+        };
+        starknet_getBlockTransactionCountByHash: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetTransactionCountResponse;
+        };
+        starknet_getBlockTransactionCountByNumber: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetTransactionCountResponse;
+        };
+        starknet_getCode: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetCodeResponse;
+        };
+        starknet_call: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: string[];
+        };
+        starknet_estimateFee: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: EstimateFeeResponse;
+        };
+        starknet_blockNumber: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetBlockNumberResponse;
+        };
+        starknet_chainId: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: StarknetChainId;
+        };
+        starknet_syncing: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetSyncingStatsResponse;
+        };
+        starknet_getEvents: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetEventsResponse;
+        };
+        starknet_addInvokeTransaction: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: AddTransactionResponse;
+        };
+        starknet_addDeployTransaction: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: DeployContractResponse;
+        };
+        starknet_addDeclareTransaction: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: DeclareResponse;
+        };
+        starknet_getClassAt: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: any;
+        };
+    };
+    export {};
+}

package/types/api/rpc.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/api/sequencer.d.ts

@@ -0,0 +1,289 @@
+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 declare type GetTransactionStatusResponse = {
+    tx_status: Status;
+    block_hash?: string;
+    tx_failure_reason?: {
+        code: string;
+        error_message: string;
+    };
+};
+export declare type GetContractAddressesResponse = {
+    Starknet: string;
+    GpsStatementVerifier: string;
+};
+export declare 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 declare 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 declare type GetCodeResponse = {
+    bytecode: string[];
+    abi: Abi;
+};
+export declare 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 declare type RawArgs = {
+    [inputName: string]: string | string[] | {
+        type: 'struct';
+        [k: string]: BigNumberish;
+    };
+};
+export declare namespace Sequencer {
+    type DeclareTransaction = {
+        type: 'DECLARE';
+        contract_class: ContractClass;
+        nonce: BigNumberish;
+        sender_address: BigNumberish;
+        signature: Signature;
+    };
+    type DeployTransaction = {
+        type: 'DEPLOY';
+        contract_definition: ContractClass;
+        contract_address_salt: BigNumberish;
+        constructor_calldata: string[];
+        nonce?: BigNumberish;
+    };
+    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;
+    };
+    type Transaction = DeclareTransaction | DeployTransaction | InvokeFunctionTransaction;
+    type AddTransactionResponse = {
+        transaction_hash: string;
+        code?: TransactionStatus;
+        address?: string;
+        class_hash?: string;
+    };
+    interface InvokeFunctionTransactionResponse extends InvokeFunctionTransaction {
+        transaction_hash: string;
+    }
+    type TransactionResponse = DeclareTransaction | DeployTransaction | InvokeFunctionTransactionResponse;
+    type SuccessfulTransactionResponse = {
+        status: Status;
+        transaction: TransactionResponse;
+        block_hash: string;
+        block_number: BlockNumber;
+        transaction_index: number;
+    };
+    type FailedTransactionResponse = {
+        status: 'REJECTED';
+        transaction_failure_reason: {
+            code: string;
+            error_message: string;
+        };
+        transaction: TransactionResponse;
+    };
+    type GetTransactionResponse = SuccessfulTransactionResponse | FailedTransactionResponse;
+    type TransactionReceiptResponse = SuccessfulTransactionReceiptResponse | FailedTransactionReceiptResponse;
+    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;
+    };
+    type FailedTransactionReceiptResponse = {
+        status: 'REJECTED';
+        transaction_failure_reason: {
+            code: string;
+            error_message: string;
+        };
+        transaction_hash: string;
+        l2_to_l1_messages: string[];
+        events: string[];
+    };
+    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;
+    };
+    type CallContractTransaction = Omit<InvokeFunctionTransaction, 'type' | 'entry_point_type' | 'nonce'>;
+    type CallContractResponse = {
+        result: string[];
+    };
+    type EstimateFeeResponse = {
+        overall_fee: number;
+        gas_price: number;
+        gas_usage: number;
+    } | {
+        amount: BN;
+        unit: string;
+    };
+    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/types/api/sequencer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });