starknet 10.2.0 → 10.3.1

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 import * as RPCSPEC0103 from '@starknet-io/starknet-types-0103';
-import { PAYMASTER_API, CONTRACT, EDataAvailabilityMode as EDataAvailabilityMode$1, ETransactionType, SUBSCRIPTION_BLOCK_ID, TypedData, CONTRACT_STORAGE_KEYS, StorageProof, CASM_COMPILED_CONTRACT_CLASS, OutsideExecutionTypedData, ETransactionVersion3 as ETransactionVersion3$1, IsType, TransactionReceipt as TransactionReceipt$1, IsSucceeded, IsReverted, PRE_CONFIRMED_BLOCK_WITH_TX_HASHES, BLOCK_WITH_TX_HASHES, TransactionHash, BlockHash, FAILED_TO_RECEIVE_TXN, NO_TRACE_AVAILABLE, CONTRACT_NOT_FOUND, ENTRYPOINT_NOT_FOUND, BLOCK_NOT_FOUND, INVALID_TXN_INDEX, CLASS_HASH_NOT_FOUND, TXN_HASH_NOT_FOUND, PAGE_SIZE_TOO_BIG, NO_BLOCKS, INVALID_CONTINUATION_TOKEN, TOO_MANY_KEYS_IN_FILTER, CONTRACT_ERROR, TRANSACTION_EXECUTION_ERROR, STORAGE_PROOF_NOT_SUPPORTED, CLASS_ALREADY_DECLARED, INVALID_TRANSACTION_NONCE, INSUFFICIENT_RESOURCES_FOR_VALIDATE, INSUFFICIENT_ACCOUNT_BALANCE, VALIDATION_FAILURE, COMPILATION_FAILED, CONTRACT_CLASS_SIZE_IS_TOO_LARGE, NON_ACCOUNT, DUPLICATE_TX, COMPILED_CLASS_HASH_MISMATCH, UNSUPPORTED_TX_VERSION, UNSUPPORTED_CONTRACT_CLASS_VERSION, UNEXPECTED_ERROR, REPLACEMENT_TRANSACTION_UNDERPRICED, FEE_BELOW_MINIMUM, INVALID_SUBSCRIPTION_ID, TOO_MANY_ADDRESSES_IN_FILTER, TOO_MANY_BLOCKS_BACK, COMPILATION_ERROR, ETransactionVersion as ETransactionVersion$1, SUBSCRIPTION_ID, TXN_FINALITY_STATUS, STATUS_ACCEPTED_ON_L1, TXN_STATUS_WITHOUT_L1, StarknetEventsEvent, TransactionsStatusEvent, NewTransactionReceiptsEvent, NewTransactionEvent, NewHeadsEvent, STORAGE_RESULT, StarknetWindowObject, AccountChangeEventHandler, NetworkChangeEventHandler, WatchAssetParameters, AddStarknetChainParameters, Signature as Signature$1, EDAMode as EDAMode$1, StarknetType, StarknetMerkleType, TypedDataRevision, OutsideCallV1, OutsideCallV2, EmittedEvent as EmittedEvent$1, Event as Event$2, Address, Permission, ChainId, AccountDeploymentData, AddInvokeTransactionParameters, AddInvokeTransactionResult, AddDeclareTransactionParameters, AddDeclareTransactionResult, SpecVersion } from '@starknet-io/starknet-types-0103';
+import { PAYMASTER_API, CONTRACT, EDataAvailabilityMode as EDataAvailabilityMode$1, ETransactionType, SUBSCRIPTION_BLOCK_ID, TypedData, CONTRACT_STORAGE_KEYS, StorageProof, CASM_COMPILED_CONTRACT_CLASS, OutsideExecutionTypedData, ETransactionVersion3 as ETransactionVersion3$1, IsType, TransactionReceipt as TransactionReceipt$1, IsSucceeded, IsReverted, PRE_CONFIRMED_BLOCK_WITH_TX_HASHES, BLOCK_WITH_TX_HASHES, TransactionHash, BlockHash, FAILED_TO_RECEIVE_TXN, NO_TRACE_AVAILABLE, CONTRACT_NOT_FOUND, ENTRYPOINT_NOT_FOUND, BLOCK_NOT_FOUND, INVALID_TXN_INDEX, CLASS_HASH_NOT_FOUND, TXN_HASH_NOT_FOUND, PAGE_SIZE_TOO_BIG, NO_BLOCKS, INVALID_CONTINUATION_TOKEN, TOO_MANY_KEYS_IN_FILTER, CONTRACT_ERROR, TRANSACTION_EXECUTION_ERROR, STORAGE_PROOF_NOT_SUPPORTED, CLASS_ALREADY_DECLARED, INVALID_TRANSACTION_NONCE, INSUFFICIENT_RESOURCES_FOR_VALIDATE, INSUFFICIENT_ACCOUNT_BALANCE, VALIDATION_FAILURE, COMPILATION_FAILED, CONTRACT_CLASS_SIZE_IS_TOO_LARGE, NON_ACCOUNT, DUPLICATE_TX, COMPILED_CLASS_HASH_MISMATCH, UNSUPPORTED_TX_VERSION, UNSUPPORTED_CONTRACT_CLASS_VERSION, UNEXPECTED_ERROR, REPLACEMENT_TRANSACTION_UNDERPRICED, FEE_BELOW_MINIMUM, INVALID_SUBSCRIPTION_ID, TOO_MANY_ADDRESSES_IN_FILTER, TOO_MANY_BLOCKS_BACK, COMPILATION_ERROR, ETransactionVersion as ETransactionVersion$1, SUBSCRIPTION_ID, TXN_FINALITY_STATUS, STATUS_ACCEPTED_ON_L1, TXN_STATUS_WITHOUT_L1, StarknetEventsEvent, TransactionsStatusEvent, NewTransactionReceiptsEvent, NewTransactionEvent, NewHeadsEvent, STORAGE_RESULT, INVOKE_TXN_V3, StarknetWindowObject, AccountChangeEventHandler, NetworkChangeEventHandler, WatchAssetParameters, AddStarknetChainParameters, Signature as Signature$1, EDAMode as EDAMode$1, StarknetType, StarknetMerkleType, TypedDataRevision, OutsideCallV1, OutsideCallV2, EmittedEvent as EmittedEvent$1, Event as Event$2, Address, Permission, ChainId, AccountDeploymentData, AddInvokeTransactionParameters, AddInvokeTransactionResult, AddDeclareTransactionParameters, AddDeclareTransactionResult, SpecVersion } from '@starknet-io/starknet-types-0103';
 export { StarknetDomain, StarknetEnumType, StarknetMerkleType, StarknetType, TypedData, TypedDataRevision } from '@starknet-io/starknet-types-0103';
-import * as RPC from '@starknet-io/starknet-types-0101';
+import * as RPC$1 from '@starknet-io/starknet-types-0101';
 import { WatchAssetParameters as WatchAssetParameters$1, AddStarknetChainParameters as AddStarknetChainParameters$1, Signature as Signature$2, Address as Address$1, Permission as Permission$1, ChainId as ChainId$1, AccountDeploymentData as AccountDeploymentData$1, AddInvokeTransactionParameters as AddInvokeTransactionParameters$1, AddInvokeTransactionResult as AddInvokeTransactionResult$1, AddDeclareTransactionParameters as AddDeclareTransactionParameters$1, AddDeclareTransactionResult as AddDeclareTransactionResult$1, TypedData as TypedData$1, SpecVersion as SpecVersion$1 } from '@starknet-io/starknet-types-0101';
 import * as weierstrass from '@noble/curves/abstract/weierstrass';
 import { RecoveredSignatureType } from '@noble/curves/abstract/weierstrass';
-import * as RPCSPEC09 from '@starknet-io/starknet-types-09';
+import * as RPC from '@starknet-io/starknet-types-09';
 import { Abi as Abi$1, TypedContract } from 'abi-wan-kanabi';
 import { WalletWithStarknetFeatures, StandardEventsChangeProperties } from '@starknet-io/get-starknet-wallet-standard/features';
 import * as poseidon from '@noble/curves/abstract/poseidon';
@@ -54,9 +54,8 @@ declare namespace jsonrpc {
 
 declare const index$4_PAYMASTER_API: typeof PAYMASTER_API;
 declare const index$4_RPCSPEC0103: typeof RPCSPEC0103;
-declare const index$4_RPCSPEC09: typeof RPCSPEC09;
 declare namespace index$4 {
-  export { jsonrpc as JRPC, index$4_PAYMASTER_API as PAYMASTER_API, index$4_RPCSPEC0103 as RPCSPEC0103, index$4_RPCSPEC09 as RPCSPEC09 };
+  export { jsonrpc as JRPC, index$4_PAYMASTER_API as PAYMASTER_API, index$4_RPCSPEC0103 as RPCSPEC0103, RPC as RPCSPEC09 };
 }
 
 type CairoEnumRaw = Record<string, any>;
@@ -466,7 +465,7 @@ type MergeProperties<T1 extends Record<any, any>, T2 extends Record<any, any>> =
  currently supported RPC specifications
  */
 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>;
-type ETransactionVersion = RPCSPEC09.ETransactionVersion;
+type ETransactionVersion = RPC.ETransactionVersion;
 declare const ETransactionVersion: {
     readonly V0: "0x0";
     readonly V1: "0x1";
@@ -477,7 +476,7 @@ declare const ETransactionVersion: {
     readonly F2: "0x100000000000000000000000000000002";
     readonly F3: "0x100000000000000000000000000000003";
 };
-type ETransactionVersion2 = RPCSPEC09.ETransactionVersion2;
+type ETransactionVersion2 = RPC.ETransactionVersion2;
 declare const ETransactionVersion2: {
     readonly V0: "0x0";
     readonly V1: "0x1";
@@ -486,25 +485,25 @@ declare const ETransactionVersion2: {
     readonly F1: "0x100000000000000000000000000000001";
     readonly F2: "0x100000000000000000000000000000002";
 };
-type ETransactionVersion3 = RPCSPEC09.ETransactionVersion3;
+type ETransactionVersion3 = RPC.ETransactionVersion3;
 declare const ETransactionVersion3: {
     readonly V3: "0x3";
     readonly F3: "0x100000000000000000000000000000003";
 };
-type BLOCK_HASH = Merge<RPCSPEC0103.BLOCK_HASH, RPCSPEC09.BLOCK_HASH>;
-type BLOCK_NUMBER = Merge<RPCSPEC0103.BLOCK_NUMBER, RPCSPEC09.BLOCK_NUMBER>;
-type FELT = Merge<RPCSPEC0103.FELT, RPCSPEC09.FELT>;
-type TXN_HASH = Merge<RPCSPEC0103.TXN_HASH, RPCSPEC09.TXN_HASH>;
-type PRICE_UNIT = Merge<RPCSPEC0103.PRICE_UNIT, RPCSPEC09.PRICE_UNIT>;
-type RESOURCE_PRICE = Merge<RPCSPEC0103.RESOURCE_PRICE, RPCSPEC09.RESOURCE_PRICE>;
-type SIMULATION_FLAG = Merge<RPCSPEC0103.SIMULATION_FLAG, RPCSPEC09.SIMULATION_FLAG>;
-type STATE_UPDATE = Merge<RPCSPEC0103.STATE_UPDATE, RPCSPEC09.STATE_UPDATE>;
-type PRE_CONFIRMED_STATE_UPDATE = Merge<RPCSPEC0103.PRE_CONFIRMED_STATE_UPDATE, RPCSPEC09.PRE_CONFIRMED_STATE_UPDATE>;
-type BlockWithTxHashes = Merge<RPCSPEC0103.BlockWithTxHashes, RPCSPEC09.BlockWithTxHashes>;
-type ContractClassPayload = Merge<RPCSPEC0103.ContractClass, RPCSPEC09.ContractClass>;
-type DeclaredTransaction = Merge<RPCSPEC0103.DeclaredTransaction, RPCSPEC09.DeclaredTransaction>;
-type InvokedTransaction = Merge<RPCSPEC0103.InvokedTransaction, RPCSPEC09.InvokedTransaction>;
-type DeployedAccountTransaction = Merge<RPCSPEC0103.DeployedAccountTransaction, RPCSPEC09.DeployedAccountTransaction>;
+type BLOCK_HASH = Merge<RPCSPEC0103.BLOCK_HASH, RPC.BLOCK_HASH>;
+type BLOCK_NUMBER = Merge<RPCSPEC0103.BLOCK_NUMBER, RPC.BLOCK_NUMBER>;
+type FELT = Merge<RPCSPEC0103.FELT, RPC.FELT>;
+type TXN_HASH = Merge<RPCSPEC0103.TXN_HASH, RPC.TXN_HASH>;
+type PRICE_UNIT = Merge<RPCSPEC0103.PRICE_UNIT, RPC.PRICE_UNIT>;
+type RESOURCE_PRICE = Merge<RPCSPEC0103.RESOURCE_PRICE, RPC.RESOURCE_PRICE>;
+type SIMULATION_FLAG = Merge<RPCSPEC0103.SIMULATION_FLAG, RPC.SIMULATION_FLAG>;
+type STATE_UPDATE = Merge<RPCSPEC0103.STATE_UPDATE, RPC.STATE_UPDATE>;
+type PRE_CONFIRMED_STATE_UPDATE = Merge<RPCSPEC0103.PRE_CONFIRMED_STATE_UPDATE, RPC.PRE_CONFIRMED_STATE_UPDATE>;
+type BlockWithTxHashes = Merge<RPCSPEC0103.BlockWithTxHashes, RPC.BlockWithTxHashes>;
+type ContractClassPayload = Merge<RPCSPEC0103.ContractClass, RPC.ContractClass>;
+type DeclaredTransaction = Merge<RPCSPEC0103.DeclaredTransaction, RPC.DeclaredTransaction>;
+type InvokedTransaction = Merge<RPCSPEC0103.InvokedTransaction, RPC.InvokedTransaction>;
+type DeployedAccountTransaction = Merge<RPCSPEC0103.DeployedAccountTransaction, RPC.DeployedAccountTransaction>;
 type L1_HANDLER_TXN = RPCSPEC0103.L1_HANDLER_TXN;
 type EDataAvailabilityMode = RPCSPEC0103.EDataAvailabilityMode;
 declare const EDataAvailabilityMode: {
@@ -516,18 +515,18 @@ declare const EDAMode: {
     readonly L1: 0;
     readonly L2: 1;
 };
-type EmittedEvent = Merge<RPCSPEC0103.EmittedEvent, RPCSPEC09.EmittedEvent>;
-type Event$1 = Merge<RPCSPEC0103.Event, RPCSPEC09.Event>;
-type Receipt = Merge<RPCSPEC0103.TransactionReceiptProductionBlock, RPCSPEC09.TransactionReceiptProductionBlock>;
+type EmittedEvent = Merge<RPCSPEC0103.EmittedEvent, RPC.EmittedEvent>;
+type Event$1 = Merge<RPCSPEC0103.Event, RPC.Event>;
+type Receipt = Merge<RPCSPEC0103.TransactionReceiptProductionBlock, RPC.TransactionReceiptProductionBlock>;
 /**
  * original response from estimate fee without parsing
  */
-type FeeEstimate = Merge<RPCSPEC0103.FEE_ESTIMATE, RPCSPEC09.FEE_ESTIMATE>;
+type FeeEstimate = Merge<RPCSPEC0103.FEE_ESTIMATE, RPC.FEE_ESTIMATE>;
 type ApiEstimateFeeResponse = FeeEstimate[];
 declare function isRPC08Plus_ResourceBounds(entry: ResourceBounds): entry is RPCSPEC0103.ResourceBounds;
 declare function isRPC08Plus_ResourceBoundsBN(entry: ResourceBoundsBN): entry is ResourceBoundsBN;
-type ResourceBounds = Merge<RPCSPEC0103.ResourceBounds, RPCSPEC09.ResourceBounds>;
-type EventFilter = RPCSPEC09.EventFilter;
+type ResourceBounds = Merge<RPCSPEC0103.ResourceBounds, RPC.ResourceBounds>;
+type EventFilter = RPC.EventFilter;
 /**
  * Represents percentage overhead for each resource bound
  * numerical 50 means 50% overhead
@@ -545,8 +544,8 @@ type ResourceBoundsBN = {
         [P in keyof ResourceBounds[K]]: bigint;
     } : number;
 };
-type SimulateTransaction = SimpleOneOf<RPCSPEC09.SimulateTransaction, RPCSPEC0103.SimulateTransaction>;
-type SimulateTransactionResponse = RPCSPEC09.SimulateTransactionResponse | RPCSPEC0103.SimulateTransactionResponse;
+type SimulateTransaction = SimpleOneOf<RPC.SimulateTransaction, RPCSPEC0103.SimulateTransaction>;
+type SimulateTransactionResponse = RPC.SimulateTransactionResponse | RPCSPEC0103.SimulateTransactionResponse;
 type INITIAL_READS = RPCSPEC0103.INITIAL_READS;
 /** Flags to request additional fields in transaction responses (RPC 0.10.1+) */
 type ETxnResponseFlag = RPCSPEC0103.ETxnResponseFlag;
@@ -567,13 +566,13 @@ declare const ESubscriptionTag: {
 type BlockTransactionTrace = RPCSPEC0103.BlockTransactionTrace;
 /** Block transaction traces with optional initial storage reads (RPC 0.10.1+) */
 type BlockTransactionsTracesWithInitialReads = RPCSPEC0103.BlockTransactionsTracesWithInitialReads;
-type TransactionTrace = SimpleOneOf<RPCSPEC09.TRANSACTION_TRACE, RPCSPEC0103.TRANSACTION_TRACE>;
-type TransactionWithHash = Merge<RPCSPEC0103.TransactionWithHash, RPCSPEC09.TransactionWithHash>;
-type TransactionReceipt = Merge<RPCSPEC0103.TransactionReceipt, RPCSPEC09.TransactionReceipt>;
+type TransactionTrace = SimpleOneOf<RPC.TRANSACTION_TRACE, RPCSPEC0103.TRANSACTION_TRACE>;
+type TransactionWithHash = Merge<RPCSPEC0103.TransactionWithHash, RPC.TransactionWithHash>;
+type TransactionReceipt = Merge<RPCSPEC0103.TransactionReceipt, RPC.TransactionReceipt>;
 type Methods = RPCSPEC0103.Methods;
-type TXN_STATUS = Merge<RPCSPEC0103.TXN_STATUS, RPCSPEC09.TXN_STATUS>;
-type TXN_EXECUTION_STATUS = Merge<RPCSPEC0103.TXN_EXECUTION_STATUS, RPCSPEC09.TXN_EXECUTION_STATUS>;
-type TransactionStatus = Merge<RPCSPEC0103.TransactionStatus, RPCSPEC09.TransactionStatus>;
+type TXN_STATUS = Merge<RPCSPEC0103.TXN_STATUS, RPC.TXN_STATUS>;
+type TXN_EXECUTION_STATUS = Merge<RPCSPEC0103.TXN_EXECUTION_STATUS, RPC.TXN_EXECUTION_STATUS>;
+type TransactionStatus = Merge<RPCSPEC0103.TransactionStatus, RPC.TransactionStatus>;
 type ETransactionStatus = RPCSPEC0103.ETransactionStatus;
 declare const ETransactionStatus: {
     readonly RECEIVED: "RECEIVED";
@@ -587,9 +586,9 @@ declare const ETransactionExecutionStatus: {
     readonly SUCCEEDED: "SUCCEEDED";
     readonly REVERTED: "REVERTED";
 };
-type FEE_ESTIMATE = Merge<RPCSPEC0103.FEE_ESTIMATE, RPCSPEC09.FEE_ESTIMATE>;
-type EVENTS_CHUNK = Merge<RPCSPEC0103.EVENTS_CHUNK, RPCSPEC09.EVENTS_CHUNK>;
-type TransactionType = RPCSPEC09.ETransactionType;
+type FEE_ESTIMATE = Merge<RPCSPEC0103.FEE_ESTIMATE, RPC.FEE_ESTIMATE>;
+type EVENTS_CHUNK = Merge<RPCSPEC0103.EVENTS_CHUNK, RPC.EVENTS_CHUNK>;
+type TransactionType = RPC.ETransactionType;
 declare const TransactionType: {
     readonly DECLARE: "DECLARE";
     readonly DEPLOY: "DEPLOY";
@@ -597,24 +596,24 @@ declare const TransactionType: {
     readonly INVOKE: "INVOKE";
     readonly L1_HANDLER: "L1_HANDLER";
 };
-type BlockStatus = RPCSPEC09.EBlockStatus;
+type BlockStatus = RPC.EBlockStatus;
 declare const BlockStatus: {
     readonly PRE_CONFIRMED: "PRE_CONFIRMED";
     readonly ACCEPTED_ON_L2: "ACCEPTED_ON_L2";
     readonly ACCEPTED_ON_L1: "ACCEPTED_ON_L1";
 };
-type TransactionFinalityStatus = RPCSPEC09.ETransactionFinalityStatus;
+type TransactionFinalityStatus = RPC.ETransactionFinalityStatus;
 declare const TransactionFinalityStatus: {
     readonly PRE_CONFIRMED: "PRE_CONFIRMED";
     readonly ACCEPTED_ON_L2: "ACCEPTED_ON_L2";
     readonly ACCEPTED_ON_L1: "ACCEPTED_ON_L1";
 };
-type TransactionExecutionStatus = RPCSPEC09.ETransactionExecutionStatus;
+type TransactionExecutionStatus = RPC.ETransactionExecutionStatus;
 declare const TransactionExecutionStatus: {
     readonly SUCCEEDED: "SUCCEEDED";
     readonly REVERTED: "REVERTED";
 };
-type BlockTag = RPCSPEC09.EBlockTag;
+type BlockTag = RPC.EBlockTag;
 declare const BlockTag: {
     readonly LATEST: "latest";
     readonly PRE_CONFIRMED: "pre_confirmed";
@@ -1360,7 +1359,7 @@ declare abstract class ProviderInterface {
      * @param txHash - transaction hash
      * @returns Transaction trace
      */
-    abstract getTransactionTrace(txHash: BigNumberish): Promise<RPCSPEC0103.TRANSACTION_TRACE | RPCSPEC09.TRANSACTION_TRACE>;
+    abstract getTransactionTrace(txHash: BigNumberish): Promise<RPCSPEC0103.TRANSACTION_TRACE | RPC.TRANSACTION_TRACE>;
     /**
      * Get the status of a transaction
      * @param transactionHash - transaction hash
@@ -1403,7 +1402,7 @@ declare abstract class ProviderInterface {
      * @param blockIdentifier - block identifier
      * @returns Fee estimate
      */
-    abstract estimateMessageFee(message: RPCSPEC09.L1Message, blockIdentifier?: BlockIdentifier): Promise<RPCSPEC0103.FEE_ESTIMATE | RPCSPEC09.MESSAGE_FEE_ESTIMATE>;
+    abstract estimateMessageFee(message: RPC.L1Message, blockIdentifier?: BlockIdentifier): Promise<RPCSPEC0103.FEE_ESTIMATE | RPC.MESSAGE_FEE_ESTIMATE>;
     /**
      * Get node synchronization status
      * @returns Sync status or false if not syncing
@@ -1414,7 +1413,7 @@ declare abstract class ProviderInterface {
      * @param eventFilter - event filter
      * @returns Events and pagination info
      */
-    abstract getEvents(eventFilter: RPCSPEC0103.EventFilter | RPCSPEC09.EventFilter): Promise<RPCSPEC0103.EVENTS_CHUNK | RPCSPEC09.EVENTS_CHUNK>;
+    abstract getEvents(eventFilter: RPCSPEC0103.EventFilter | RPC.EventFilter): Promise<RPCSPEC0103.EVENTS_CHUNK | RPC.EVENTS_CHUNK>;
     /**
      * Verify in Starknet a signature of a TypedData object or of a given hash.
      * @param {BigNumberish | TypedData} message TypedData object to be verified, or message hash to be verified.
@@ -1456,7 +1455,7 @@ declare abstract class ProviderInterface {
      * @param transactionHash - L1 transaction hash
      * @returns L1 message status
      */
-    abstract getL1MessagesStatus(transactionHash: BigNumberish): Promise<RPCSPEC0103.L1L2MessagesStatus | RPCSPEC09.L1L2MessagesStatus>;
+    abstract getL1MessagesStatus(transactionHash: BigNumberish): Promise<RPCSPEC0103.L1L2MessagesStatus | RPC.L1L2MessagesStatus>;
     /**
      * Get Merkle paths in state tries
      * @param classHashes - class hashes
@@ -4497,7 +4496,7 @@ declare class RpcChannel$2 {
     setChainId(chainId: _StarknetChainId): void;
     fetch(method: string, params?: object, id?: string | number): Promise<Response>;
     protected errorHandler(method: string, params: any, rpcError?: Error$1, otherError?: any): void;
-    protected fetchEndpoint<T extends keyof RPCSPEC09.Methods>(method: T, params?: RPCSPEC09.Methods[T]['params']): Promise<RPCSPEC09.Methods[T]['result']>;
+    protected fetchEndpoint<T extends keyof RPC.Methods>(method: T, params?: RPC.Methods[T]['params']): Promise<RPC.Methods[T]['result']>;
     getChainId(): Promise<"0x534e5f4d41494e" | "0x534e5f5345504f4c4941">;
     /**
      * fetch rpc node specVersion
@@ -4512,10 +4511,10 @@ declare class RpcChannel$2 {
     /**
      * Given an l1 tx hash, returns the associated l1_handler tx hashes and statuses for all L1 -> L2 messages sent by the l1 transaction, ordered by the l1 tx sending order
      */
-    getMessagesStatus(txHash: BigNumberish): Promise<RPCSPEC09.L1L2MessagesStatus>;
-    getStorageProof(classHashes?: BigNumberish[], contractAddresses?: BigNumberish[], contractsStorageKeys?: RPCSPEC09.CONTRACT_STORAGE_KEYS[], // TODO: allow BigNUmberish[] and fix formatting before request
-    blockIdentifier?: BlockIdentifier): Promise<RPCSPEC09.StorageProof>;
-    getCompiledCasm(classHash: BigNumberish): Promise<RPCSPEC09.CASM_COMPILED_CONTRACT_CLASS>;
+    getMessagesStatus(txHash: BigNumberish): Promise<RPC.L1L2MessagesStatus>;
+    getStorageProof(classHashes?: BigNumberish[], contractAddresses?: BigNumberish[], contractsStorageKeys?: RPC.CONTRACT_STORAGE_KEYS[], // TODO: allow BigNUmberish[] and fix formatting before request
+    blockIdentifier?: BlockIdentifier): Promise<RPC.StorageProof>;
+    getCompiledCasm(classHash: BigNumberish): Promise<RPC.CASM_COMPILED_CONTRACT_CLASS>;
     getNonceForAddress(contractAddress: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<string>;
     /**
      * Helper method to get the starknet version from the block, default latest block
@@ -4525,7 +4524,7 @@ declare class RpcChannel$2 {
     /**
      * Get the most recent accepted block hash and number
      */
-    getBlockLatestAccepted(): Promise<RPCSPEC09.BlockHashAndNumber>;
+    getBlockLatestAccepted(): Promise<RPC.BlockHashAndNumber>;
     /**
      * Get the most recent accepted block number
      * redundant use getBlockLatestAccepted();
@@ -4533,42 +4532,42 @@ declare class RpcChannel$2 {
      */
     getBlockNumber(): Promise<number>;
     getBlockWithTxHashes(blockIdentifier?: BlockIdentifier): Promise<({
-        status: RPCSPEC09.BLOCK_STATUS;
-    } & RPCSPEC09.BLOCK_HEADER & RPCSPEC09.BLOCK_BODY_WITH_TX_HASHES & {}) | (RPCSPEC09.BLOCK_BODY_WITH_TX_HASHES & RPCSPEC09.PRE_CONFIRMED_BLOCK_HEADER & {
+        status: RPC.BLOCK_STATUS;
+    } & RPC.BLOCK_HEADER & RPC.BLOCK_BODY_WITH_TX_HASHES & {}) | (RPC.BLOCK_BODY_WITH_TX_HASHES & RPC.PRE_CONFIRMED_BLOCK_HEADER & {
         block_hash?: undefined;
         new_root?: undefined;
         status?: undefined;
         parent_hash?: undefined;
     })>;
     getBlockWithTxs(blockIdentifier?: BlockIdentifier): Promise<({
-        status: RPCSPEC09.BLOCK_STATUS;
-    } & RPCSPEC09.BLOCK_HEADER & RPCSPEC09.BLOCK_BODY_WITH_TXS & {}) | (RPCSPEC09.BLOCK_BODY_WITH_TXS & RPCSPEC09.PRE_CONFIRMED_BLOCK_HEADER & {
+        status: RPC.BLOCK_STATUS;
+    } & RPC.BLOCK_HEADER & RPC.BLOCK_BODY_WITH_TXS & {}) | (RPC.BLOCK_BODY_WITH_TXS & RPC.PRE_CONFIRMED_BLOCK_HEADER & {
         block_hash?: undefined;
         new_root?: undefined;
         status?: undefined;
         parent_hash?: undefined;
     })>;
     getBlockWithReceipts(blockIdentifier?: BlockIdentifier): Promise<({
-        status: RPCSPEC09.BLOCK_STATUS;
-    } & RPCSPEC09.BLOCK_HEADER & RPCSPEC09.BLOCK_BODY_WITH_RECEIPTS & {}) | (RPCSPEC09.BLOCK_BODY_WITH_RECEIPTS & RPCSPEC09.PRE_CONFIRMED_BLOCK_HEADER & {
+        status: RPC.BLOCK_STATUS;
+    } & RPC.BLOCK_HEADER & RPC.BLOCK_BODY_WITH_RECEIPTS & {}) | (RPC.BLOCK_BODY_WITH_RECEIPTS & RPC.PRE_CONFIRMED_BLOCK_HEADER & {
         block_hash?: undefined;
         new_root?: undefined;
         status?: undefined;
         parent_hash?: undefined;
     })>;
-    getBlockStateUpdate(blockIdentifier?: BlockIdentifier): Promise<(RPCSPEC09.STATE_UPDATE & {}) | (RPCSPEC09.PRE_CONFIRMED_STATE_UPDATE & {
+    getBlockStateUpdate(blockIdentifier?: BlockIdentifier): Promise<(RPC.STATE_UPDATE & {}) | (RPC.PRE_CONFIRMED_STATE_UPDATE & {
         new_root?: undefined;
     })>;
-    getBlockTransactionsTraces(blockIdentifier?: BlockIdentifier): Promise<RPCSPEC09.BlockTransactionsTraces>;
+    getBlockTransactionsTraces(blockIdentifier?: BlockIdentifier): Promise<RPC.BlockTransactionsTraces>;
     getBlockTransactionCount(blockIdentifier?: BlockIdentifier): Promise<number>;
-    getTransactionByHash(txHash: BigNumberish): Promise<RPCSPEC09.TXN_WITH_HASH>;
-    getTransactionByBlockIdAndIndex(blockIdentifier: BlockIdentifier, index: number): Promise<RPCSPEC09.TXN_WITH_HASH>;
-    getTransactionReceipt(txHash: BigNumberish): Promise<RPCSPEC09.TXN_RECEIPT_WITH_BLOCK_INFO>;
-    getTransactionTrace(txHash: BigNumberish): Promise<RPCSPEC09.TRANSACTION_TRACE>;
+    getTransactionByHash(txHash: BigNumberish): Promise<RPC.TXN_WITH_HASH>;
+    getTransactionByBlockIdAndIndex(blockIdentifier: BlockIdentifier, index: number): Promise<RPC.TXN_WITH_HASH>;
+    getTransactionReceipt(txHash: BigNumberish): Promise<RPC.TXN_RECEIPT_WITH_BLOCK_INFO>;
+    getTransactionTrace(txHash: BigNumberish): Promise<RPC.TRANSACTION_TRACE>;
     /**
      * Get the status of a transaction
      */
-    getTransactionStatus(transactionHash: BigNumberish): Promise<RPCSPEC09.TXN_STATUS_RESULT>;
+    getTransactionStatus(transactionHash: BigNumberish): Promise<RPC.TXN_STATUS_RESULT>;
     /**
      * @param invocations AccountInvocations
      * @param simulateTransactionOptions blockIdentifier and flags to skip validation and fee charge<br/>
@@ -4576,49 +4575,50 @@ declare class RpcChannel$2 {
      * - skipValidate (default true)<br/>
      * - skipFeeCharge (default true)<br/>
      */
-    simulateTransaction(invocations: AccountInvocations, simulateTransactionOptions?: getSimulateTransactionOptions): Promise<RPCSPEC09.SimulateTransactionResponse>;
-    waitForTransaction(txHash: BigNumberish, options?: waitForTransactionOptions): Promise<RPCSPEC09.TXN_RECEIPT>;
+    simulateTransaction(invocations: AccountInvocations, simulateTransactionOptions?: getSimulateTransactionOptions): Promise<RPC.SimulateTransactionResponse>;
+    waitForTransaction(txHash: BigNumberish, options?: waitForTransactionOptions): Promise<RPC.TXN_RECEIPT>;
     getStorageAt(contractAddress: BigNumberish, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<string>;
     getClassHashAt(contractAddress: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<string>;
-    getClass(classHash: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<(RPCSPEC09.CONTRACT_CLASS & {
+    getClass(classHash: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<(RPC.CONTRACT_CLASS & {
         program?: undefined;
-    }) | (RPCSPEC09.DEPRECATED_CONTRACT_CLASS & {
+    }) | (RPC.DEPRECATED_CONTRACT_CLASS & {
         sierra_program?: undefined;
         contract_class_version?: undefined;
     })>;
-    getClassAt(contractAddress: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<(RPCSPEC09.CONTRACT_CLASS & {
+    getClassAt(contractAddress: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<(RPC.CONTRACT_CLASS & {
         program?: undefined;
-    }) | (RPCSPEC09.DEPRECATED_CONTRACT_CLASS & {
+    }) | (RPC.DEPRECATED_CONTRACT_CLASS & {
         sierra_program?: undefined;
         contract_class_version?: undefined;
     })>;
-    getEstimateFee(invocations: AccountInvocations, options?: getEstimateFeeBulkOptions): Promise<RPCSPEC09.FEE_ESTIMATE[]>;
-    invoke(functionInvocation: Invocation, details: InvocationsDetailsWithNonce): Promise<RPCSPEC09.InvokedTransaction>;
-    declare(declareTransaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce): Promise<RPCSPEC09.DeclaredTransaction | RPCSPEC09.TXN_RECEIPT>;
-    deployAccount(deployAccountTransaction: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce): Promise<RPCSPEC09.DeployedAccountTransaction | RPCSPEC09.TXN_RECEIPT>;
+    getEstimateFee(invocations: AccountInvocations, options?: getEstimateFeeBulkOptions): Promise<RPC.FEE_ESTIMATE[]>;
+    invoke(functionInvocation: Invocation, details: InvocationsDetailsWithNonce): Promise<RPC.InvokedTransaction>;
+    invokeSignedTx(transaction: RPC.INVOKE_TXN_V3): Promise<RPC.InvokedTransaction>;
+    declare(declareTransaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce): Promise<RPC.DeclaredTransaction | RPC.TXN_RECEIPT>;
+    deployAccount(deployAccountTransaction: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce): Promise<RPC.DeployedAccountTransaction | RPC.TXN_RECEIPT>;
     callContract(call: Call, blockIdentifier?: BlockIdentifier): Promise<string[]>;
     /**
      * NEW: Estimate the fee for a message from L1
      * @param message Message From L1
      */
-    estimateMessageFee(message: RPCSPEC09.L1Message, blockIdentifier?: BlockIdentifier): Promise<RPCSPEC09.MESSAGE_FEE_ESTIMATE>;
+    estimateMessageFee(message: RPC.L1Message, blockIdentifier?: BlockIdentifier): Promise<RPC.MESSAGE_FEE_ESTIMATE>;
     /**
      * Returns an object about the sync status, or false if the node is not synching
      * @returns Object with the stats data
      */
-    getSyncingStats(): Promise<RPCSPEC09.Syncing>;
+    getSyncingStats(): Promise<RPC.Syncing>;
     /**
      * Returns all events matching the given filter
      * @returns events and the pagination of the events
      */
-    getEvents(eventFilter: RPCSPEC09.EventFilter): Promise<RPCSPEC09.EVENTS_CHUNK>;
+    getEvents(eventFilter: RPC.EventFilter): Promise<RPC.EVENTS_CHUNK>;
     buildTransaction<T extends AccountInvocationItem>(invocation: T, versionType?: 'fee' | 'transaction'): Promise<T extends {
         type: typeof ETransactionType.INVOKE;
-    } ? RPCSPEC09.INVOKE_TXN_V3 : T extends {
+    } ? RPC.INVOKE_TXN_V3 : T extends {
         type: typeof ETransactionType.DECLARE;
-    } ? RPCSPEC09.BROADCASTED_DECLARE_TXN_V3 : T extends {
+    } ? RPC.BROADCASTED_DECLARE_TXN_V3 : T extends {
         type: typeof ETransactionType.DEPLOY_ACCOUNT;
-    } ? RPCSPEC09.DEPLOY_ACCOUNT_TXN_V3 : never>;
+    } ? RPC.DEPLOY_ACCOUNT_TXN_V3 : never>;
 }
 
 declare namespace rpc_0_9_0 {
@@ -4651,7 +4651,7 @@ declare class RpcChannel$1 {
     setChainId(chainId: _StarknetChainId): void;
     fetch(method: string, params?: object, id?: string | number): Promise<Response>;
     protected errorHandler(method: string, params: any, rpcError?: Error$1, otherError?: any): void;
-    protected fetchEndpoint<T extends keyof RPC.Methods>(method: T, params?: RPC.Methods[T]['params']): Promise<RPC.Methods[T]['result']>;
+    protected fetchEndpoint<T extends keyof RPC$1.Methods>(method: T, params?: RPC$1.Methods[T]['params']): Promise<RPC$1.Methods[T]['result']>;
     getChainId(): Promise<"0x534e5f4d41494e" | "0x534e5f5345504f4c4941">;
     /**
      * fetch rpc node specVersion
@@ -4666,10 +4666,10 @@ declare class RpcChannel$1 {
     /**
      * Given an l1 tx hash, returns the associated l1_handler tx hashes and statuses for all L1 -> L2 messages sent by the l1 transaction, ordered by the l1 tx sending order
      */
-    getMessagesStatus(txHash: BigNumberish): Promise<RPC.L1L2MessagesStatus>;
-    getStorageProof(classHashes?: BigNumberish[], contractAddresses?: BigNumberish[], contractsStorageKeys?: RPC.CONTRACT_STORAGE_KEYS[], // TODO: allow BigNUmberish[] and fix formatting before request
-    blockIdentifier?: BlockIdentifier): Promise<RPC.StorageProof>;
-    getCompiledCasm(classHash: BigNumberish): Promise<RPC.CASM_COMPILED_CONTRACT_CLASS>;
+    getMessagesStatus(txHash: BigNumberish): Promise<RPC$1.L1L2MessagesStatus>;
+    getStorageProof(classHashes?: BigNumberish[], contractAddresses?: BigNumberish[], contractsStorageKeys?: RPC$1.CONTRACT_STORAGE_KEYS[], // TODO: allow BigNUmberish[] and fix formatting before request
+    blockIdentifier?: BlockIdentifier): Promise<RPC$1.StorageProof>;
+    getCompiledCasm(classHash: BigNumberish): Promise<RPC$1.CASM_COMPILED_CONTRACT_CLASS>;
     getNonceForAddress(contractAddress: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<string>;
     /**
      * Helper method to get the starknet version from the block, default latest block
@@ -4679,7 +4679,7 @@ declare class RpcChannel$1 {
     /**
      * Get the most recent accepted block hash and number
      */
-    getBlockLatestAccepted(): Promise<RPC.BlockHashAndNumber>;
+    getBlockLatestAccepted(): Promise<RPC$1.BlockHashAndNumber>;
     /**
      * Get the most recent accepted block number
      * redundant use getBlockLatestAccepted();
@@ -4687,8 +4687,8 @@ declare class RpcChannel$1 {
      */
     getBlockNumber(): Promise<number>;
     getBlockWithTxHashes(blockIdentifier?: BlockIdentifier): Promise<({
-        status: RPC.BLOCK_STATUS;
-    } & RPC.BLOCK_HEADER & RPC.BLOCK_BODY_WITH_TX_HASHES & {}) | (RPC.BLOCK_BODY_WITH_TX_HASHES & RPC.PRE_CONFIRMED_BLOCK_HEADER & {
+        status: RPC$1.BLOCK_STATUS;
+    } & RPC$1.BLOCK_HEADER & RPC$1.BLOCK_BODY_WITH_TX_HASHES & {}) | (RPC$1.BLOCK_BODY_WITH_TX_HASHES & RPC$1.PRE_CONFIRMED_BLOCK_HEADER & {
         block_hash?: undefined;
         new_root?: undefined;
         status?: undefined;
@@ -4710,8 +4710,8 @@ declare class RpcChannel$1 {
     getBlockWithTxs(blockIdentifier?: BlockIdentifier, options?: {
         includeProofFacts?: boolean;
     }): Promise<({
-        status: RPC.BLOCK_STATUS;
-    } & RPC.BLOCK_HEADER & RPC.BLOCK_BODY_WITH_TXS & {}) | (RPC.BLOCK_BODY_WITH_TXS & RPC.PRE_CONFIRMED_BLOCK_HEADER & {
+        status: RPC$1.BLOCK_STATUS;
+    } & RPC$1.BLOCK_HEADER & RPC$1.BLOCK_BODY_WITH_TXS & {}) | (RPC$1.BLOCK_BODY_WITH_TXS & RPC$1.PRE_CONFIRMED_BLOCK_HEADER & {
         block_hash?: undefined;
         new_root?: undefined;
         status?: undefined;
@@ -4733,8 +4733,8 @@ declare class RpcChannel$1 {
     getBlockWithReceipts(blockIdentifier?: BlockIdentifier, options?: {
         includeProofFacts?: boolean;
     }): Promise<({
-        status: RPC.BLOCK_STATUS;
-    } & RPC.BLOCK_HEADER & RPC.BLOCK_BODY_WITH_RECEIPTS & {}) | (RPC.BLOCK_BODY_WITH_RECEIPTS & RPC.PRE_CONFIRMED_BLOCK_HEADER & {
+        status: RPC$1.BLOCK_STATUS;
+    } & RPC$1.BLOCK_HEADER & RPC$1.BLOCK_BODY_WITH_RECEIPTS & {}) | (RPC$1.BLOCK_BODY_WITH_RECEIPTS & RPC$1.PRE_CONFIRMED_BLOCK_HEADER & {
         block_hash?: undefined;
         new_root?: undefined;
         status?: undefined;
@@ -4747,7 +4747,7 @@ declare class RpcChannel$1 {
         transaction_count?: undefined;
         state_diff_length?: undefined;
     })>;
-    getBlockStateUpdate(blockIdentifier?: BlockIdentifier, contractAddresses?: BigNumberish[]): Promise<(RPC.STATE_UPDATE & {}) | (RPC.PRE_CONFIRMED_STATE_UPDATE & {
+    getBlockStateUpdate(blockIdentifier?: BlockIdentifier, contractAddresses?: BigNumberish[]): Promise<(RPC$1.STATE_UPDATE & {}) | (RPC$1.PRE_CONFIRMED_STATE_UPDATE & {
         new_root?: undefined;
     })>;
     /**
@@ -4758,7 +4758,7 @@ declare class RpcChannel$1 {
      */
     getBlockTransactionsTraces(blockIdentifier?: BlockIdentifier, options?: {
         returnInitialReads?: boolean;
-    }): Promise<RPC.BlockTransactionsTraces>;
+    }): Promise<RPC$1.BlockTransactionsTraces>;
     getBlockTransactionCount(blockIdentifier?: BlockIdentifier): Promise<number>;
     /**
      * Get transaction by hash
@@ -4768,7 +4768,7 @@ declare class RpcChannel$1 {
      */
     getTransactionByHash(txHash: BigNumberish, options?: {
         includeProofFacts?: boolean;
-    }): Promise<RPC.TXN_WITH_HASH>;
+    }): Promise<RPC$1.TXN_WITH_HASH>;
     /**
      * Get transaction by block identifier and index
      * @param blockIdentifier - block identifier
@@ -4778,13 +4778,13 @@ declare class RpcChannel$1 {
      */
     getTransactionByBlockIdAndIndex(blockIdentifier: BlockIdentifier, index: number, options?: {
         includeProofFacts?: boolean;
-    }): Promise<RPC.TXN_WITH_HASH>;
-    getTransactionReceipt(txHash: BigNumberish): Promise<RPC.TXN_RECEIPT_WITH_BLOCK_INFO>;
-    getTransactionTrace(txHash: BigNumberish): Promise<RPC.TRANSACTION_TRACE>;
+    }): Promise<RPC$1.TXN_WITH_HASH>;
+    getTransactionReceipt(txHash: BigNumberish): Promise<RPC$1.TXN_RECEIPT_WITH_BLOCK_INFO>;
+    getTransactionTrace(txHash: BigNumberish): Promise<RPC$1.TRANSACTION_TRACE>;
     /**
      * Get the status of a transaction
      */
-    getTransactionStatus(transactionHash: BigNumberish): Promise<RPC.TXN_STATUS_RESULT>;
+    getTransactionStatus(transactionHash: BigNumberish): Promise<RPC$1.TXN_STATUS_RESULT>;
     /**
      * @param invocations AccountInvocations
      * @param simulateTransactionOptions blockIdentifier and flags to skip validation and fee charge<br/>
@@ -4793,49 +4793,50 @@ declare class RpcChannel$1 {
      * - skipFeeCharge (default true)<br/>
      * - returnInitialReads (default false) - include initial storage reads in trace (RPC 0.10.1+)<br/>
      */
-    simulateTransaction(invocations: AccountInvocations, simulateTransactionOptions?: getSimulateTransactionOptions): Promise<RPC.SimulateTransactionResponse>;
-    waitForTransaction(txHash: BigNumberish, options?: waitForTransactionOptions): Promise<RPC.TXN_RECEIPT>;
-    getStorageAt(contractAddress: BigNumberish, key: BigNumberish, blockIdentifier?: BlockIdentifier, responseFlags?: RPC.STORAGE_RESPONSE_FLAG[]): Promise<string | RPC.STORAGE_RESULT>;
+    simulateTransaction(invocations: AccountInvocations, simulateTransactionOptions?: getSimulateTransactionOptions): Promise<RPC$1.SimulateTransactionResponse>;
+    waitForTransaction(txHash: BigNumberish, options?: waitForTransactionOptions): Promise<RPC$1.TXN_RECEIPT>;
+    getStorageAt(contractAddress: BigNumberish, key: BigNumberish, blockIdentifier?: BlockIdentifier, responseFlags?: RPC$1.STORAGE_RESPONSE_FLAG[]): Promise<string | RPC$1.STORAGE_RESULT>;
     getClassHashAt(contractAddress: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<string>;
-    getClass(classHash: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<(RPC.CONTRACT_CLASS & {
+    getClass(classHash: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<(RPC$1.CONTRACT_CLASS & {
         program?: undefined;
-    }) | (RPC.DEPRECATED_CONTRACT_CLASS & {
+    }) | (RPC$1.DEPRECATED_CONTRACT_CLASS & {
         sierra_program?: undefined;
         contract_class_version?: undefined;
     })>;
-    getClassAt(contractAddress: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<(RPC.CONTRACT_CLASS & {
+    getClassAt(contractAddress: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<(RPC$1.CONTRACT_CLASS & {
         program?: undefined;
-    }) | (RPC.DEPRECATED_CONTRACT_CLASS & {
+    }) | (RPC$1.DEPRECATED_CONTRACT_CLASS & {
         sierra_program?: undefined;
         contract_class_version?: undefined;
     })>;
-    getEstimateFee(invocations: AccountInvocations, options?: getEstimateFeeBulkOptions): Promise<RPC.FEE_ESTIMATE[]>;
-    invoke(functionInvocation: Invocation, details: InvocationsDetailsWithNonce): Promise<RPC.InvokedTransaction>;
-    declare(declareTransaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce): Promise<RPC.TXN_RECEIPT | RPC.DeclaredTransaction>;
-    deployAccount(deployAccountTransaction: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce): Promise<RPC.TXN_RECEIPT | RPC.DeployedAccountTransaction>;
+    getEstimateFee(invocations: AccountInvocations, options?: getEstimateFeeBulkOptions): Promise<RPC$1.FEE_ESTIMATE[]>;
+    invoke(functionInvocation: Invocation, details: InvocationsDetailsWithNonce): Promise<RPC$1.InvokedTransaction>;
+    invokeSignedTx(transaction: RPC$1.INVOKE_TXN_V3): Promise<RPC$1.InvokedTransaction>;
+    declare(declareTransaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce): Promise<RPC$1.TXN_RECEIPT | RPC$1.DeclaredTransaction>;
+    deployAccount(deployAccountTransaction: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce): Promise<RPC$1.TXN_RECEIPT | RPC$1.DeployedAccountTransaction>;
     callContract(call: Call, blockIdentifier?: BlockIdentifier): Promise<string[]>;
     /**
      * NEW: Estimate the fee for a message from L1
      * @param message Message From L1
      */
-    estimateMessageFee(message: RPC.L1Message, blockIdentifier?: BlockIdentifier): Promise<RPC.MESSAGE_FEE_ESTIMATE>;
+    estimateMessageFee(message: RPC$1.L1Message, blockIdentifier?: BlockIdentifier): Promise<RPC$1.MESSAGE_FEE_ESTIMATE>;
     /**
      * Returns an object about the sync status, or false if the node is not synching
      * @returns Object with the stats data
      */
-    getSyncingStats(): Promise<RPC.Syncing>;
+    getSyncingStats(): Promise<RPC$1.Syncing>;
     /**
      * Returns all events matching the given filter
      * @returns events and the pagination of the events
      */
-    getEvents(eventFilter: RPC.EventFilter): Promise<RPC.EVENTS_CHUNK>;
+    getEvents(eventFilter: RPC$1.EventFilter): Promise<RPC$1.EVENTS_CHUNK>;
     buildTransaction<T extends AccountInvocationItem>(invocation: T, versionType?: 'fee' | 'transaction'): Promise<T extends {
         type: typeof ETransactionType.INVOKE;
-    } ? RPC.BROADCASTED_INVOKE_TXN : T extends {
+    } ? RPC$1.BROADCASTED_INVOKE_TXN : T extends {
         type: typeof ETransactionType.DECLARE;
-    } ? RPC.BROADCASTED_DECLARE_TXN_V3 : T extends {
+    } ? RPC$1.BROADCASTED_DECLARE_TXN_V3 : T extends {
         type: typeof ETransactionType.DEPLOY_ACCOUNT;
-    } ? RPC.DEPLOY_ACCOUNT_TXN_V3 : never>;
+    } ? RPC$1.DEPLOY_ACCOUNT_TXN_V3 : never>;
 }
 
 declare namespace rpc_0_10_2 {
@@ -5318,6 +5319,198 @@ declare class PluginManager {
     hasPlugin(name: string): boolean;
 }
 
+interface StarknetIdProviderMethods {
+    getStarkName(address: BigNumberish, StarknetIdContract?: string): Promise<string>;
+    getAddressFromStarkName(name: string, StarknetIdContract?: string): Promise<string>;
+    getStarkProfile(address: BigNumberish, StarknetIdContract?: string, StarknetIdIdentityContract?: string, StarknetIdVerifierContract?: string, StarknetIdPfpContract?: string, StarknetIdPopContract?: string, StarknetIdMulticallContract?: string): Promise<StarkProfile>;
+}
+interface StarknetIdAccountMethods {
+    getStarkName(address?: BigNumberish, StarknetIdContract?: string): Promise<string>;
+    getAddressFromStarkName(name: string, StarknetIdContract?: string): Promise<string>;
+    getStarkProfile(address: BigNumberish, StarknetIdContract?: string, StarknetIdIdentityContract?: string, StarknetIdVerifierContract?: string, StarknetIdPfpContract?: string, StarknetIdPopContract?: string, StarknetIdMulticallContract?: string): Promise<StarkProfile>;
+}
+declare class StarknetIdImpl {
+    static getStarkName(provider: ProviderInterface, address: BigNumberish, StarknetIdContract?: string): Promise<string>;
+    static getAddressFromStarkName(provider: ProviderInterface, name: string, StarknetIdContract?: string): Promise<string>;
+    static getStarkProfile(provider: ProviderInterface, address: BigNumberish, StarknetIdContract?: string, StarknetIdIdentityContract?: string, StarknetIdVerifierContract?: string, StarknetIdPfpContract?: string, StarknetIdPopContract?: string, StarknetIdMulticallContract?: string): Promise<StarkProfile>;
+}
+
+interface BrotherProfile {
+    name: string;
+    resolver: string;
+    tokenId: string;
+    expiryDate: number;
+    lastTransferTime: number;
+}
+interface BrotherIdProviderMethods {
+    getBrotherName(address: BigNumberish, BrotherIdContract?: string): Promise<string>;
+    getAddressFromBrotherName(name: string, BrotherIdContract?: string): Promise<string>;
+    getBrotherProfile(address: BigNumberish, BrotherIdContract?: string): Promise<BrotherProfile>;
+}
+declare class BrotherIdImpl {
+    static getBrotherName(provider: ProviderInterface, address: BigNumberish, BrotherIdContract?: string): Promise<string>;
+    static getAddressFromBrotherName(provider: ProviderInterface, name: string, BrotherIdContract?: string): Promise<string>;
+    static getBrotherProfile(provider: ProviderInterface, address: BigNumberish, BrotherIdContract?: string): Promise<BrotherProfile>;
+}
+/**
+ * BrotherId plugin - adds .brother domain resolution methods.
+ *
+ * @example
+ * ```typescript
+ * import { RpcProvider, brotherId } from 'starknet';
+ * const provider = new RpcProvider({ plugins: [brotherId()] });
+ * const name = await provider.getBrotherName('0x123...');
+ * ```
+ */
+declare function brotherId(): StarknetPlugin<BrotherIdProviderMethods>;
+
+/**
+ * Options for controlling fastWaitForTransaction polling behavior
+ */
+type FastWaitForTransactionOptions = {
+    /** Number of retry attempts (default: 50) */
+    retries?: number;
+    /** Milliseconds to wait between retries (default: 500) */
+    retryInterval?: number;
+};
+/**
+ * Response from fastExecute() containing transaction result and readiness status
+ */
+type FastExecuteResponse = {
+    /** The transaction invoke response with transaction hash */
+    txResult: InvokeFunctionResponse;
+    /** Whether the next transaction can be executed immediately */
+    isReady: boolean;
+};
+/**
+ * Provider methods added by the FastExecute plugin
+ */
+interface FastExecuteProviderMethods {
+    /**
+     * Wait for transaction confirmation with polling optimization for gaming.
+     *
+     * This method is fast but Events and transaction reports are not yet available.
+     * Useful for gaming activity and rapid-fire transaction scenarios.
+     *
+     * Only available on RPC 0.9 and onwards.
+     *
+     * @param {BigNumberish} txHash - Transaction hash to monitor
+     * @param {string} address - Address of the account (used to track nonce changes)
+     * @param {BigNumberish} initNonce - Initial nonce of the account (before the transaction)
+     * @param {FastWaitForTransactionOptions} [options={retries: 50, retryInterval: 500}] - Polling configuration
+     *        options. `retries` is the number of times to retry (default: 50), `retryInterval` is the time in ms
+     *        between retries (default: 500).
+     * @returns {Promise<boolean>} Returns true if the next transaction is possible (nonce increment detected),
+     *          false if the timeout has been reached, or throws an error in case of provider communication failure
+     *          or transaction reversion.
+     *
+     * @example
+     * ```typescript
+     * const isReady = await provider.fastWaitForTransaction(
+     *   '0x123abc...',
+     *   '0x456def...',
+     *   10,
+     *   { retries: 30, retryInterval: 500 }
+     * );
+     *
+     * if (isReady) {
+     *   // Next transaction can be sent
+     * }
+     * ```
+     */
+    fastWaitForTransaction(txHash: BigNumberish, address: string, initNonce: BigNumberish, options?: FastWaitForTransactionOptions): Promise<boolean>;
+}
+/**
+ * Account methods added by the FastExecute plugin
+ */
+interface FastExecuteAccountMethods {
+    /**
+     * Execute one or multiple calls through the account contract,
+     * responding as soon as a new transaction is possible with the same account.
+     * Useful for gaming usage where rapid consecutive transactions are needed.
+     *
+     * This method requires the provider to be initialized with `pre_confirmed` blockIdentifier option.
+     * RPC 0.9 minimum.
+     *
+     * In a normal `account.execute()` call followed by `provider.waitForTransaction()`, you have immediate access
+     * to the events and transaction report. Here, we process consecutive transactions faster, but events and
+     * transaction reports are not available immediately.
+     *
+     * As a consequence of the above, do not use contract/account deployment with this method.
+     *
+     * @param {AllowArray<Call>} transactions - Single call or array of calls to execute
+     * @param {UniversalDetails} [transactionsDetail] - Transaction execution options
+     * @param {FastWaitForTransactionOptions} [waitDetail={retries: 50, retryInterval: 500}] - Options to scan the
+     *        network for the next possible transaction. `retries` is the number of times to retry (default: 50),
+     *        `retryInterval` is the time in ms between retries (default: 500).
+     * @returns {Promise<FastExecuteResponse>} Response containing the transaction result and status for the next
+     *          transaction. If `isReady` is true, you can execute the next transaction immediately. If false,
+     *          timeout has been reached before the next transaction was possible.
+     *
+     * @example
+     * ```typescript
+     * const myProvider = new RpcProvider({
+     *   nodeUrl: url,
+     *   blockIdentifier: BlockTag.PRE_CONFIRMED
+     * });
+     * const myAccount = new Account({
+     *   provider: myProvider,
+     *   address: accountAddress0,
+     *   signer: privateKey0
+     * });
+     *
+     * const resp = await myAccount.fastExecute(
+     *   call,
+     *   { tip: recommendedTip },
+     *   { retries: 30, retryInterval: 500 }
+     * );
+     *
+     * // if resp.isReady is true, you can launch immediately a new tx
+     * if (resp.isReady) {
+     *   // send next transaction
+     * }
+     * ```
+     */
+    fastExecute(transactions: any, transactionsDetail?: any, waitDetail?: FastWaitForTransactionOptions): Promise<FastExecuteResponse>;
+}
+
+/**
+ * FastExecute plugin - adds gaming-optimized transaction execution
+ *
+ * Provides fastExecute() on accounts and fastWaitForTransaction() on providers
+ * for rapid successive transaction execution with minimal confirmation latency.
+ *
+ * Requires:
+ * - RPC 0.9 or later
+ * - Provider initialized with BlockTag.PRE_CONFIRMED
+ *
+ * @example
+ * ```typescript
+ * import { RpcProvider, Account } from 'starknet';
+ * import { fastExecute } from 'starknet/plugins';
+ *
+ * const provider = new RpcProvider({
+ *   nodeUrl: url,
+ *   blockIdentifier: BlockTag.PRE_CONFIRMED,
+ * });
+ *
+ * const account = new Account({ provider, address, signer });
+ *
+ * const resp = await account.fastExecute(
+ *   call,
+ *   { tip: recommendedTip },
+ *   { retries: 30, retryInterval: 500 }
+ * );
+ *
+ * if (resp.isReady) {
+ *   // Next transaction can be sent immediately
+ * }
+ * ```
+ */
+declare function fastExecute(): StarknetPlugin<FastExecuteProviderMethods, FastExecuteAccountMethods>;
+
+interface RpcProvider extends StarknetIdProviderMethods, BrotherIdProviderMethods, FastExecuteProviderMethods {
+}
 declare class RpcProvider implements ProviderInterface {
     responseParser: RPCResponseParser;
     channel: RpcChannel$2 | RpcChannel$1 | RpcChannel;
@@ -5353,11 +5546,11 @@ declare class RpcProvider implements ProviderInterface {
     getBlock(blockIdentifier: 'pre_confirmed'): Promise<PreConfirmedBlock>;
     getBlock(blockIdentifier: 'latest'): Promise<Block$1>;
     getBlock(blockIdentifier: BlockIdentifier): Promise<GetBlockResponse>;
-    getBlockLatestAccepted(): Promise<RPCSPEC09.BlockHashAndNumber>;
+    getBlockLatestAccepted(): Promise<RPC.BlockHashAndNumber>;
     getBlockNumber(): Promise<number>;
     getBlockWithTxHashes(blockIdentifier?: BlockIdentifier): Promise<({
-        status: RPCSPEC09.BLOCK_STATUS;
-    } & RPCSPEC09.BLOCK_HEADER & RPCSPEC09.BLOCK_BODY_WITH_TX_HASHES & {}) | (RPCSPEC09.BLOCK_BODY_WITH_TX_HASHES & RPCSPEC09.PRE_CONFIRMED_BLOCK_HEADER & {
+        status: RPC.BLOCK_STATUS;
+    } & RPC.BLOCK_HEADER & RPC.BLOCK_BODY_WITH_TX_HASHES & {}) | (RPC.BLOCK_BODY_WITH_TX_HASHES & RPC.PRE_CONFIRMED_BLOCK_HEADER & {
         block_hash?: undefined;
         new_root?: undefined;
         status?: undefined;
@@ -5366,8 +5559,8 @@ declare class RpcProvider implements ProviderInterface {
     getBlockWithTxs(blockIdentifier?: BlockIdentifier, options?: {
         includeProofFacts?: boolean;
     }): Promise<({
-        status: RPCSPEC09.BLOCK_STATUS;
-    } & RPCSPEC09.BLOCK_HEADER & RPCSPEC09.BLOCK_BODY_WITH_TXS & {}) | (RPCSPEC09.BLOCK_BODY_WITH_TXS & RPCSPEC09.PRE_CONFIRMED_BLOCK_HEADER & {
+        status: RPC.BLOCK_STATUS;
+    } & RPC.BLOCK_HEADER & RPC.BLOCK_BODY_WITH_TXS & {}) | (RPC.BLOCK_BODY_WITH_TXS & RPC.PRE_CONFIRMED_BLOCK_HEADER & {
         block_hash?: undefined;
         new_root?: undefined;
         status?: undefined;
@@ -5390,8 +5583,8 @@ declare class RpcProvider implements ProviderInterface {
     getBlockWithReceipts(blockIdentifier?: BlockIdentifier, options?: {
         includeProofFacts?: boolean;
     }): Promise<({
-        status: RPCSPEC09.BLOCK_STATUS;
-    } & RPCSPEC09.BLOCK_HEADER & RPCSPEC09.BLOCK_BODY_WITH_RECEIPTS & {}) | (RPCSPEC09.BLOCK_BODY_WITH_RECEIPTS & RPCSPEC09.PRE_CONFIRMED_BLOCK_HEADER & {
+        status: RPC.BLOCK_STATUS;
+    } & RPC.BLOCK_HEADER & RPC.BLOCK_BODY_WITH_RECEIPTS & {}) | (RPC.BLOCK_BODY_WITH_RECEIPTS & RPC.PRE_CONFIRMED_BLOCK_HEADER & {
         block_hash?: undefined;
         new_root?: undefined;
         status?: undefined;
@@ -5409,99 +5602,99 @@ declare class RpcProvider implements ProviderInterface {
     getBlockStateUpdate(blockIdentifier?: BlockIdentifier, contractAddresses?: BigNumberish[]): Promise<StateUpdateResponse>;
     getBlockTransactionsTraces(blockIdentifier?: BlockIdentifier, options?: {
         returnInitialReads?: boolean;
-    }): Promise<RPCSPEC09.BlockTransactionsTraces | RPC.BlockTransactionsTracesWithInitialReads>;
+    }): Promise<RPC.BlockTransactionsTraces | RPC$1.BlockTransactionsTracesWithInitialReads>;
     getBlockTransactionCount(blockIdentifier?: BlockIdentifier): Promise<number>;
     getTransaction(txHash: BigNumberish, options?: {
         includeProofFacts?: boolean;
-    }): Promise<(RPCSPEC09.INVOKE_TXN_V0 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.INVOKE_TXN_V1 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.INVOKE_TXN_V3 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
+    }): Promise<(RPC.INVOKE_TXN_V0 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.INVOKE_TXN_V1 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.INVOKE_TXN_V3 & {
+        transaction_hash: RPC.TXN_HASH;
     }) | ({
         version: "0x0";
-        type: Uppercase<RPCSPEC09.ABI_TYPE_L1_HANDLER>;
-        nonce: RPCSPEC09.NUM_AS_HEX;
-    } & RPCSPEC09.FUNCTION_CALL & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DECLARE_TXN_V0 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DECLARE_TXN_V1 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DECLARE_TXN_V2 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DECLARE_TXN_V3 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DEPLOY_TXN & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DEPLOY_ACCOUNT_TXN_V1 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DEPLOY_ACCOUNT_TXN_V3 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
+        type: Uppercase<RPC.ABI_TYPE_L1_HANDLER>;
+        nonce: RPC.NUM_AS_HEX;
+    } & RPC.FUNCTION_CALL & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DECLARE_TXN_V0 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DECLARE_TXN_V1 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DECLARE_TXN_V2 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DECLARE_TXN_V3 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DEPLOY_TXN & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DEPLOY_ACCOUNT_TXN_V1 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DEPLOY_ACCOUNT_TXN_V3 & {
+        transaction_hash: RPC.TXN_HASH;
     })>;
     getTransactionByHash(txHash: BigNumberish, options?: {
         includeProofFacts?: boolean;
-    }): Promise<(RPCSPEC09.INVOKE_TXN_V0 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.INVOKE_TXN_V1 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.INVOKE_TXN_V3 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
+    }): Promise<(RPC.INVOKE_TXN_V0 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.INVOKE_TXN_V1 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.INVOKE_TXN_V3 & {
+        transaction_hash: RPC.TXN_HASH;
     }) | ({
         version: "0x0";
-        type: Uppercase<RPCSPEC09.ABI_TYPE_L1_HANDLER>;
-        nonce: RPCSPEC09.NUM_AS_HEX;
-    } & RPCSPEC09.FUNCTION_CALL & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DECLARE_TXN_V0 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DECLARE_TXN_V1 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DECLARE_TXN_V2 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DECLARE_TXN_V3 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DEPLOY_TXN & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DEPLOY_ACCOUNT_TXN_V1 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DEPLOY_ACCOUNT_TXN_V3 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
+        type: Uppercase<RPC.ABI_TYPE_L1_HANDLER>;
+        nonce: RPC.NUM_AS_HEX;
+    } & RPC.FUNCTION_CALL & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DECLARE_TXN_V0 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DECLARE_TXN_V1 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DECLARE_TXN_V2 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DECLARE_TXN_V3 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DEPLOY_TXN & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DEPLOY_ACCOUNT_TXN_V1 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DEPLOY_ACCOUNT_TXN_V3 & {
+        transaction_hash: RPC.TXN_HASH;
     })>;
     getTransactionByBlockIdAndIndex(blockIdentifier: BlockIdentifier, index: number, options?: {
         includeProofFacts?: boolean;
-    }): Promise<(RPCSPEC09.INVOKE_TXN_V0 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.INVOKE_TXN_V1 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.INVOKE_TXN_V3 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
+    }): Promise<(RPC.INVOKE_TXN_V0 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.INVOKE_TXN_V1 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.INVOKE_TXN_V3 & {
+        transaction_hash: RPC.TXN_HASH;
     }) | ({
         version: "0x0";
-        type: Uppercase<RPCSPEC09.ABI_TYPE_L1_HANDLER>;
-        nonce: RPCSPEC09.NUM_AS_HEX;
-    } & RPCSPEC09.FUNCTION_CALL & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DECLARE_TXN_V0 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DECLARE_TXN_V1 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DECLARE_TXN_V2 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DECLARE_TXN_V3 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DEPLOY_TXN & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DEPLOY_ACCOUNT_TXN_V1 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
-    }) | (RPCSPEC09.DEPLOY_ACCOUNT_TXN_V3 & {
-        transaction_hash: RPCSPEC09.TXN_HASH;
+        type: Uppercase<RPC.ABI_TYPE_L1_HANDLER>;
+        nonce: RPC.NUM_AS_HEX;
+    } & RPC.FUNCTION_CALL & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DECLARE_TXN_V0 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DECLARE_TXN_V1 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DECLARE_TXN_V2 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DECLARE_TXN_V3 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DEPLOY_TXN & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DEPLOY_ACCOUNT_TXN_V1 & {
+        transaction_hash: RPC.TXN_HASH;
+    }) | (RPC.DEPLOY_ACCOUNT_TXN_V3 & {
+        transaction_hash: RPC.TXN_HASH;
     })>;
     getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
-    getTransactionTrace<V extends _SupportedRpcVersion = _SupportedRpcVersion>(txHash: BigNumberish): Promise<V extends SupportedRpcVersion0_10 ? RPCSPEC0103.TRANSACTION_TRACE : RPCSPEC09.TRANSACTION_TRACE>;
-    getTransactionTrace(txHash: BigNumberish): Promise<RPCSPEC0103.TRANSACTION_TRACE | RPCSPEC09.TRANSACTION_TRACE>;
-    getTransactionStatus(transactionHash: BigNumberish): Promise<RPCSPEC09.TXN_STATUS_RESULT>;
+    getTransactionTrace<V extends _SupportedRpcVersion = _SupportedRpcVersion>(txHash: BigNumberish): Promise<V extends SupportedRpcVersion0_10 ? RPCSPEC0103.TRANSACTION_TRACE : RPC.TRANSACTION_TRACE>;
+    getTransactionTrace(txHash: BigNumberish): Promise<RPCSPEC0103.TRANSACTION_TRACE | RPC.TRANSACTION_TRACE>;
+    getTransactionStatus(transactionHash: BigNumberish): Promise<RPC.TXN_STATUS_RESULT>;
     getSimulateTransaction(invocations: AccountInvocations, options?: getSimulateTransactionOptions): Promise<SimulateTransactionOverheadResponse>;
     waitForTransaction(txHash: BigNumberish, options?: waitForTransactionOptions): Promise<GetTransactionReceiptResponse>;
     getStorageAt(contractAddress: BigNumberish, key: BigNumberish, blockIdentifier?: BlockIdentifier, responseFlags?: RPCSPEC0103.STORAGE_RESPONSE_FLAG[]): Promise<STORAGE_RESULT>;
@@ -5518,6 +5711,34 @@ declare class RpcProvider implements ProviderInterface {
     invokeFunction(functionInvocation: Invocation, details: InvocationsDetailsWithNonce): Promise<{
         transaction_hash: string;
     }>;
+    /**
+     * Submit a pre-signed INVOKE_TXN_V3 transaction to the network.
+     *
+     * Broadcasts a transaction previously built and signed by `Account.getSignedTransaction()`.
+     * Fees are already included in the signed transaction and will not be re-estimated.
+     *
+     * @param transaction - A fully signed `RPC.INVOKE_TXN_V3` object, as returned by `Account.getSignedTransaction()`
+     *
+     * @returns The transaction hash if `waitMode` is disabled (default), or the transaction receipt if `waitMode` is enabled.
+     *
+     * @remarks
+     * - The transaction must be signed before calling this method ; use `Account.getSignedTransaction()` to produce it.
+     * - Resubmitting the same signed transaction (same nonce) will be rejected by the network.
+     * - If `waitMode` is enabled on the provider, this method waits for the transaction to be included in a block before returning.
+     *
+     * @example
+     * ```typescript
+     * const signedTx = await account.getSignedTransaction([
+     *   { contractAddress: erc20Address, entrypoint: 'transfer', calldata: [recipient, amount, 0] }
+     * ]);
+     * // inspect or store signedTx, then submit when ready:
+     * const { transaction_hash } = await provider.invokeSignedTx(signedTx);
+     * await provider.waitForTransaction(transaction_hash);
+     * ```
+     */
+    invokeSignedTx(transaction: INVOKE_TXN_V3): Promise<{
+        transaction_hash: string;
+    }>;
     declareContract(transaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce): Promise<{
         class_hash: string;
         transaction_hash: string;
@@ -5527,11 +5748,11 @@ declare class RpcProvider implements ProviderInterface {
         transaction_hash: string;
     }>;
     callContract(call: Call, blockIdentifier?: BlockIdentifier): Promise<string[]>;
-    estimateMessageFee<V extends _SupportedRpcVersion = _SupportedRpcVersion>(message: RPCSPEC09.L1Message, blockIdentifier?: BlockIdentifier): Promise<V extends SupportedRpcVersion0_10 ? RPCSPEC0103.FEE_ESTIMATE : RPCSPEC09.MESSAGE_FEE_ESTIMATE>;
-    estimateMessageFee(message: RPCSPEC09.L1Message, blockIdentifier?: BlockIdentifier): Promise<RPCSPEC0103.FEE_ESTIMATE | RPCSPEC09.MESSAGE_FEE_ESTIMATE>;
-    getSyncingStats(): Promise<RPCSPEC09.Syncing>;
-    getEvents<V extends _SupportedRpcVersion = _SupportedRpcVersion>(eventFilter: V extends SupportedRpcVersion0_10 ? RPCSPEC0103.EventFilter : RPCSPEC09.EventFilter): Promise<V extends SupportedRpcVersion0_10 ? RPCSPEC0103.EVENTS_CHUNK : RPCSPEC09.EVENTS_CHUNK>;
-    getEvents(eventFilter: RPCSPEC0103.EventFilter | RPCSPEC09.EventFilter): Promise<RPCSPEC0103.EVENTS_CHUNK | RPCSPEC09.EVENTS_CHUNK>;
+    estimateMessageFee<V extends _SupportedRpcVersion = _SupportedRpcVersion>(message: RPC.L1Message, blockIdentifier?: BlockIdentifier): Promise<V extends SupportedRpcVersion0_10 ? RPCSPEC0103.FEE_ESTIMATE : RPC.MESSAGE_FEE_ESTIMATE>;
+    estimateMessageFee(message: RPC.L1Message, blockIdentifier?: BlockIdentifier): Promise<RPCSPEC0103.FEE_ESTIMATE | RPC.MESSAGE_FEE_ESTIMATE>;
+    getSyncingStats(): Promise<RPC.Syncing>;
+    getEvents<V extends _SupportedRpcVersion = _SupportedRpcVersion>(eventFilter: V extends SupportedRpcVersion0_10 ? RPCSPEC0103.EventFilter : RPC.EventFilter): Promise<V extends SupportedRpcVersion0_10 ? RPCSPEC0103.EVENTS_CHUNK : RPC.EVENTS_CHUNK>;
+    getEvents(eventFilter: RPCSPEC0103.EventFilter | RPC.EventFilter): Promise<RPCSPEC0103.EVENTS_CHUNK | RPC.EVENTS_CHUNK>;
     verifyMessageInStarknet(message: BigNumberish | TypedData, signature: Signature, accountAddress: BigNumberish, signatureVerificationFunctionName?: string, signatureVerificationResponse?: {
         okResponse: string[];
         nokResponse: string[];
@@ -5539,8 +5760,8 @@ declare class RpcProvider implements ProviderInterface {
     }): Promise<boolean>;
     isClassDeclared(contractClassIdentifier: ContractClassIdentifier, blockIdentifier?: BlockIdentifier): Promise<boolean>;
     prepareInvocations(invocations: Invocations): Promise<Invocations>;
-    getL1MessagesStatus<V extends _SupportedRpcVersion = _SupportedRpcVersion>(transactionHash: BigNumberish): Promise<V extends SupportedRpcVersion0_10 ? RPCSPEC0103.L1L2MessagesStatus : RPCSPEC09.L1L2MessagesStatus>;
-    getL1MessagesStatus(transactionHash: BigNumberish): Promise<RPCSPEC0103.L1L2MessagesStatus | RPCSPEC09.L1L2MessagesStatus>;
+    getL1MessagesStatus<V extends _SupportedRpcVersion = _SupportedRpcVersion>(transactionHash: BigNumberish): Promise<V extends SupportedRpcVersion0_10 ? RPCSPEC0103.L1L2MessagesStatus : RPC.L1L2MessagesStatus>;
+    getL1MessagesStatus(transactionHash: BigNumberish): Promise<RPCSPEC0103.L1L2MessagesStatus | RPC.L1L2MessagesStatus>;
     getStorageProof(classHashes: BigNumberish[], contractAddresses: BigNumberish[], contractsStorageKeys: CONTRACT_STORAGE_KEYS[], blockIdentifier?: BlockIdentifier): Promise<StorageProof>;
     getCompiledCasm(classHash: BigNumberish): Promise<CASM_COMPILED_CONTRACT_CLASS>;
     getEstimateTip(blockIdentifier?: BlockIdentifier, options?: TipAnalysisOptions): Promise<TipEstimate>;
@@ -5573,6 +5794,8 @@ declare function verifyMessageInStarknet(provider: ProviderInterface, message: B
 
 declare function getGasPrices(channel: RpcChannel$2 | RpcChannel$1, blockIdentifier?: BlockIdentifier): Promise<GasPrices>;
 
+interface Account extends StarknetIdAccountMethods, BrotherIdProviderMethods, FastExecuteAccountMethods {
+}
 declare class Account implements AccountInterface {
     provider: RpcProvider;
     signer: SignerInterface;
@@ -5598,7 +5821,38 @@ declare class Account implements AccountInterface {
     estimateDeployFee(payload: UniversalDeployerContractPayload | UniversalDeployerContractPayload[], details?: UniversalDetails): Promise<EstimateFeeResponseOverhead>;
     estimateFeeBulk(invocations: Invocations, details?: UniversalDetails): Promise<EstimateFeeBulk>;
     simulateTransaction(invocations: Invocations, details?: SimulateTransactionDetails): Promise<SimulateTransactionOverheadResponse>;
+    /**
+     * Shared preparation logic for execute() and buildExecute().
+     * Runs hooks, estimates fees, and builds accountInvocations.
+     * @private
+     */
+    private prepareInvoke;
     execute(transactions: AllowArray<Call>, transactionsDetail?: UniversalDetails): Promise<InvokeFunctionResponse>;
+    /**
+     * Build a signed INVOKE_TXN_V3 transaction without submitting it to the network.
+     *
+     * Produces a fully signed transaction object that can be inspected, stored,
+     * or submitted later via `provider.channel.sendTransaction()`.
+     * Main usage is to send a virtual transaction to a proof server.
+     * Fees are estimated automatically if not provided.
+     *
+     * @param transactions - Single call or array of calls to include in the transaction
+     * @param transactionsDetail - Transaction execution options
+     * @returns A fully signed `RPC.INVOKE_TXN_V3` object, ready to broadcast
+     *
+     * @remarks
+     * - Unlike `execute()`, this method does **not** submit the transaction ; the account nonce is unchanged after the call.
+     * - The `afterExecute` plugin hook is intentionally **not** triggered.
+     * - The returned object can be broadcast with `provider.channel.sendTransaction()`.
+     *
+     * @example
+     * ```typescript
+     * const signedTx = await account.getSignedTransaction(
+     *   { contractAddress: erc20Address, entrypoint: 'transfer', calldata: [recipient, amount, 0] }
+     * );
+     * ```
+     */
+    getSignedTransaction(transactions: AllowArray<Call>, transactionsDetail?: UniversalDetails): Promise<INVOKE_TXN_V3>;
     /**
      * First check if contract is already declared, if not declare it
      * If contract already declared returned transaction_hash is ''.
@@ -5815,8 +6069,8 @@ declare class WalletAccountV5 extends Account {
     /**
      * ACCOUNT METHODS
      */
-    execute(calls: AllowArray<Call>): Promise<RPC.AddInvokeTransactionResult>;
-    declare(payload: DeclareContractPayload): Promise<RPC.AddDeclareTransactionResult>;
+    execute(calls: AllowArray<Call>): Promise<RPC$1.AddInvokeTransactionResult>;
+    declare(payload: DeclareContractPayload): Promise<RPC$1.AddDeclareTransactionResult>;
     deploy(payload: UniversalDeployerContractPayload | UniversalDeployerContractPayload[]): Promise<MultiDeployContractResponse>;
     signMessage(typedData: TypedData): Promise<Signature$2>;
     static connect(provider: ProviderOptions | ProviderInterface, walletProvider: WalletWithStarknetFeatures, cairoVersion?: CairoVersion, paymaster?: PaymasterOptions | PaymasterInterface, silentMode?: boolean): Promise<WalletAccountV5>;
@@ -6176,205 +6430,6 @@ declare class Contract implements ContractInterface {
     static factory(params: FactoryParams, details?: UniversalDetails): Promise<Contract>;
 }
 
-interface StarknetIdProviderMethods {
-    getStarkName(address: BigNumberish, StarknetIdContract?: string): Promise<string>;
-    getAddressFromStarkName(name: string, StarknetIdContract?: string): Promise<string>;
-    getStarkProfile(address: BigNumberish, StarknetIdContract?: string, StarknetIdIdentityContract?: string, StarknetIdVerifierContract?: string, StarknetIdPfpContract?: string, StarknetIdPopContract?: string, StarknetIdMulticallContract?: string): Promise<StarkProfile>;
-}
-interface StarknetIdAccountMethods {
-    getStarkName(address?: BigNumberish, StarknetIdContract?: string): Promise<string>;
-    getAddressFromStarkName(name: string, StarknetIdContract?: string): Promise<string>;
-    getStarkProfile(address: BigNumberish, StarknetIdContract?: string, StarknetIdIdentityContract?: string, StarknetIdVerifierContract?: string, StarknetIdPfpContract?: string, StarknetIdPopContract?: string, StarknetIdMulticallContract?: string): Promise<StarkProfile>;
-}
-declare class StarknetIdImpl {
-    static getStarkName(provider: ProviderInterface, address: BigNumberish, StarknetIdContract?: string): Promise<string>;
-    static getAddressFromStarkName(provider: ProviderInterface, name: string, StarknetIdContract?: string): Promise<string>;
-    static getStarkProfile(provider: ProviderInterface, address: BigNumberish, StarknetIdContract?: string, StarknetIdIdentityContract?: string, StarknetIdVerifierContract?: string, StarknetIdPfpContract?: string, StarknetIdPopContract?: string, StarknetIdMulticallContract?: string): Promise<StarkProfile>;
-}
-
-interface BrotherProfile {
-    name: string;
-    resolver: string;
-    tokenId: string;
-    expiryDate: number;
-    lastTransferTime: number;
-}
-interface BrotherIdProviderMethods {
-    getBrotherName(address: BigNumberish, BrotherIdContract?: string): Promise<string>;
-    getAddressFromBrotherName(name: string, BrotherIdContract?: string): Promise<string>;
-    getBrotherProfile(address: BigNumberish, BrotherIdContract?: string): Promise<BrotherProfile>;
-}
-declare class BrotherIdImpl {
-    static getBrotherName(provider: ProviderInterface, address: BigNumberish, BrotherIdContract?: string): Promise<string>;
-    static getAddressFromBrotherName(provider: ProviderInterface, name: string, BrotherIdContract?: string): Promise<string>;
-    static getBrotherProfile(provider: ProviderInterface, address: BigNumberish, BrotherIdContract?: string): Promise<BrotherProfile>;
-}
-/**
- * BrotherId plugin - adds .brother domain resolution methods.
- *
- * @example
- * ```typescript
- * import { RpcProvider, brotherId } from 'starknet';
- * const provider = new RpcProvider({ plugins: [brotherId()] });
- * const name = await provider.getBrotherName('0x123...');
- * ```
- */
-declare function brotherId(): StarknetPlugin<BrotherIdProviderMethods>;
-
-declare module '../provider/rpc' {
-    interface RpcProvider extends StarknetIdProviderMethods, BrotherIdProviderMethods {
-    }
-}
-declare module '../account/default' {
-    interface Account extends StarknetIdAccountMethods, BrotherIdProviderMethods {
-    }
-}
-
-/**
- * Options for controlling fastWaitForTransaction polling behavior
- */
-type FastWaitForTransactionOptions = {
-    /** Number of retry attempts (default: 50) */
-    retries?: number;
-    /** Milliseconds to wait between retries (default: 500) */
-    retryInterval?: number;
-};
-/**
- * Response from fastExecute() containing transaction result and readiness status
- */
-type FastExecuteResponse = {
-    /** The transaction invoke response with transaction hash */
-    txResult: InvokeFunctionResponse;
-    /** Whether the next transaction can be executed immediately */
-    isReady: boolean;
-};
-/**
- * Provider methods added by the FastExecute plugin
- */
-interface FastExecuteProviderMethods {
-    /**
-     * Wait for transaction confirmation with polling optimization for gaming.
-     *
-     * This method is fast but Events and transaction reports are not yet available.
-     * Useful for gaming activity and rapid-fire transaction scenarios.
-     *
-     * Only available on RPC 0.9 and onwards.
-     *
-     * @param {BigNumberish} txHash - Transaction hash to monitor
-     * @param {string} address - Address of the account (used to track nonce changes)
-     * @param {BigNumberish} initNonce - Initial nonce of the account (before the transaction)
-     * @param {FastWaitForTransactionOptions} [options={retries: 50, retryInterval: 500}] - Polling configuration
-     *        options. `retries` is the number of times to retry (default: 50), `retryInterval` is the time in ms
-     *        between retries (default: 500).
-     * @returns {Promise<boolean>} Returns true if the next transaction is possible (nonce increment detected),
-     *          false if the timeout has been reached, or throws an error in case of provider communication failure
-     *          or transaction reversion.
-     *
-     * @example
-     * ```typescript
-     * const isReady = await provider.fastWaitForTransaction(
-     *   '0x123abc...',
-     *   '0x456def...',
-     *   10,
-     *   { retries: 30, retryInterval: 500 }
-     * );
-     *
-     * if (isReady) {
-     *   // Next transaction can be sent
-     * }
-     * ```
-     */
-    fastWaitForTransaction(txHash: BigNumberish, address: string, initNonce: BigNumberish, options?: FastWaitForTransactionOptions): Promise<boolean>;
-}
-/**
- * Account methods added by the FastExecute plugin
- */
-interface FastExecuteAccountMethods {
-    /**
-     * Execute one or multiple calls through the account contract,
-     * responding as soon as a new transaction is possible with the same account.
-     * Useful for gaming usage where rapid consecutive transactions are needed.
-     *
-     * This method requires the provider to be initialized with `pre_confirmed` blockIdentifier option.
-     * RPC 0.9 minimum.
-     *
-     * In a normal `account.execute()` call followed by `provider.waitForTransaction()`, you have immediate access
-     * to the events and transaction report. Here, we process consecutive transactions faster, but events and
-     * transaction reports are not available immediately.
-     *
-     * As a consequence of the above, do not use contract/account deployment with this method.
-     *
-     * @param {AllowArray<Call>} transactions - Single call or array of calls to execute
-     * @param {UniversalDetails} [transactionsDetail] - Transaction execution options
-     * @param {FastWaitForTransactionOptions} [waitDetail={retries: 50, retryInterval: 500}] - Options to scan the
-     *        network for the next possible transaction. `retries` is the number of times to retry (default: 50),
-     *        `retryInterval` is the time in ms between retries (default: 500).
-     * @returns {Promise<FastExecuteResponse>} Response containing the transaction result and status for the next
-     *          transaction. If `isReady` is true, you can execute the next transaction immediately. If false,
-     *          timeout has been reached before the next transaction was possible.
-     *
-     * @example
-     * ```typescript
-     * const myProvider = new RpcProvider({
-     *   nodeUrl: url,
-     *   blockIdentifier: BlockTag.PRE_CONFIRMED
-     * });
-     * const myAccount = new Account({
-     *   provider: myProvider,
-     *   address: accountAddress0,
-     *   signer: privateKey0
-     * });
-     *
-     * const resp = await myAccount.fastExecute(
-     *   call,
-     *   { tip: recommendedTip },
-     *   { retries: 30, retryInterval: 500 }
-     * );
-     *
-     * // if resp.isReady is true, you can launch immediately a new tx
-     * if (resp.isReady) {
-     *   // send next transaction
-     * }
-     * ```
-     */
-    fastExecute(transactions: any, transactionsDetail?: any, waitDetail?: FastWaitForTransactionOptions): Promise<FastExecuteResponse>;
-}
-
-/**
- * FastExecute plugin - adds gaming-optimized transaction execution
- *
- * Provides fastExecute() on accounts and fastWaitForTransaction() on providers
- * for rapid successive transaction execution with minimal confirmation latency.
- *
- * Requires:
- * - RPC 0.9 or later
- * - Provider initialized with BlockTag.PRE_CONFIRMED
- *
- * @example
- * ```typescript
- * import { RpcProvider, Account } from 'starknet';
- * import { fastExecute } from 'starknet/plugins';
- *
- * const provider = new RpcProvider({
- *   nodeUrl: url,
- *   blockIdentifier: BlockTag.PRE_CONFIRMED,
- * });
- *
- * const account = new Account({ provider, address, signer });
- *
- * const resp = await account.fastExecute(
- *   call,
- *   { tip: recommendedTip },
- *   { retries: 30, retryInterval: 500 }
- * );
- *
- * if (resp.isReady) {
- *   // Next transaction can be sent immediately
- * }
- * ```
- */
-declare function fastExecute(): StarknetPlugin<FastExecuteProviderMethods, FastExecuteAccountMethods>;
-
 /** Default plugins shipped with the SDK */
 declare const defaultPlugins: StarknetPlugin<any, any>[];
 
@@ -9233,6 +9288,7 @@ declare class CairoFixedArray {
      * Cairo fixed array type.
      */
     readonly arrayType: string;
+    private static parseFixedArrayType;
     /**
      * Create an instance representing a Cairo fixed Array.
      * @param {any[]} content JS array representing a Cairo fixed array.