starknet 3.18.2 → 3.19.0

package/dist/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/dist/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/dist/types/api/sequencer.js

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

package/dist/types/index.d.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/dist/types/index.js

@@ -10,12 +10,26 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 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);
 };
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.api = void 0;
 __exportStar(require("./lib"), exports);
-__exportStar(require("./api"), exports);
+exports.api = __importStar(require("./api"));
 __exportStar(require("./signer"), exports);
 __exportStar(require("./contract"), exports);
 __exportStar(require("./account"), exports);
+__exportStar(require("./provider"), exports);

package/dist/types/lib.d.ts

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

package/dist/types/provider.d.ts

@@ -0,0 +1,86 @@
+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 declare 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 declare 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 declare 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 declare type CallContractResponse = {
+    result: Array<string>;
+};

package/dist/types/provider.js

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

package/dist/utils/provider.d.ts

@@ -0,0 +1,4 @@
+import { CompiledContract, ContractClass, RawCalldata } from '../types';
+export declare function wait(delay: number): Promise<unknown>;
+export declare function parseCalldata(calldata?: RawCalldata): string[];
+export declare function parseContract(contract: CompiledContract | string): ContractClass;

package/dist/utils/provider.js

@@ -0,0 +1,38 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseContract = exports.parseCalldata = exports.wait = void 0;
+var json_1 = require("./json");
+var number_1 = require("./number");
+var stark_1 = require("./stark");
+function wait(delay) {
+    return new Promise(function (res) {
+        setTimeout(res, delay);
+    });
+}
+exports.wait = wait;
+function parseCalldata(calldata) {
+    if (calldata === void 0) { calldata = []; }
+    return calldata.map(function (data) {
+        if (typeof data === 'string' && (0, number_1.isHex)(data)) {
+            return data;
+        }
+        return (0, number_1.toHex)((0, number_1.toBN)(data));
+    });
+}
+exports.parseCalldata = parseCalldata;
+function parseContract(contract) {
+    var parsedContract = typeof contract === 'string' ? (0, json_1.parse)(contract) : contract;
+    return __assign(__assign({}, parsedContract), { program: (0, stark_1.compressProgram)(parsedContract.program) });
+}
+exports.parseContract = parseContract;