starknet 3.18.0 → 3.19.0

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 });

package/types/contract.d.ts

@@ -1,5 +1,5 @@
 export declare type AsyncContractFunction<T = any> = (...args: Array<any>) => Promise<T>;
 export declare type ContractFunction = (...args: Array<any>) => any;
 export interface Result extends Array<any> {
-  [key: string]: any;
+    [key: string]: any;
 }

package/types/contract.js

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

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

@@ -1,34 +1,35 @@
-'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('./lib'), exports);
-__exportStar(require('./api'), exports);
-__exportStar(require('./signer'), exports);
-__exportStar(require('./contract'), exports);
-__exportStar(require('./account'), exports);
+"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 __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);
+exports.api = __importStar(require("./api"));
+__exportStar(require("./signer"), exports);
+__exportStar(require("./contract"), exports);
+__exportStar(require("./account"), exports);
+__exportStar(require("./provider"), exports);

package/types/lib.d.ts

@@ -1,78 +1,73 @@
 import type { ec as EC } from 'elliptic';
-
 import type { BigNumberish } from '../utils/number';
 export declare type KeyPair = EC.KeyPair;
 export declare type Signature = string[];
 export declare type RawCalldata = BigNumberish[];
 export declare type DeployContractPayload = {
-  contract: CompiledContract | string;
-  constructorCalldata?: RawCalldata;
-  addressSalt?: BigNumberish;
+    contract: CompiledContract | string;
+    constructorCalldata?: RawCalldata;
+    addressSalt?: BigNumberish;
 };
 export declare type DeclareContractPayload = {
-  contract: CompiledContract | string;
+    contract: CompiledContract | string;
+    version?: BigNumberish;
 };
 export declare type Invocation = {
-  contractAddress: string;
-  entrypoint: string;
-  calldata?: RawCalldata;
-  signature?: Signature;
+    contractAddress: string;
+    entrypoint: string;
+    calldata?: RawCalldata;
+    signature?: Signature;
 };
 export declare type Call = Omit<Invocation, 'signature'>;
 export declare type InvocationsDetails = {
-  nonce?: BigNumberish;
-  maxFee?: BigNumberish;
-  version?: BigNumberish;
+    nonce?: BigNumberish;
+    maxFee?: BigNumberish;
+    version?: BigNumberish;
 };
-export declare type Status =
-  | 'NOT_RECEIVED'
-  | 'RECEIVED'
-  | 'PENDING'
-  | 'ACCEPTED_ON_L2'
-  | 'ACCEPTED_ON_L1'
-  | 'REJECTED';
+export declare type Status = 'NOT_RECEIVED' | 'RECEIVED' | 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
 export declare type TransactionStatus = 'TRANSACTION_RECEIVED';
 export declare type Type = 'DECLARE' | 'DEPLOY' | 'INVOKE_FUNCTION';
 export declare type EntryPointType = 'EXTERNAL';
 export declare type CompressedProgram = string;
 export declare type AbiEntry = {
-  name: string;
-  type: 'felt' | 'felt*' | string;
+    name: string;
+    type: 'felt' | 'felt*' | string;
 };
 export declare type FunctionAbi = {
-  inputs: AbiEntry[];
-  name: string;
-  outputs: AbiEntry[];
-  stateMutability?: 'view';
-  type: 'function' | 'constructor';
+    inputs: AbiEntry[];
+    name: string;
+    outputs: AbiEntry[];
+    stateMutability?: 'view';
+    type: 'function' | 'constructor';
 };
 export declare type StructAbi = {
-  members: (AbiEntry & {
-    offset: number;
-  })[];
-  name: string;
-  size: number;
-  type: 'struct';
+    members: (AbiEntry & {
+        offset: number;
+    })[];
+    name: string;
+    size: number;
+    type: 'struct';
 };
 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;
-  program: Program;
+    abi: Abi;
+    entry_points_by_type: EntryPointsByType;
+    program: Program;
 };
 export declare type CompressedCompiledContract = Omit<CompiledContract, 'program'> & {
-  program: CompressedProgram;
+    program: CompressedProgram;
 };
 export declare type Struct = {
-  type: 'struct';
-  [k: string]: BigNumberish;
+    type: 'struct';
+    [k: string]: BigNumberish;
 };
 export declare type Args = {
-  [inputName: string]: BigNumberish | BigNumberish[] | ParsedStruct | ParsedStruct[];
+    [inputName: string]: BigNumberish | BigNumberish[] | ParsedStruct | ParsedStruct[];
 };
 export declare type ParsedStruct = {
-  [key: string]: BigNumberish | ParsedStruct;
+    [key: string]: BigNumberish | ParsedStruct;
 };

package/types/lib.js

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

package/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/types/provider.js

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

package/types/signer.d.ts

@@ -1,6 +1,6 @@
 import { StarknetChainId } from '../constants';
 import { InvocationsDetails } from './lib';
 export interface InvocationsSignerDetails extends Required<InvocationsDetails> {
-  walletAddress: string;
-  chainId: StarknetChainId;
+    walletAddress: string;
+    chainId: StarknetChainId;
 }

package/types/signer.js

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