starknet 6.9.0 → 6.10.1

package/dist/types/lib/index.d.ts

@@ -0,0 +1,259 @@
+import { ValuesType } from '../helpers/valuesType';
+import { StarknetChainId } from '../../constants';
+import { weierstrass } from '../../utils/ec';
+import { EDataAvailabilityMode, ResourceBounds } from '../api';
+import { CairoEnum } from '../cairoEnum';
+import { CompiledContract, CompiledSierraCasm, ContractClass } from './contract';
+export type WeierstrassSignatureType = weierstrass.SignatureType;
+export type ArraySignatureType = string[];
+export type Signature = ArraySignatureType | WeierstrassSignatureType;
+export type BigNumberish = string | number | bigint;
+export type ByteArray = {
+    data: BigNumberish[];
+    pending_word: BigNumberish;
+    pending_word_len: BigNumberish;
+};
+/**
+ * Compiled calldata ready to be sent
+ *
+ * decimal-string array
+ */
+export type Calldata = string[] & {
+    readonly __compiled__?: true;
+};
+/**
+ * Represents an integer in the range [0, 2^256)
+ */
+export interface Uint256 {
+    low: BigNumberish;
+    high: BigNumberish;
+}
+/**
+ * Represents an integer in the range [0, 2^256)
+ */
+export interface Uint512 {
+    limb0: BigNumberish;
+    limb1: BigNumberish;
+    limb2: BigNumberish;
+    limb3: BigNumberish;
+}
+/**
+ * BigNumberish array
+ *
+ * use CallData.compile() to convert to Calldata
+ */
+export type RawCalldata = BigNumberish[];
+/**
+ * Hexadecimal-string array
+ */
+export type HexCalldata = string[];
+export type AllowArray<T> = T | T[];
+export type OptionalPayload<T> = {
+    payload: T;
+} | T;
+export type RawArgs = RawArgsObject | RawArgsArray;
+export type RawArgsObject = {
+    [inputName: string]: MultiType | MultiType[] | RawArgs;
+};
+export type RawArgsArray = Array<MultiType | MultiType[] | RawArgs>;
+export type MultiType = BigNumberish | Uint256 | object | boolean | CairoEnum;
+export type UniversalDeployerContractPayload = {
+    classHash: BigNumberish;
+    salt?: string;
+    unique?: boolean;
+    constructorCalldata?: RawArgs;
+};
+export type DeployAccountContractPayload = {
+    classHash: string;
+    constructorCalldata?: RawArgs;
+    addressSalt?: BigNumberish;
+    contractAddress?: string;
+};
+export type DeployAccountContractTransaction = Omit<DeployAccountContractPayload, 'contractAddress'> & {
+    signature?: Signature;
+};
+export type DeclareContractPayload = {
+    contract: CompiledContract | string;
+    classHash?: string;
+    casm?: CompiledSierraCasm;
+    compiledClassHash?: string;
+};
+export type CompleteDeclareContractPayload = {
+    contract: CompiledContract | string;
+    classHash: string;
+    casm?: CompiledSierraCasm;
+    compiledClassHash?: string;
+};
+export type DeclareAndDeployContractPayload = Omit<UniversalDeployerContractPayload, 'classHash'> & DeclareContractPayload;
+export type DeclareContractTransaction = {
+    contract: ContractClass;
+    senderAddress: string;
+    signature?: Signature;
+    compiledClassHash?: string;
+};
+export type CallDetails = {
+    contractAddress: string;
+    calldata?: RawArgs | Calldata;
+    entrypoint?: string;
+};
+export type Invocation = CallDetails & {
+    signature?: Signature;
+};
+export type Call = CallDetails & {
+    entrypoint: string;
+};
+export type CairoVersion = '0' | '1' | undefined;
+export type CompilerVersion = '0' | '1' | '2' | undefined;
+export type InvocationsDetails = {
+    nonce?: BigNumberish;
+    maxFee?: BigNumberish;
+    version?: BigNumberish;
+} & Partial<V3TransactionDetails>;
+export type V3TransactionDetails = {
+    nonce: BigNumberish;
+    version: BigNumberish;
+    resourceBounds: ResourceBounds;
+    tip: BigNumberish;
+    paymasterData: BigNumberish[];
+    accountDeploymentData: BigNumberish[];
+    nonceDataAvailabilityMode: EDataAvailabilityMode;
+    feeDataAvailabilityMode: EDataAvailabilityMode;
+};
+/**
+ * Contain all additional details params
+ */
+export type Details = {
+    nonce: BigNumberish;
+    maxFee: BigNumberish;
+    version: BigNumberish;
+    chainId: StarknetChainId;
+};
+export type InvocationsDetailsWithNonce = (InvocationsDetails & {
+    nonce: BigNumberish;
+}) | V3TransactionDetails;
+export declare const TransactionType: {
+    readonly DECLARE: "DECLARE";
+    readonly DEPLOY: "DEPLOY";
+    readonly DEPLOY_ACCOUNT: "DEPLOY_ACCOUNT";
+    readonly INVOKE: "INVOKE_FUNCTION";
+};
+export type TransactionType = ValuesType<typeof TransactionType>;
+/**
+ * new statuses are defined by props: finality_status and execution_status
+ * to be #deprecated
+ */
+export declare const TransactionStatus: {
+    readonly NOT_RECEIVED: "NOT_RECEIVED";
+    readonly RECEIVED: "RECEIVED";
+    readonly ACCEPTED_ON_L2: "ACCEPTED_ON_L2";
+    readonly ACCEPTED_ON_L1: "ACCEPTED_ON_L1";
+    readonly REJECTED: "REJECTED";
+    readonly REVERTED: "REVERTED";
+};
+export type TransactionStatus = ValuesType<typeof TransactionStatus>;
+export declare const TransactionFinalityStatus: {
+    readonly NOT_RECEIVED: "NOT_RECEIVED";
+    readonly RECEIVED: "RECEIVED";
+    readonly ACCEPTED_ON_L2: "ACCEPTED_ON_L2";
+    readonly ACCEPTED_ON_L1: "ACCEPTED_ON_L1";
+};
+export type TransactionFinalityStatus = ValuesType<typeof TransactionFinalityStatus>;
+export declare const TransactionExecutionStatus: {
+    readonly REJECTED: "REJECTED";
+    readonly REVERTED: "REVERTED";
+    readonly SUCCEEDED: "SUCCEEDED";
+};
+export type TransactionExecutionStatus = ValuesType<typeof TransactionExecutionStatus>;
+export declare const BlockStatus: {
+    readonly PENDING: "PENDING";
+    readonly ACCEPTED_ON_L1: "ACCEPTED_ON_L1";
+    readonly ACCEPTED_ON_L2: "ACCEPTED_ON_L2";
+    readonly REJECTED: "REJECTED";
+};
+export type BlockStatus = ValuesType<typeof BlockStatus>;
+export declare const BlockTag: {
+    readonly PENDING: "pending";
+    readonly LATEST: "latest";
+};
+export type BlockTag = ValuesType<typeof BlockTag>;
+export type BlockNumber = BlockTag | null | number;
+/**
+ * hex string and BigInt are detected as block hashes
+ *
+ * decimal string and number are detected as block numbers
+ *
+ * text string are detected as block tag
+ *
+ * null return 'pending' block tag
+ */
+export type BlockIdentifier = BlockNumber | BigNumberish;
+/**
+ * items used by AccountInvocations
+ */
+export type AccountInvocationItem = (({
+    type: typeof TransactionType.DECLARE;
+} & DeclareContractTransaction) | ({
+    type: typeof TransactionType.DEPLOY_ACCOUNT;
+} & DeployAccountContractTransaction) | ({
+    type: typeof TransactionType.INVOKE;
+} & Invocation)) & InvocationsDetailsWithNonce;
+/**
+ * Complete invocations array with account details (internal type from account -> provider)
+ */
+export type AccountInvocations = AccountInvocationItem[];
+/**
+ * Invocations array user provide to bulk method (simulate)
+ */
+export type Invocations = Array<({
+    type: typeof TransactionType.DECLARE;
+} & OptionalPayload<DeclareContractPayload>) | ({
+    type: typeof TransactionType.DEPLOY;
+} & OptionalPayload<AllowArray<UniversalDeployerContractPayload>>) | ({
+    type: typeof TransactionType.DEPLOY_ACCOUNT;
+} & OptionalPayload<DeployAccountContractPayload>) | ({
+    type: typeof TransactionType.INVOKE;
+} & OptionalPayload<AllowArray<Call>>)>;
+export type Tupled = {
+    element: any;
+    type: string;
+};
+export type Args = {
+    [inputName: string]: BigNumberish | BigNumberish[] | ParsedStruct | ParsedStruct[];
+};
+export type ParsedStruct = {
+    [key: string]: BigNumberish | BigNumberish[] | ParsedStruct | Uint256;
+};
+export type waitForTransactionOptions = {
+    retryInterval?: number;
+    successStates?: Array<TransactionFinalityStatus | TransactionExecutionStatus>;
+    errorStates?: Array<TransactionFinalityStatus | TransactionExecutionStatus>;
+};
+export type getSimulateTransactionOptions = {
+    blockIdentifier?: BlockIdentifier;
+    skipValidate?: boolean;
+    skipExecute?: boolean;
+    skipFeeCharge?: boolean;
+};
+export type getContractVersionOptions = {
+    blockIdentifier?: BlockIdentifier;
+    compiler?: boolean;
+};
+export type getEstimateFeeBulkOptions = {
+    blockIdentifier?: BlockIdentifier;
+    skipValidate?: boolean;
+};
+export interface CallStruct {
+    to: string;
+    selector: string;
+    calldata: string[];
+}
+/**
+ * Represent Contract version
+ */
+export type ContractVersion = {
+    /** version of the cairo language */
+    cairo: CairoVersion;
+    /** version of the cairo compiler used to compile the contract */
+    compiler: CompilerVersion;
+};
+export * from './contract';

package/dist/types/lib/index.mjs

@@ -0,0 +1,36 @@
+export const TransactionType = {
+  DECLARE: "DECLARE",
+  DEPLOY: "DEPLOY",
+  DEPLOY_ACCOUNT: "DEPLOY_ACCOUNT",
+  INVOKE: "INVOKE_FUNCTION"
+};
+export const TransactionStatus = {
+  NOT_RECEIVED: "NOT_RECEIVED",
+  RECEIVED: "RECEIVED",
+  ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+  ACCEPTED_ON_L1: "ACCEPTED_ON_L1",
+  REJECTED: "REJECTED",
+  REVERTED: "REVERTED"
+};
+export const TransactionFinalityStatus = {
+  NOT_RECEIVED: "NOT_RECEIVED",
+  RECEIVED: "RECEIVED",
+  ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+  ACCEPTED_ON_L1: "ACCEPTED_ON_L1"
+};
+export const TransactionExecutionStatus = {
+  REJECTED: "REJECTED",
+  REVERTED: "REVERTED",
+  SUCCEEDED: "SUCCEEDED"
+};
+export const BlockStatus = {
+  PENDING: "PENDING",
+  ACCEPTED_ON_L1: "ACCEPTED_ON_L1",
+  ACCEPTED_ON_L2: "ACCEPTED_ON_L2",
+  REJECTED: "REJECTED"
+};
+export const BlockTag = {
+  PENDING: "pending",
+  LATEST: "latest"
+};
+export * from "./contract/index.mjs";

package/dist/types/provider/configuration.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/types/provider/configuration.d.ts

@@ -0,0 +1,20 @@
+import { NetworkName, StarknetChainId } from '../../constants';
+import { BlockIdentifier } from '../lib';
+export interface ProviderOptions extends RpcProviderOptions {
+}
+export type RpcProviderOptions = {
+    nodeUrl?: string | NetworkName;
+    retries?: number;
+    transactionRetryIntervalFallback?: number;
+    headers?: object;
+    blockIdentifier?: BlockIdentifier;
+    chainId?: StarknetChainId;
+    specVersion?: string;
+    default?: boolean;
+    waitMode?: boolean;
+    feeMarginPercentage?: {
+        l1BoundMaxAmount: number;
+        l1BoundMaxPricePerUnit: number;
+        maxFee: number;
+    };
+};

package/dist/types/provider/index.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _configuration = require("./configuration.cjs");
+Object.keys(_configuration).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _configuration[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _configuration[key];
+    }
+  });
+});
+var _response = require("./response.cjs");
+Object.keys(_response).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _response[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _response[key];
+    }
+  });
+});

package/dist/types/provider/index.d.ts

@@ -0,0 +1,2 @@
+export * from './configuration';
+export * from './response';

package/dist/types/provider/index.mjs

@@ -0,0 +1,2 @@
+export * from "./configuration.mjs";
+export * from "./response.mjs";

package/dist/types/provider/response.cjs

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "BlockWithTxHashes", {
+  enumerable: true,
+  get: function () {
+    return _spec.BlockWithTxHashes;
+  }
+});
+Object.defineProperty(exports, "ContractClassPayload", {
+  enumerable: true,
+  get: function () {
+    return _spec.ContractClassPayload;
+  }
+});
+Object.defineProperty(exports, "FeeEstimate", {
+  enumerable: true,
+  get: function () {
+    return _spec.FeeEstimate;
+  }
+});
+Object.defineProperty(exports, "TransactionReceipt", {
+  enumerable: true,
+  get: function () {
+    return _spec.TransactionReceipt;
+  }
+});
+var _spec = require("./spec.cjs");

package/dist/types/provider/response.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Common interface response
+ * Intersection (sequencer response ∩ (∪ rpc responses))
+ */
+import { CompiledSierra, LegacyContractClass, TransactionExecutionStatus, TransactionFinalityStatus, TransactionType, TransactionStatus, BlockNumber } from '../lib';
+import { BLOCK_HASH, BLOCK_NUMBER, DECLARE_TXN_RECEIPT, DEPLOY_ACCOUNT_TXN_RECEIPT, FELT, INVOKE_TXN_RECEIPT, L1_HANDLER_TXN_RECEIPT, PENDING_DECLARE_TXN_RECEIPT, PENDING_DEPLOY_ACCOUNT_TXN_RECEIPT, PENDING_INVOKE_TXN_RECEIPT, PENDING_L1_HANDLER_TXN_RECEIPT, PENDING_STATE_UPDATE, PRICE_UNIT, RESOURCE_PRICE, SIMULATION_FLAG, STATE_UPDATE, TXN_HASH, DeclaredTransaction, InvokedTransaction, ResourceBounds, SimulateTransaction, TransactionWithHash } from './spec';
+export { BlockWithTxHashes, ContractClassPayload, FeeEstimate, TransactionReceipt } from './spec';
+export type GetBlockResponse = PendingBlock | Block;
+export type PendingBlock = {
+    status: 'PENDING';
+    parent_hash: BLOCK_HASH;
+    timestamp: number;
+    sequencer_address: FELT;
+    l1_gas_price: RESOURCE_PRICE;
+    starknet_version: string;
+    transactions: TXN_HASH[];
+};
+export type Block = {
+    status: 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+    block_hash: BLOCK_HASH;
+    parent_hash: BLOCK_HASH;
+    block_number: BLOCK_NUMBER;
+    new_root: FELT;
+    timestamp: number;
+    sequencer_address: FELT;
+    l1_gas_price: RESOURCE_PRICE;
+    starknet_version: string;
+    transactions: TXN_HASH[];
+};
+export interface MessageToL1 {
+    to_address: string;
+    payload: Array<string>;
+}
+export type RevertedTransactionReceiptResponse = {
+    type?: TransactionType | any;
+    execution_status: typeof TransactionExecutionStatus.REVERTED | any;
+    finality_status: TransactionFinalityStatus | any;
+    status?: TransactionStatus;
+    actual_fee: string;
+    block_hash?: string;
+    block_number?: BlockNumber;
+    transaction_hash: string;
+    transaction_index?: number;
+    messages_sent: Array<MessageToL1>;
+    events: any[];
+    revert_reason?: string;
+};
+export type RejectedTransactionReceiptResponse = {
+    status: typeof TransactionStatus.REJECTED;
+    transaction_failure_reason: {
+        code: string;
+        error_message: string;
+    };
+};
+export type GetTxReceiptResponseWithoutHelper = SuccessfulTransactionReceiptResponse | RevertedTransactionReceiptResponse | RejectedTransactionReceiptResponse;
+export type SuccessfulTransactionReceiptResponse = InvokeTransactionReceiptResponse | DeployTransactionReceiptResponse | DeclareTransactionReceiptResponse;
+export type GetTransactionResponse = TransactionWithHash;
+export type InvokeTransactionReceiptResponse = INVOKE_TXN_RECEIPT | PENDING_INVOKE_TXN_RECEIPT;
+export type DeclareTransactionReceiptResponse = DECLARE_TXN_RECEIPT | PENDING_DECLARE_TXN_RECEIPT;
+export type DeployTransactionReceiptResponse = InvokeTransactionReceiptResponse;
+export type DeployAccountTransactionReceiptResponse = DEPLOY_ACCOUNT_TXN_RECEIPT | PENDING_DEPLOY_ACCOUNT_TXN_RECEIPT;
+export type L1HandlerTransactionReceiptResponse = L1_HANDLER_TXN_RECEIPT | PENDING_L1_HANDLER_TXN_RECEIPT;
+export interface EstimateFeeResponse {
+    gas_consumed: bigint;
+    overall_fee: bigint;
+    gas_price: bigint;
+    unit: PRICE_UNIT;
+    suggestedMaxFee: bigint;
+    resourceBounds: ResourceBounds;
+    data_gas_consumed: bigint;
+    data_gas_price: bigint;
+}
+export type EstimateFeeResponseBulk = Array<EstimateFeeResponse>;
+export type InvokeFunctionResponse = InvokedTransaction;
+export type DeclareContractResponse = DeclaredTransaction;
+export type CallContractResponse = string[];
+export type Storage = FELT;
+export type Nonce = string;
+export type { SIMULATION_FLAG };
+export type SimulationFlags = Array<SIMULATION_FLAG>;
+export type SimulatedTransaction = SimulateTransaction & {
+    suggestedMaxFee: bigint;
+    resourceBounds: ResourceBounds;
+};
+export type SimulateTransactionResponse = SimulatedTransaction[];
+export type StateUpdateResponse = StateUpdate | PendingStateUpdate;
+export type StateUpdate = STATE_UPDATE;
+export type PendingStateUpdate = PENDING_STATE_UPDATE;
+/**
+ * Standardized type
+ *
+ * Cairo0 program compressed and Cairo1 sierra_program decompressed
+ *
+ * abi Abi
+ *
+ * CompiledSierra without '.sierra_program_debug_info'
+ */
+export type ContractClassResponse = LegacyContractClass | Omit<CompiledSierra, 'sierra_program_debug_info'>;

package/dist/types/provider/response.mjs

@@ -0,0 +1 @@
+export { BlockWithTxHashes, ContractClassPayload, FeeEstimate, TransactionReceipt } from "./spec.mjs";

package/dist/types/provider/spec.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/types/provider/spec.d.ts

@@ -0,0 +1,49 @@
+import { RPCSPEC07 } from '../api';
+import * as RPC06 from '../api/rpcspec_0_6';
+import { SPEC as SPEC06 } from '../api/rpcspec_0_6';
+type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type RequiredKeysOf<T extends object> = Exclude<{
+    [K in keyof T]: T extends Record<K, T[K]> ? K : never;
+}[keyof T], undefined>;
+type ArrayElement<T> = T extends Array<infer U> ? U : never;
+type MergeProperties<T1 extends Record<any, any>, T2 extends Record<any, any>> = {
+    [K in RequiredKeysOf<T1> & RequiredKeysOf<T2>]: Merge<T1[K], T2[K]>;
+} & {
+    [K in keyof T1 & keyof T2]?: Merge<T1[K], T2[K]>;
+} & {
+    [K in Exclude<keyof T1, keyof T2>]?: T1[K];
+} & {
+    [K in Exclude<keyof T2, keyof T1>]?: T2[K];
+};
+type Merge<T1, T2> = Simplify<T1 extends Array<any> ? T2 extends Array<any> ? Array<Merge<ArrayElement<T1>, ArrayElement<T2>>> : T1 : T2 extends Array<any> ? T2 : T1 extends object ? T2 extends object ? MergeProperties<T1, T2> : T1 : T2 extends object ? T2 : T1 | T2>;
+export type BLOCK_HASH = Merge<SPEC06.BLOCK_HASH, RPCSPEC07.SPEC.BLOCK_HASH>;
+export type BLOCK_NUMBER = Merge<SPEC06.BLOCK_NUMBER, RPCSPEC07.SPEC.BLOCK_NUMBER>;
+export type FELT = Merge<SPEC06.FELT, RPCSPEC07.SPEC.FELT>;
+export type TXN_HASH = Merge<SPEC06.TXN_HASH, RPCSPEC07.SPEC.TXN_HASH>;
+export type PRICE_UNIT = Merge<SPEC06.PRICE_UNIT, RPCSPEC07.SPEC.PRICE_UNIT>;
+export type RESOURCE_PRICE = Merge<SPEC06.RESOURCE_PRICE, RPCSPEC07.SPEC.RESOURCE_PRICE>;
+export type SIMULATION_FLAG = Merge<SPEC06.SIMULATION_FLAG, RPCSPEC07.SPEC.SIMULATION_FLAG>;
+export type STATE_UPDATE = Merge<SPEC06.STATE_UPDATE, RPCSPEC07.SPEC.STATE_UPDATE>;
+export type PENDING_STATE_UPDATE = Merge<SPEC06.PENDING_STATE_UPDATE, RPCSPEC07.SPEC.PENDING_STATE_UPDATE>;
+export type INVOKE_TXN_RECEIPT = Merge<SPEC06.INVOKE_TXN_RECEIPT, RPCSPEC07.SPEC.INVOKE_TXN_RECEIPT & RPCSPEC07.BlockHashAndNumber>;
+export type DECLARE_TXN_RECEIPT = Merge<SPEC06.DECLARE_TXN_RECEIPT, RPCSPEC07.SPEC.DECLARE_TXN_RECEIPT & RPCSPEC07.BlockHashAndNumber>;
+export type DEPLOY_ACCOUNT_TXN_RECEIPT = Merge<SPEC06.DEPLOY_ACCOUNT_TXN_RECEIPT, RPCSPEC07.SPEC.DEPLOY_ACCOUNT_TXN_RECEIPT & RPCSPEC07.BlockHashAndNumber>;
+export type L1_HANDLER_TXN_RECEIPT = Merge<SPEC06.L1_HANDLER_TXN_RECEIPT, RPCSPEC07.SPEC.L1_HANDLER_TXN_RECEIPT & RPCSPEC07.BlockHashAndNumber>;
+export type PENDING_INVOKE_TXN_RECEIPT = Merge<SPEC06.PENDING_INVOKE_TXN_RECEIPT, RPCSPEC07.SPEC.INVOKE_TXN_RECEIPT>;
+export type PENDING_DECLARE_TXN_RECEIPT = Merge<SPEC06.PENDING_DECLARE_TXN_RECEIPT, RPCSPEC07.SPEC.DECLARE_TXN_RECEIPT>;
+export type PENDING_DEPLOY_ACCOUNT_TXN_RECEIPT = Merge<SPEC06.PENDING_DEPLOY_ACCOUNT_TXN_RECEIPT, RPCSPEC07.SPEC.DEPLOY_ACCOUNT_TXN_RECEIPT>;
+export type PENDING_L1_HANDLER_TXN_RECEIPT = Merge<SPEC06.PENDING_L1_HANDLER_TXN_RECEIPT, RPCSPEC07.SPEC.L1_HANDLER_TXN_RECEIPT>;
+export type BlockWithTxHashes = Merge<RPC06.BlockWithTxHashes, RPCSPEC07.BlockWithTxHashes>;
+export type ContractClassPayload = Merge<RPC06.ContractClass, RPCSPEC07.ContractClass>;
+export type DeclaredTransaction = Merge<RPC06.DeclaredTransaction, RPCSPEC07.DeclaredTransaction>;
+export type FeeEstimate = Merge<SPEC06.FEE_ESTIMATE, RPCSPEC07.SPEC.FEE_ESTIMATE>;
+export type InvokedTransaction = Merge<RPC06.InvokedTransaction, RPCSPEC07.InvokedTransaction>;
+export type PendingReceipt = Merge<RPC06.PendingReceipt, RPCSPEC07.PendingReceipt>;
+export type Receipt = Merge<RPC06.Receipt, RPCSPEC07.Receipt>;
+export type ResourceBounds = Merge<RPC06.ResourceBounds, RPCSPEC07.ResourceBounds>;
+export type SimulateTransaction = Merge<RPC06.SimulateTransaction, RPCSPEC07.SimulateTransaction>;
+export type TransactionReceipt = Merge<RPC06.TransactionReceipt, RPCSPEC07.TransactionReceipt>;
+export type TransactionWithHash = Merge<RPC06.TransactionWithHash, RPCSPEC07.TransactionWithHash>;
+export {};

package/dist/types/signer.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/types/signer.d.ts

@@ -0,0 +1,49 @@
+import { StarknetChainId } from '../constants';
+import { ETransactionVersion, ETransactionVersion2, ETransactionVersion3 } from './api';
+import { BigNumberish, CairoVersion, DeployAccountContractPayload, InvocationsDetails, V3TransactionDetails } from './lib';
+export type InvocationsSignerDetails = (V2InvocationsSignerDetails | V3InvocationsSignerDetails) & {
+    version: `${ETransactionVersion}`;
+    skipValidate?: boolean;
+};
+export type V2InvocationsSignerDetails = {
+    walletAddress: string;
+    cairoVersion: CairoVersion;
+    chainId: StarknetChainId;
+    nonce: BigNumberish;
+    maxFee: BigNumberish;
+    version: `${ETransactionVersion2}`;
+};
+export type V3InvocationsSignerDetails = V3TransactionDetails & {
+    walletAddress: string;
+    cairoVersion: CairoVersion;
+    chainId: StarknetChainId;
+    version: `${ETransactionVersion3}`;
+};
+export type DeclareSignerDetails = (V3DeclareSignerDetails | V2DeclareSignerDetails) & {
+    version: `${ETransactionVersion}`;
+};
+export type V2DeclareSignerDetails = Required<InvocationsDetails> & {
+    classHash: string;
+    compiledClassHash?: string;
+    senderAddress: string;
+    chainId: StarknetChainId;
+    version: `${ETransactionVersion2}`;
+};
+export type V3DeclareSignerDetails = V3TransactionDetails & {
+    classHash: string;
+    compiledClassHash: string;
+    senderAddress: string;
+    chainId: StarknetChainId;
+    version: `${ETransactionVersion3}`;
+};
+export type DeployAccountSignerDetails = V2DeployAccountSignerDetails | V3DeployAccountSignerDetails;
+export type V2DeployAccountSignerDetails = Required<DeployAccountContractPayload> & Required<InvocationsDetails> & {
+    contractAddress: BigNumberish;
+    chainId: StarknetChainId;
+    version: `${ETransactionVersion2}`;
+};
+export type V3DeployAccountSignerDetails = Required<DeployAccountContractPayload> & V3TransactionDetails & {
+    contractAddress: BigNumberish;
+    chainId: StarknetChainId;
+    version: `${ETransactionVersion3}`;
+};

package/dist/types/transactionReceipt.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/types/transactionReceipt.d.ts

@@ -0,0 +1,23 @@
+import { RejectedTransactionReceiptResponse, RevertedTransactionReceiptResponse, SuccessfulTransactionReceiptResponse } from './provider';
+export type TransactionStatusReceiptSets = {
+    success: SuccessfulTransactionReceiptResponse;
+    reverted: RevertedTransactionReceiptResponse;
+    rejected: RejectedTransactionReceiptResponse;
+    error: Error;
+};
+export type TransactionReceiptStatus = keyof TransactionStatusReceiptSets;
+export type TransactionReceiptValue = TransactionStatusReceiptSets[TransactionReceiptStatus];
+export type TransactionReceiptCallbacksDefined = {
+    [key in TransactionReceiptStatus]: (response: TransactionStatusReceiptSets[key]) => void;
+};
+export type TransactionReceiptCallbacksDefault = Partial<TransactionReceiptCallbacksDefined> & {
+    _: () => void;
+};
+export type TransactionReceiptCallbacks = TransactionReceiptCallbacksDefined | TransactionReceiptCallbacksDefault;
+export type TransactionReceiptUtilityInterface = {
+    readonly statusReceipt: TransactionReceiptStatus;
+    readonly value: TransactionReceiptValue;
+    match(callbacks: TransactionReceiptCallbacks): void;
+} & {
+    [key in `is${Capitalize<TransactionReceiptStatus>}`]: () => boolean;
+};

package/dist/types/typedData.cjs

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "TypedDataRevision", {
+  enumerable: true,
+  get: function () {
+    return _starknetTypes.TypedDataRevision;
+  }
+});
+var _starknetTypes = require("starknet-types-07");

package/dist/types/typedData.d.ts

@@ -0,0 +1 @@
+export { TypedDataRevision, type StarknetEnumType, type StarknetMerkleType, type StarknetType, type StarknetDomain, type TypedData, } from 'starknet-types-07';

package/dist/types/typedData.mjs

@@ -0,0 +1,3 @@
+export {
+  TypedDataRevision
+} from "starknet-types-07";