starknet 5.6.1 → 5.8.0

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+# [5.8.0](https://github.com/0xs34n/starknet.js/compare/v5.7.0...v5.8.0) (2023-04-26)
+
+### Bug Fixes
+
+- contract types, interface, cleanup, extend tests ([02c6b72](https://github.com/0xs34n/starknet.js/commit/02c6b72ec41016fdd75537044889e7cffd624b27))
+- contractfactory, contract, interface cleanup cleanup & ts ([b25047e](https://github.com/0xs34n/starknet.js/commit/b25047ece2eed313eaa776b2a132b9a04c3fbc2f))
+- lapsus lingua, dangling, cleanup 🚀 ([a79d55c](https://github.com/0xs34n/starknet.js/commit/a79d55c2990e81bc6b0e58583142d3eb7bbddfa2))
+- prevent missusage of cairoVersion on deploy ([d920dbe](https://github.com/0xs34n/starknet.js/commit/d920dbe6144006438c917727b153a043fec2531b))
+- remove unused cairoVersion from Contract ([e4fcf24](https://github.com/0xs34n/starknet.js/commit/e4fcf244fa1dfd01301addfa7492bf90dac5a854))
+
+### Features
+
+- boolean to felt - cairo 1, compile() ([ef34e0a](https://github.com/0xs34n/starknet.js/commit/ef34e0a25a52be7a6ac76714bda43233a2f1a6f1))
+- remove deprecated compileCalldata ([e5adca4](https://github.com/0xs34n/starknet.js/commit/e5adca449a9d1142339d5e63adb857698c5913d6))
+
+# [5.7.0](https://github.com/0xs34n/starknet.js/compare/v5.6.1...v5.7.0) (2023-04-25)
+
+### Features
+
+- expose more starknetId addresses ([863736e](https://github.com/0xs34n/starknet.js/commit/863736e0d1daf30b9b6c1bab7c5213cda29f3d61))
+
 ## [5.6.1](https://github.com/0xs34n/starknet.js/compare/v5.6.0...v5.6.1) (2023-04-21)
 
 ### Bug Fixes

package/dist/index.d.ts

@@ -206,6 +206,33 @@ declare namespace num {
   };
 }
 
+interface Uint256 {
+    low: BigNumberish;
+    high: BigNumberish;
+}
+declare function uint256ToBN(uint256: Uint256): bigint;
+declare const UINT_128_MAX: bigint;
+declare const UINT_256_MAX: bigint;
+declare function isUint256(bn: BigNumberish): boolean;
+declare function bnToUint256(bignumber: BigNumberish): Uint256;
+
+type uint256$1_Uint256 = Uint256;
+declare const uint256$1_uint256ToBN: typeof uint256ToBN;
+declare const uint256$1_UINT_128_MAX: typeof UINT_128_MAX;
+declare const uint256$1_UINT_256_MAX: typeof UINT_256_MAX;
+declare const uint256$1_isUint256: typeof isUint256;
+declare const uint256$1_bnToUint256: typeof bnToUint256;
+declare namespace uint256$1 {
+  export {
+    uint256$1_Uint256 as Uint256,
+    uint256$1_uint256ToBN as uint256ToBN,
+    uint256$1_UINT_128_MAX as UINT_128_MAX,
+    uint256$1_UINT_256_MAX as UINT_256_MAX,
+    uint256$1_isUint256 as isUint256,
+    uint256$1_bnToUint256 as bnToUint256,
+  };
+}
+
 /** ABI */
 declare type Abi = Array<FunctionAbi | EventAbi | StructAbi>;
 declare type AbiEntry = {
@@ -316,12 +343,12 @@ declare type ArraySignatureType = string[];
 declare type Signature = ArraySignatureType | WeierstrassSignatureType;
 declare type RawCalldata = BigNumberish[];
 declare type AllowArray<T> = T | T[];
-declare type RawArgs = {
-    [inputName: string]: BigNumberish | BigNumberish[] | {
-        type: 'struct';
-        [k: string]: BigNumberish;
-    };
-} | BigNumberish[];
+declare type RawArgs = RawArgsObject | RawArgsArray;
+declare type RawArgsObject = {
+    [inputName: string]: MultiType | MultiType[] | RawArgs;
+};
+declare type RawArgsArray = Array<MultiType | MultiType[] | RawArgs>;
+declare type MultiType = BigNumberish | Uint256 | object | boolean;
 declare type UniversalDeployerContractPayload = {
     classHash: BigNumberish;
     salt?: string;
@@ -457,14 +484,6 @@ interface CallStruct {
     calldata: string[];
 }
 
-declare type Calldata = string[];
-declare type Overrides = {
-    maxFee?: BigNumberish;
-    nonce?: BigNumberish;
-    signature?: Signature;
-    parseRequest?: Boolean;
-};
-
 interface InvocationsSignerDetails extends Required<InvocationsDetails> {
     walletAddress: string;
     chainId: StarknetChainId;
@@ -483,13 +502,32 @@ declare type DeployAccountSignerDetails = Required<DeployAccountContractPayload>
     chainId: StarknetChainId;
 };
 
-declare type AsyncContractFunction<T = any> = (...args: Array<any>) => Promise<T>;
-declare type ContractFunction = (...args: Array<any>) => any;
+declare type BlockIdentifier = BlockNumber | BigNumberish;
+
+declare type AsyncContractFunction<T = any> = (...args: ArgsOrCalldataWithOptions) => Promise<T>;
+declare type ContractFunction = (...args: ArgsOrCalldataWithOptions) => any;
 declare type Result = {
     [key: string]: any;
 } | Result[] | bigint | string | boolean;
-
-declare type BlockIdentifier = BlockNumber | BigNumberish;
+declare type Calldata = string[] & {
+    readonly __compiled__?: boolean;
+};
+declare type ArgsOrCalldata = RawArgsArray | [Calldata] | Calldata;
+declare type ArgsOrCalldataWithOptions = ArgsOrCalldata & ContractOptions;
+declare type ContractOptions = {
+    blockIdentifier?: BlockIdentifier;
+    parseRequest?: boolean;
+    parseResponse?: boolean;
+    formatResponse?: {
+        [key: string]: any;
+    };
+    maxFee?: BigNumberish;
+    nonce?: BigNumberish;
+    signature?: Signature;
+    addressSalt?: string;
+};
+declare type CallOptions = Pick<ContractOptions, 'blockIdentifier' | 'parseRequest' | 'parseResponse' | 'formatResponse'>;
+declare type InvokeOptions = Pick<ContractOptions, 'maxFee' | 'nonce' | 'signature' | 'parseRequest'>;
 
 /**
  * Starknet RPC version 0.2.1
@@ -1609,6 +1647,7 @@ interface EstimateFeeResponse {
     overall_fee: bigint;
     gas_consumed?: bigint;
     gas_price?: bigint;
+    suggestedMaxFee?: bigint;
 }
 interface InvokeFunctionResponse {
     transaction_hash: string;
@@ -2624,12 +2663,6 @@ declare class Account extends Provider implements AccountInterface {
     StarknetIdContract?: string): Promise<string>;
 }
 
-declare type CallOptions = {
-    blockIdentifier?: BlockIdentifier;
-    parseRequest: Boolean;
-    parseResponse: Boolean;
-    formatResponse?: object | null;
-};
 declare abstract class ContractInterface {
     abstract abi: Abi;
     abstract address: string;
@@ -2675,36 +2708,47 @@ declare abstract class ContractInterface {
      * @param options optional blockIdentifier
      * @returns Result of the call as an array with key value pars
      */
-    abstract call(method: string, args?: Array<any>, options?: CallOptions): Promise<Object>;
+    abstract call(method: string, args?: ArgsOrCalldata, options?: CallOptions): Promise<Result>;
     /**
      * Invokes a method on a contract
      *
      * @param method name of the method
-     * @param args Array of the arguments for the invoke
+     * @param args Array of the arguments for the invoke or Calldata
      * @param options
      * @returns Add Transaction Response
      */
-    abstract invoke(method: string, args?: Array<any>, options?: Overrides): Promise<InvokeFunctionResponse>;
+    abstract invoke(method: string, args?: ArgsOrCalldata, options?: InvokeOptions): Promise<InvokeFunctionResponse>;
     /**
      * Estimates a method on a contract
      *
      * @param method name of the method
-     * @param args Array of the arguments for the call
+     * @param args Array of the arguments for the call or Calldata
      * @param options optional blockIdentifier
      */
-    abstract estimate(method: string, args?: Array<any>, options?: {
+    abstract estimate(method: string, args?: ArgsOrCalldata, options?: {
         blockIdentifier?: BlockIdentifier;
-    }): Promise<any>;
+    }): Promise<EstimateFeeResponse>;
     /**
      * Calls a method on a contract
      *
      * @param method name of the method
-     * @param args Array of the arguments for the call
+     * @param args Array of the arguments for the call or Calldata
      * @returns Invocation object
      */
-    abstract populate(method: string, args?: Array<any>): Invocation;
+    abstract populate(method: string, args?: ArgsOrCalldata): Invocation;
 }
 
+declare const splitArgsAndOptions: (args: ArgsOrCalldataWithOptions) => {
+    args: ArgsOrCalldata;
+    options: ContractOptions;
+} | {
+    args: ArgsOrCalldata;
+    options?: undefined;
+};
+declare function getCalldata(args: ArgsOrCalldata, callback: Function): Calldata;
+/**
+ * Not used at the moment
+ */
 declare class Contract implements ContractInterface {
     abi: Abi;
     address: string;
@@ -2727,23 +2771,21 @@ declare class Contract implements ContractInterface {
     };
     readonly [key: string]: AsyncContractFunction | any;
     private callData;
-    private version;
     /**
      * Contract class to handle contract methods
      *
      * @param abi - Abi of the contract object
      * @param address (optional) - address to connect to
      * @param providerOrAccount (optional) - Provider or Account to attach to
-     * @param cairoVersion (optional) - default '0', for Cairo 1 set '1'
      */
-    constructor(abi: Abi, address: string, providerOrAccount?: ProviderInterface | AccountInterface, cairoVersion?: string);
+    constructor(abi: Abi, address: string, providerOrAccount?: ProviderInterface | AccountInterface);
     attach(address: string): void;
     connect(providerOrAccount: ProviderInterface | AccountInterface): void;
     deployed(): Promise<Contract>;
-    call(method: string, args?: Array<any>, options?: CallOptions): Promise<Result>;
-    invoke(method: string, args?: Array<any>, options?: Overrides): Promise<InvokeFunctionResponse>;
-    estimate(method: string, args?: Array<any>): Promise<EstimateFeeResponse>;
-    populate(method: string, args?: Array<any>): Call;
+    call(method: string, args?: ArgsOrCalldata, { parseRequest, parseResponse, formatResponse, blockIdentifier, }?: CallOptions): Promise<Result>;
+    invoke(method: string, args?: ArgsOrCalldata, { parseRequest, maxFee, nonce, signature }?: InvokeOptions): Promise<InvokeFunctionResponse>;
+    estimate(method: string, args?: ArgsOrCalldata): Promise<EstimateFeeResponse>;
+    populate(method: string, args?: ArgsOrCalldata): Call;
 }
 
 declare class ContractFactory {
@@ -2751,7 +2793,7 @@ declare class ContractFactory {
     compiledContract: CompiledContract;
     classHash: string;
     account: AccountInterface;
-    private callData;
+    private CallData;
     constructor(compiledContract: CompiledContract, classHash: string, account: AccountInterface, abi?: Abi);
     /**
      * Deploys contract and returns new instance of the Contract
@@ -2760,16 +2802,16 @@ declare class ContractFactory {
      * @param options (optional) Object - parseRequest, parseResponse, addressSalt
      * @returns deployed Contract
      */
-    deploy(...args: Array<any>): Promise<Contract>;
+    deploy(...args: ArgsOrCalldataWithOptions): Promise<Contract>;
     /**
-     * Attaches to new Provider or Account
+     * Attaches to new Account
      *
      * @param account - new Provider or Account to attach to
      * @returns ContractFactory
      */
     connect(account: AccountInterface): ContractFactory;
     /**
-     * Attaches current abi and provider or account to the new address
+     * Attaches current abi and account to the new address
      *
      * @param address - Contract address
      * @returns Contract
@@ -2957,10 +2999,6 @@ declare function makeAddress(input: string): string;
 declare function formatSignature(sig?: Signature): ArraySignatureType;
 declare function signatureToDecimalArray(sig?: Signature): ArraySignatureType;
 declare function signatureToHexArray(sig?: Signature): ArraySignatureType;
-/**
- * @deprecated this function is deprecated use callData instead from calldata.ts
- */
-declare function compileCalldata(args: RawArgs): Calldata;
 declare function estimatedFeeToMaxFee(estimatedFee: BigNumberish, overhead?: number): bigint;
 
 declare const stark_compressProgram: typeof compressProgram;
@@ -2969,7 +3007,6 @@ declare const stark_makeAddress: typeof makeAddress;
 declare const stark_formatSignature: typeof formatSignature;
 declare const stark_signatureToDecimalArray: typeof signatureToDecimalArray;
 declare const stark_signatureToHexArray: typeof signatureToHexArray;
-declare const stark_compileCalldata: typeof compileCalldata;
 declare const stark_estimatedFeeToMaxFee: typeof estimatedFeeToMaxFee;
 declare namespace stark {
   export {
@@ -2979,7 +3016,6 @@ declare namespace stark {
     stark_formatSignature as formatSignature,
     stark_signatureToDecimalArray as signatureToDecimalArray,
     stark_signatureToHexArray as signatureToHexArray,
-    stark_compileCalldata as compileCalldata,
     stark_estimatedFeeToMaxFee as estimatedFeeToMaxFee,
   };
 }
@@ -3005,33 +3041,6 @@ declare namespace merkle {
   };
 }
 
-interface Uint256 {
-    low: BigNumberish;
-    high: BigNumberish;
-}
-declare function uint256ToBN(uint256: Uint256): bigint;
-declare const UINT_128_MAX: bigint;
-declare const UINT_256_MAX: bigint;
-declare function isUint256(bn: BigNumberish): boolean;
-declare function bnToUint256(bignumber: BigNumberish): Uint256;
-
-type uint256$1_Uint256 = Uint256;
-declare const uint256$1_uint256ToBN: typeof uint256ToBN;
-declare const uint256$1_UINT_128_MAX: typeof UINT_128_MAX;
-declare const uint256$1_UINT_256_MAX: typeof UINT_256_MAX;
-declare const uint256$1_isUint256: typeof isUint256;
-declare const uint256$1_bnToUint256: typeof bnToUint256;
-declare namespace uint256$1 {
-  export {
-    uint256$1_Uint256 as Uint256,
-    uint256$1_uint256ToBN as uint256ToBN,
-    uint256$1_UINT_128_MAX as UINT_128_MAX,
-    uint256$1_UINT_256_MAX as UINT_256_MAX,
-    uint256$1_isUint256 as isUint256,
-    uint256$1_bnToUint256 as bnToUint256,
-  };
-}
-
 declare function isASCII(str: string): boolean;
 declare function isShortString(str: string): boolean;
 declare function isDecimalString(decim: string): boolean;
@@ -3093,6 +3102,28 @@ declare namespace shortString {
   };
 }
 
+declare function useDecoded(encoded: bigint[]): string;
+declare function useEncoded(decoded: string): bigint;
+declare const enum StarknetIdContract {
+    MAINNET = "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678",
+    TESTNET = "0x3bab268e932d2cecd1946f100ae67ce3dff9fd234119ea2f6da57d16d29fce"
+}
+declare function getStarknetIdContract(chainId: StarknetChainId): string;
+
+declare const starknetId_useDecoded: typeof useDecoded;
+declare const starknetId_useEncoded: typeof useEncoded;
+type starknetId_StarknetIdContract = StarknetIdContract;
+declare const starknetId_StarknetIdContract: typeof StarknetIdContract;
+declare const starknetId_getStarknetIdContract: typeof getStarknetIdContract;
+declare namespace starknetId {
+  export {
+    starknetId_useDecoded as useDecoded,
+    starknetId_useEncoded as useEncoded,
+    starknetId_StarknetIdContract as StarknetIdContract,
+    starknetId_getStarknetIdContract as getStarknetIdContract,
+  };
+}
+
 declare function addAddressPadding(address: BigNumberish): string;
 declare function validateAndParseAddress(address: BigNumberish): string;
 declare function getChecksumAddress(address: BigNumberish): string;
@@ -3241,44 +3272,53 @@ declare class CallData {
     protected readonly structs: AbiStructs;
     constructor(abi: Abi);
     /**
-     * Validates if all arguments that are passed to the method are corresponding to the ones in the abi
-     *
-     * @param type - type of the method
-     * @param method  - name of the method
-     * @param args - arguments that are passed to the method
+     * Validate arguments passed to the method as corresponding to the ones in the abi
+     * @param type string - type of the method
+     * @param method string - name of the method
+     * @param args ArgsOrCalldata - arguments that are passed to the method
      */
-    validate(type: 'INVOKE' | 'CALL' | 'DEPLOY', method: string, args?: Array<any>): void;
+    validate(type: 'INVOKE' | 'CALL' | 'DEPLOY', method: string, args?: ArgsOrCalldata): void;
     /**
+     * Compile contract callData with abi
      * Parse the calldata by using input fields from the abi for that method
-     *
-     * @param args - arguments passed the the method
-     * @param inputs  - list of inputs(fields) that are in the abi
-     * @return {Calldata} - parsed arguments in format that contract is expecting
+     * @param method string - method name
+     * @param args ArgsOrCalldata - arguments passed to the method
+     * @return Calldata - parsed arguments in format that contract is expecting
      */
-    compile(args: Array<any>, inputs: AbiEntry[]): Calldata;
+    compile(method: string, args: ArgsOrCalldata): Calldata;
     /**
      * Compile contract callData without abi
-     * @param data Object representing cairo method arguments or string array of compiled data
-     * @returns string[]
+     * @param rawArgs RawArgs representing cairo method arguments or string array of compiled data
+     * @returns Calldata
      */
-    static compile(data: object | string[]): Calldata;
+    static compile(rawArgs: RawArgs): Calldata;
     /**
      * Parse elements of the response array and structuring them into response object
-     * @param method - method name
-     * @param response  - response from the method
-     * @return - parsed response corresponding to the abi
+     * @param method string - method name
+     * @param response string[] - response from the method
+     * @return Result - parsed response corresponding to the abi
      */
     parse(method: string, response: string[]): Result;
     /**
      * Format cairo method response data to native js values based on provided format schema
-     * @param method - cairo method name
-     * @param response - cairo method response
-     * @param format - formatter object schema
-     * @returns parsed and formatted response object
+     * @param method string - cairo method name
+     * @param response string[] - cairo method response
+     * @param format object - formatter object schema
+     * @returns Result - parsed and formatted response object
+     */
+    format(method: string, response: string[], format: object): Result;
+    /**
+     * Helper to calculate inputs from abi
+     * @param inputs AbiEntry
+     * @returns number
      */
-    format(method: string, response: string[], format: object): object;
     static abiInputsLength(inputs: AbiEntry[]): number;
-    static getAbiStruct(abi: Abi): any;
+    /**
+     * Helper to extract structs from abi
+     * @param abi Abi
+     * @returns AbiStructs - structs from abi
+     */
+    static getAbiStruct(abi: Abi): AbiStructs;
 }
 
 /**
@@ -3288,4 +3328,4 @@ declare class CallData {
 /** @deprecated prefer the 'num' naming */
 declare const number: typeof num;
 
-export { Abi, AbiEntry, AbiStructs, Account, AccountInterface, AllowArray, Args, ArraySignatureType, AsyncContractFunction, BlockNumber, BlockTag, Builtins, ByteCode, CairoAssembly, CairoContract, CairoVersion, Call, CallContractResponse, CallData, CallDetails, CallL1Handler, CallOptions, CallStruct, Calldata, CommonTransactionReceiptResponse, CommonTransactionResponse, CompiledContract, CompiledSierra, CompiledSierraCasm, CompleteDeclareContractPayload, CompressedProgram, Contract, ContractClass, ContractEntryPoint, ContractEntryPointFields, ContractFactory, ContractFunction, ContractInterface, CustomError, DeclareAndDeployContractPayload, DeclareContractPayload, DeclareContractResponse, DeclareContractTransaction, DeclareDeployUDCResponse, DeclareSignerDetails, DeclareTransactionReceiptResponse, DeclareTransactionResponse, DeployAccountContractPayload, DeployAccountContractTransaction, DeployAccountSignerDetails, DeployContractPayload, DeployContractResponse, DeployContractUDCResponse, DeployedContractItem, Details, EntryPointType, EntryPointsByType, EstimateFee, EstimateFeeAction, EstimateFeeBulk, EstimateFeeDetails, EstimateFeeResponse, EstimateFeeResponseBulk, Event, ExecutionResources, FunctionAbi, FunctionInvocation, GatewayError, GetBlockResponse, GetCodeResponse, GetContractAddressesResponse, GetTransactionReceiptResponse, GetTransactionResponse, GetTransactionStatusResponse, HttpError, Invocation, InvocationBulk, InvocationsDetails, InvocationsDetailsWithNonce, InvocationsSignerDetails, InvokeFunctionResponse, InvokeTransactionReceiptResponse, InvokeTransactionResponse, LegacyCompiledContract, LegacyContractClass, LibraryError, MessageToL1, MessageToL2, MultiDeployContractResponse, Nonce, Overrides, ParsedStruct, Program, Provider, ProviderInterface, ProviderOptions, PythonicHints, RPC, RawArgs, RawCalldata, Result, RpcProvider, RpcProviderOptions, Sequencer, SequencerHttpMethod, SequencerIdentifier, SequencerProvider, SequencerProviderOptions, SierraContractClass, SierraContractEntryPointFields, SierraEntryPointsByType, SierraProgramDebugInfo, Signature, Signer, SignerInterface, StateUpdateResponse, Status, Storage, Struct, StructAbi, TransactionBulk, TransactionSimulation, TransactionSimulationResponse, TransactionStatus, TransactionTraceResponse, TransactionType, Tupled, UniversalDeployerContractPayload, WeierstrassSignatureType, addAddressPadding, buildUrl, cairo, constants, defaultProvider, ec, encode, fixProto, fixStack, getChecksumAddress, hash, isUrl, json, merkle, num, number, shortString, stark, transaction, index as typedData, uint256$1 as uint256, validateAndParseAddress, validateChecksumAddress, waitForTransactionOptions };
+export { Abi, AbiEntry, AbiStructs, Account, AccountInterface, AllowArray, Args, ArgsOrCalldata, ArgsOrCalldataWithOptions, ArraySignatureType, AsyncContractFunction, BlockNumber, BlockTag, Builtins, ByteCode, CairoAssembly, CairoContract, CairoVersion, Call, CallContractResponse, CallData, CallDetails, CallL1Handler, CallOptions, CallStruct, Calldata, CommonTransactionReceiptResponse, CommonTransactionResponse, CompiledContract, CompiledSierra, CompiledSierraCasm, CompleteDeclareContractPayload, CompressedProgram, Contract, ContractClass, ContractEntryPoint, ContractEntryPointFields, ContractFactory, ContractFunction, ContractInterface, ContractOptions, CustomError, DeclareAndDeployContractPayload, DeclareContractPayload, DeclareContractResponse, DeclareContractTransaction, DeclareDeployUDCResponse, DeclareSignerDetails, DeclareTransactionReceiptResponse, DeclareTransactionResponse, DeployAccountContractPayload, DeployAccountContractTransaction, DeployAccountSignerDetails, DeployContractPayload, DeployContractResponse, DeployContractUDCResponse, DeployedContractItem, Details, EntryPointType, EntryPointsByType, EstimateFee, EstimateFeeAction, EstimateFeeBulk, EstimateFeeDetails, EstimateFeeResponse, EstimateFeeResponseBulk, Event, ExecutionResources, FunctionAbi, FunctionInvocation, GatewayError, GetBlockResponse, GetCodeResponse, GetContractAddressesResponse, GetTransactionReceiptResponse, GetTransactionResponse, GetTransactionStatusResponse, HttpError, Invocation, InvocationBulk, InvocationsDetails, InvocationsDetailsWithNonce, InvocationsSignerDetails, InvokeFunctionResponse, InvokeOptions, InvokeTransactionReceiptResponse, InvokeTransactionResponse, LegacyCompiledContract, LegacyContractClass, LibraryError, MessageToL1, MessageToL2, MultiDeployContractResponse, MultiType, Nonce, ParsedStruct, Program, Provider, ProviderInterface, ProviderOptions, PythonicHints, RPC, RawArgs, RawArgsArray, RawArgsObject, RawCalldata, Result, RpcProvider, RpcProviderOptions, Sequencer, SequencerHttpMethod, SequencerIdentifier, SequencerProvider, SequencerProviderOptions, SierraContractClass, SierraContractEntryPointFields, SierraEntryPointsByType, SierraProgramDebugInfo, Signature, Signer, SignerInterface, StateUpdateResponse, Status, Storage, Struct, StructAbi, TransactionBulk, TransactionSimulation, TransactionSimulationResponse, TransactionStatus, TransactionTraceResponse, TransactionType, Tupled, UniversalDeployerContractPayload, WeierstrassSignatureType, addAddressPadding, buildUrl, cairo, constants, defaultProvider, ec, encode, fixProto, fixStack, getCalldata, getChecksumAddress, hash, isUrl, json, merkle, num, number, shortString, splitArgsAndOptions, stark, starknetId, transaction, index as typedData, uint256$1 as uint256, validateAndParseAddress, validateChecksumAddress, waitForTransactionOptions };