@taquito/taquito 23.0.3 → 24.0.0-RC.0

package/dist/taquito.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"taquito.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"taquito.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/batch/constants.d.ts

@@ -0,0 +1,3 @@
+import { OpKind } from '@taquito/rpc';
+export declare const BATCH_KINDS: OpKind[];
+export type BatchKinds = OpKind.ACTIVATION | OpKind.ORIGINATION | OpKind.TRANSACTION | OpKind.DELEGATION | OpKind.REGISTER_GLOBAL_CONSTANT | OpKind.INCREASE_PAID_STORAGE | OpKind.TRANSFER_TICKET | OpKind.SMART_ROLLUP_ADD_MESSAGES | OpKind.SMART_ROLLUP_ORIGINATE | OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE;

package/dist/types/batch/rpc-batch-provider.d.ts

@@ -1,16 +1,13 @@
 import { Context } from '../context';
 import { ContractStorageType, DefaultContractType } from '../contract/contract';
-import { ContractMethod } from '../contract/contract-methods/contract-method-flat-param';
 import { SendParams } from '../contract/contract-methods/contract-method-interface';
 import { ContractProvider } from '../contract/interface';
 import { BatchOperation } from '../operations/batch-operation';
 import { ActivationParams, DelegateParams, OriginateParams, TransferParams, ParamsWithKind, RegisterGlobalConstantParams, TransferTicketParams, IncreasePaidStorageParams, SmartRollupAddMessagesParams, SmartRollupOriginateParams, SmartRollupExecuteOutboxMessageParams, UpdateConsensusKeyParams, UpdateCompanionKeyParams } from '../operations/types';
-import { OpKind } from '@taquito/rpc';
 import { ContractMethodObject } from '../contract/contract-methods/contract-method-object-param';
 import { EstimationProvider } from '../estimate/estimate-provider-interface';
 import { Provider } from '../provider';
-export declare const BATCH_KINDS: OpKind[];
-export type BatchKinds = OpKind.ACTIVATION | OpKind.ORIGINATION | OpKind.TRANSACTION | OpKind.DELEGATION;
+export { BATCH_KINDS, BatchKinds } from './constants';
 export declare class OperationBatch extends Provider {
     private estimator;
     private operations;
@@ -37,7 +34,7 @@ export declare class OperationBatch extends Provider {
      * @param params Call a contract method
      * @param options Generic operation parameters
      */
-    withContractCall(params: ContractMethod<ContractProvider> | ContractMethodObject<ContractProvider>, options?: Partial<SendParams>): this;
+    withContractCall(params: ContractMethodObject<ContractProvider>, options?: Partial<SendParams>): this;
     /**
      *
      * @description Add a delegation operation to the batch

package/dist/types/constants.d.ts

@@ -1,33 +1,3 @@
-/**
- * @deprecated default reveal gasLimit please use getRevealGasLimit(address) instead, removing hardcoded gasLimit of delegation, origination and transfer
- */
-export declare const DEFAULT_GAS_LIMIT: {
-    DELEGATION: number;
-    ORIGINATION: number;
-    TRANSFER: number;
-    REVEAL_TZ1: number;
-    REVEAL_TZ2: number;
-    REVEAL_TZ3: number;
-    REVEAL_TZ4: number;
-};
-/**
- * @deprecated default reveal fee please use getRevealFee(address) instead, removing hardcoded fee of delegation, origination and transfer
- */
-export declare const DEFAULT_FEE: {
-    DELEGATION: number;
-    ORIGINATION: number;
-    TRANSFER: number;
-    REVEAL: number;
-};
-/**
- * @deprecated default reveal storageLimit please use REVEAL_STORAGE_LIMIT instead, removing hardcoded storageLimit of delegation, origination and transfer
- */
-export declare const DEFAULT_STORAGE_LIMIT: {
-    DELEGATION: number;
-    ORIGINATION: number;
-    TRANSFER: number;
-    REVEAL: number;
-};
 export declare const REVEAL_STORAGE_LIMIT = 0;
 export declare const ORIGINATION_SIZE = 257;
 export declare const COST_PER_BYTE = 250;
@@ -55,6 +25,7 @@ export declare enum Protocols {
     PsQuebecn = "PsQuebecnLByd3JwTiGadoG4nGWi3HYiLXUjkibeFV8dCFeVMUg",
     PsRiotuma = "PsRiotumaAMotcRoDWW1bysEhQy2n1M5fy8JgRp8jjRfHGmfeA7",
     PtSeouLou = "PtSeouLouXkxhg39oWzjxDWaCydNfR3RxCUrNe4Q9Ro8BTehcbh",
+    PtTALLiNt = "PtTALLiNtPec7mE7yY4m3k26J8Qukef3E3ehzhfXgFZKGtDdAXu",
     ProtoALpha = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK"
 }
 export declare const protocols: {
@@ -78,6 +49,7 @@ export declare const protocols: {
     '022': Protocols[];
     '023': Protocols[];
     '024': Protocols[];
+    '025': Protocols[];
 };
 export declare enum ChainIds {
     MAINNET = "NetXdQprcVkpaWU",
@@ -101,7 +73,8 @@ export declare enum ChainIds {
     PARISCNET = "NetXXWAHLEvre9b",
     QUEBECNET = "NetXuTeGinLEqxp",
     RIONET = "NetXPdgaoabtBth",
-    SEOULNET = "NetXd56aBs1aeW3"
+    SEOULNET = "NetXd56aBs1aeW3",
+    TALLINNNET = "NetXe8DbhW9A1eS"
 }
 export declare const getRevealGasLimit: (address: string) => number;
 export declare const getRevealFee: (address: string) => number;

package/dist/types/contract/constants.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_SMART_CONTRACT_METHOD_NAME = "default";

package/dist/types/contract/contract-methods/contract-method-factory.d.ts

@@ -1,7 +1,6 @@
-import { Wallet } from '../../wallet';
-import { ContractProvider } from '../../contract';
+import type { Wallet } from '../../wallet/wallet';
+import { ContractProvider } from '../interface';
 import { ContractMethodObject } from './contract-method-object-param';
-import { ContractMethod } from './contract-method-flat-param';
 import { ParameterSchema, ViewSchema } from '@taquito/michelson-encoder';
 import { RpcClientInterface, MichelsonV1Expression } from '@taquito/rpc';
 import { OnChainView } from './contract-on-chain-view';
@@ -10,7 +9,6 @@ export declare class ContractMethodFactory<T extends ContractProvider | Wallet>
     private provider;
     private contractAddress;
     constructor(provider: T, contractAddress: string);
-    createContractMethodFlatParams(smartContractMethodSchema: ParameterSchema, smartContractMethodName: string, args: any[], isMultipleEntrypoint?: boolean, isAnonymous?: boolean): ContractMethod<T>;
     createContractMethodObjectParam(smartContractMethodSchema: ParameterSchema, smartContractMethodName: string, args: any[], isMultipleEntrypoint?: boolean, isAnonymous?: boolean): ContractMethodObject<T>;
     createContractViewObjectParam(rpc: RpcClientInterface, readProvider: TzReadProvider, smartContractViewSchema: ViewSchema, contractStorageType: MichelsonV1Expression, viewArgs: any): OnChainView;
 }

package/dist/types/contract/contract-methods/contract-method-object-param.d.ts

@@ -1,8 +1,9 @@
 import { TransactionOperation } from '../../operations/transaction-operation';
 import { TransferParams } from '../../operations/types';
 import { ContractProvider } from '../interface';
-import { TransactionWalletOperation, Wallet } from '../../wallet';
-import { ParameterSchema } from "@taquito/michelson-encoder";
+import type { Wallet } from '../../wallet/wallet';
+import { TransactionWalletOperation } from '../../wallet/transaction-operation';
+import { ParameterSchema } from '@taquito/michelson-encoder';
 import { ContractMethodInterface, SendParams } from './contract-method-interface';
 /**
  * @description Utility class to send smart contract operation
@@ -20,7 +21,7 @@ export declare class ContractMethodObject<T extends ContractProvider | Wallet> i
     /**
      * @description Get the signature of the smart contract method
      */
-    getSignature(): any;
+    getSignature(): unknown;
     /**
      *
      * @description Send the smart contract operation

package/dist/types/contract/contract-methods/contract-on-chain-view.d.ts

@@ -17,8 +17,8 @@ export declare class OnChainView {
      * @description Get the signature of the smart contract view
      */
     getSignature(): {
-        parameter: any;
-        result: any;
+        parameter: import("@taquito/michelson-encoder").TokenSchema;
+        result: import("@taquito/michelson-encoder").TokenSchema;
     };
     /**
      * @description Get the result of the view simulation

package/dist/types/contract/contract.d.ts

@@ -2,12 +2,12 @@ import { ParameterSchema, Schema, ViewSchema, EventSchema } from '@taquito/miche
 import { EntrypointsResponse, RpcClientInterface, ScriptResponse } from '@taquito/rpc';
 import { ChainIds } from '../constants';
 import { TzReadProvider } from '../read-provider/interface';
-import { Wallet } from '../wallet';
-import { ContractMethod } from './contract-methods/contract-method-flat-param';
+import type { Wallet } from '../wallet/wallet';
 import { ContractMethodObject } from './contract-methods/contract-method-object-param';
 import { OnChainView } from './contract-methods/contract-on-chain-view';
 import { ContractProvider, StorageProvider } from './interface';
-export declare const DEFAULT_SMART_CONTRACT_METHOD_NAME = "default";
+import { DEFAULT_SMART_CONTRACT_METHOD_NAME } from './constants';
+export { DEFAULT_SMART_CONTRACT_METHOD_NAME };
 /**
  * @description Utility class to retrieve data from a smart contract's storage without incurring fees via a contract's view method
  */
@@ -24,7 +24,6 @@ export declare class ContractView {
 }
 export type Contract = ContractAbstraction<ContractProvider>;
 export type WalletContract = ContractAbstraction<Wallet>;
-type DefaultMethods<T extends ContractProvider | Wallet> = Record<string, (...args: any[]) => ContractMethod<T>>;
 type DefaultMethodsObject<T extends ContractProvider | Wallet> = Record<string, (args?: any) => ContractMethodObject<T>>;
 type DefaultViews = Record<string, (...args: any[]) => ContractView>;
 type DefaultContractViews = Record<string, (args?: any) => OnChainView>;
@@ -36,7 +35,7 @@ export type DefaultWalletType = ContractAbstraction<Wallet>;
 /**
  * @description Smart contract abstraction
  */
-export declare class ContractAbstraction<T extends ContractProvider | Wallet, TMethods extends DefaultMethods<T> = DefaultMethods<T>, TMethodsObject extends DefaultMethodsObject<T> = DefaultMethodsObject<T>, TViews extends DefaultViews = DefaultViews, TContractViews extends DefaultContractViews = DefaultContractViews, TStorage extends DefaultStorage = DefaultStorage> {
+export declare class ContractAbstraction<T extends ContractProvider | Wallet, TMethodsObject extends DefaultMethodsObject<T> = DefaultMethodsObject<T>, TViews extends DefaultViews = DefaultViews, TContractViews extends DefaultContractViews = DefaultContractViews, TStorage extends DefaultStorage = DefaultStorage> {
     readonly address: string;
     readonly script: ScriptResponse;
     private storageProvider;
@@ -44,12 +43,6 @@ export declare class ContractAbstraction<T extends ContractProvider | Wallet, TM
     private rpc;
     private readProvider;
     private contractMethodFactory;
-    /**
-     * @deprecated use methodsObject instead, flat params of methods can't sufficiently represent all Michelson values
-     * @description Contains methods that are implemented by the target Tezos Smart Contract, and offers the user to call the Smart Contract methods as if they were native TS/JS methods.
-     * NB: if the contract contains annotation it will include named properties; if not it will be indexed by a number.
-     */
-    methods: TMethods;
     /**
      * @description Contains methods that are implemented by the target Tezos Smart Contract, and offers the user to call the Smart Contract methods as if they were native TS/JS methods.
      * `methodsObject` serves the exact same purpose as the `methods` member. The difference is that it allows passing the parameter in an object format when calling the smart contract method (instead of the flattened representation)
@@ -79,16 +72,4 @@ export declare class ContractAbstraction<T extends ContractProvider | Wallet, TM
      * @description Return a friendly representation of the smart contract storage
      */
     storage<T extends TStorage = TStorage>(): Promise<T>;
-    /**
-     *
-     * @description Return a friendly representation of the smart contract big map value
-     *
-     * @param key BigMap key to fetch
-     *
-     * @deprecated getBigMapKey has been deprecated in favor of getBigMapKeyByID
-     *
-     * @see https://tezos.gitlab.io/api/rpc.html#post-block-id-context-contracts-contract-id-big-map-get
-     */
-    bigMap(key: string): Promise<unknown>;
 }
-export {};

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

@@ -6,7 +6,6 @@ export * from './prepare';
 export * from './view_lambda';
 export { compose } from './compose';
 export * from './contract-methods/contract-method-interface';
-export * from './contract-methods/contract-method-flat-param';
 export * from './contract-methods/contract-method-object-param';
 export * from './sapling-state-abstraction';
 export { smartContractAbstractionSemantic } from './semantic';

package/dist/types/contract/interface.d.ts

@@ -32,19 +32,6 @@ export interface StorageProvider {
      * @see https://tezos.gitlab.io/api/rpc.html#get-block-id-context-contracts-contract-id-script
      */
     getStorage<T>(contract: string, schema?: ContractSchema): Promise<T>;
-    /**
-     *
-     * @description Return a well formatted json object of the contract big map storage
-     *
-     * @param contract contract address you want to get the storage from
-     * @param key contract big map key to fetch value from
-     * @param schema optional schema can either be the contract script rpc response or a michelson-encoder schema
-     *
-     * @deprecated Deprecated in favor of getBigMapKeyByID
-     *
-     * @see https://tezos.gitlab.io/api/rpc.html#post-block-id-context-contracts-contract-id-big-map-get
-     */
-    getBigMapKey<T>(contract: string, key: string, schema?: ContractSchema): Promise<T>;
     /**
      *
      * @description Return a well formatted json object of a big map value

package/dist/types/contract/rpc-contract-provider.d.ts

@@ -37,19 +37,6 @@ export declare class RpcContractProvider extends Provider implements ContractPro
      * @see https://tezos.gitlab.io/api/rpc.html#get-block-id-context-contracts-contract-id-script
      */
     getStorage<T>(contract: string, schema?: ContractSchema): Promise<T>;
-    /**
-     *
-     * @description Return a well formatted json object of the contract big map storage
-     *
-     * @param contract contract address you want to get the storage from
-     * @param key contract big map key to fetch value from
-     * @param schema optional schema can either be the contract script rpc response or a michelson-encoder schema
-     * @throws {@link InvalidContractAddressError}
-     * @deprecated Deprecated in favor of getBigMapKeyByID
-     *
-     * @see https://tezos.gitlab.io/api/rpc.html#post-block-id-context-contracts-contract-id-big-map-get
-     */
-    getBigMapKey<T>(contract: string, key: string, schema?: ContractSchema): Promise<T>;
     /**
      *
      * @description Return a well formatted json object of a big map value

package/dist/types/estimate/estimate-provider-interface.d.ts

@@ -1,7 +1,7 @@
 import { OriginateParams, TransferParams, DelegateParams, RegisterDelegateParams, ParamsWithKind } from '../operations';
 import { RevealParams, RegisterGlobalConstantParams, TransferTicketParams, IncreasePaidStorageParams, UpdateConsensusKeyParams, UpdateCompanionKeyParams, SmartRollupAddMessagesParams, SmartRollupOriginateParams, SmartRollupExecuteOutboxMessageParams, StakeParams, UnstakeParams, FinalizeUnstakeParams } from '../operations/types';
 import { Estimate } from './estimate';
-import { ContractMethod, ContractMethodObject, ContractProvider } from '../contract';
+import { ContractMethodObject, ContractProvider } from '../contract';
 export interface EstimationProvider {
     /**
      *
@@ -144,7 +144,7 @@ export interface EstimationProvider {
      *
      * @param Estimate
      */
-    contractCall(contractMethod: ContractMethod<ContractProvider> | ContractMethodObject<ContractProvider>): Promise<Estimate>;
+    contractCall(contractMethod: ContractMethodObject<ContractProvider>): Promise<Estimate>;
     /**
      * @description Estimate gasLimit, storageLimit and fees for an Smart Rollup Originate operation
      *

package/dist/types/estimate/rpc-estimate-provider.d.ts

@@ -1,7 +1,7 @@
 import { DelegateParams, OriginateParams, ParamsWithKind, RegisterDelegateParams, TransferParams, RevealParams, RegisterGlobalConstantParams, TransferTicketParams, IncreasePaidStorageParams, UpdateConsensusKeyParams, UpdateCompanionKeyParams, SmartRollupAddMessagesParams, SmartRollupOriginateParams, SmartRollupExecuteOutboxMessageParams, StakeParams, UnstakeParams, FinalizeUnstakeParams } from '../operations/types';
 import { Estimate } from './estimate';
 import { EstimationProvider } from '../estimate/estimate-provider-interface';
-import { ContractMethod, ContractMethodObject, ContractProvider } from '../contract';
+import { ContractMethodObject, ContractProvider } from '../contract';
 import { Provider } from '../provider';
 export declare class RPCEstimateProvider extends Provider implements EstimationProvider {
     private readonly REVEAL_LENGTH;
@@ -166,5 +166,5 @@ export declare class RPCEstimateProvider extends Provider implements EstimationP
      *
      * @param Estimate
      */
-    contractCall(contractMethod: ContractMethod<ContractProvider> | ContractMethodObject<ContractProvider>): Promise<Estimate>;
+    contractCall(contractMethod: ContractMethodObject<ContractProvider>): Promise<Estimate>;
 }

package/dist/types/import-key.d.ts

@@ -0,0 +1,13 @@
+import { TezosToolkit } from './taquito';
+/**
+ *
+ * @description Import a key to sign operation with the side-effect of setting the Tezos instance to use the InMemorySigner provider
+ *
+ * @warn The JSON faucets are no longer available on https://teztnets.com/
+ * @param toolkit The toolkit instance to attach a signer
+ * @param privateKeyOrEmail Key to load in memory
+ * @param passphrase If the key is encrypted passphrase to decrypt it
+ * @param mnemonic Faucet mnemonic
+ * @param secret Faucet secret
+ */
+export declare function importKey(toolkit: TezosToolkit, privateKeyOrEmail: string, passphrase?: string, mnemonic?: string, secret?: string): Promise<void>;

package/dist/types/operations/transfer-ticket-operation.d.ts

@@ -1,6 +1,6 @@
 import { OperationContentsAndResult, OperationContentsTransferTicket } from '@taquito/rpc';
 import { Context } from '../context';
-import { Operation } from '../operations';
+import { Operation } from './operations';
 import { GasConsumingOperation, StorageConsumingOperation, FeeConsumingOperation, ForgedBytes } from './types';
 /**
  *

package/dist/types/operations/types.d.ts

@@ -16,7 +16,7 @@ export declare const isKind: <T extends {
     kind: OpKind;
 }, K extends OpKind>(op: T, kind: K) => op is withKind<T, K>;
 export type RPCOpWithFee = RPCTransferOperation | RPCOriginationOperation | RPCDelegateOperation | RPCRevealOperation | RPCRegisterGlobalConstantOperation | RPCIncreasePaidStorageOperation | RPCTransferTicketOperation | RPCUpdateConsensusKeyOperation | RPCUpdateCompanionKeyOperation | RPCSmartRollupAddMessagesOperation | RPCSmartRollupOriginateOperation | RPCSmartRollupOutboxMessageOperation;
-export type RPCOpWithSource = RPCTransferOperation | RPCOriginationOperation | RPCDelegateOperation | RPCRevealOperation | RPCRegisterGlobalConstantOperation | RPCIncreasePaidStorageOperation | RPCTransferTicketOperation | RPCUpdateConsensusKeyOperation | RPCUpdateCompanionKeyOperation | RPCSmartRollupAddMessagesOperation | RPCSmartRollupOriginateOperation | RPCSmartRollupOutboxMessageOperation;
+export type RPCOpWithSource = RPCTransferOperation | RPCOriginationOperation | RPCDelegateOperation | RPCRevealOperation | RPCRegisterGlobalConstantOperation | RPCIncreasePaidStorageOperation | RPCTransferTicketOperation | RPCUpdateConsensusKeyOperation | RPCUpdateCompanionKeyOperation | RPCSmartRollupAddMessagesOperation | RPCSmartRollupOriginateOperation | RPCSmartRollupOutboxMessageOperation | RPCBallotOperation | RPCProposalsOperation;
 export declare const isOpWithGasBuffer: <T extends {
     kind: OpKind;
     destination?: string;
@@ -133,7 +133,7 @@ export interface ForgedBytes {
  * @description Parameters for setDelegate method
  */
 export interface DelegateParams {
-    source: string;
+    source?: string;
     delegate?: string;
     fee?: number;
     gasLimit?: number;
@@ -454,3 +454,8 @@ export type PrepareOperationParams = {
     operation: RPCOperation | RPCOperation[];
     source?: string;
 };
+export type ParamsWithOptionalFees = {
+    fee?: number | string;
+    storageLimit?: number | string;
+    gasLimit?: number | string;
+};

package/dist/types/prepare/interface.d.ts

@@ -1,6 +1,5 @@
 import { OperationContents, PreapplyParams } from '@taquito/rpc';
 import { BallotParams, DelegateParams, DrainDelegateParams, IncreasePaidStorageParams, OriginateParams, ProposalsParams, RegisterGlobalConstantParams, RevealParams, TransferParams, TransferTicketParams, UpdateConsensusKeyParams, UpdateCompanionKeyParams, ActivationParams, SmartRollupAddMessagesParams, SmartRollupOriginateParams } from '../operations/types';
-import { ContractMethod } from '../contract/contract-methods/contract-method-flat-param';
 import { ContractMethodObject } from '../contract/contract-methods/contract-method-object-param';
 import { ContractProvider } from '../contract/interface';
 import { ParamsWithKind } from '../operations/types';
@@ -125,10 +124,10 @@ export interface PreparationProvider {
     batch(batchParams: ParamsWithKind[]): Promise<PreparedOperation>;
     /**
      * @description Method to prepare a contract call (transfer) operation
-     * @param contractMethod ContractMethod or ContractMethodObject retrieved from smart contract
+     * @param contractMethod ContractMethodObject retrieved from smart contract
      * @returns a PreparedOperation object
      */
-    contractCall(contractMethod: ContractMethod<ContractProvider> | ContractMethodObject<ContractProvider>): Promise<PreparedOperation>;
+    contractCall(contractMethod: ContractMethodObject<ContractProvider>): Promise<PreparedOperation>;
     /**
      *
      * @description Method to convert a PreparedOperation to the params needed for the preapplyOperation method

package/dist/types/prepare/prepare-provider.d.ts

@@ -2,7 +2,6 @@ import { PreapplyParams } from '@taquito/rpc';
 import { DelegateParams, RevealParams, RegisterGlobalConstantParams, TransferParams, OriginateParams, UpdateConsensusKeyParams, UpdateCompanionKeyParams, TransferTicketParams, IncreasePaidStorageParams, BallotParams, ProposalsParams, DrainDelegateParams, ParamsWithKind, SmartRollupAddMessagesParams, SmartRollupOriginateParams, SmartRollupExecuteOutboxMessageParams, RegisterDelegateParams, ActivationParams, StakeParams, UnstakeParams, FinalizeUnstakeParams } from '../operations/types';
 import { PreparationProvider, PreparedOperation } from './interface';
 import { Context } from '../context';
-import { ContractMethod } from '../contract/contract-methods/contract-method-flat-param';
 import { ContractMethodObject } from '../contract/contract-methods/contract-method-object-param';
 import { ContractProvider } from '../contract/interface';
 import { DefaultContractType, ContractStorageType } from '../contract';
@@ -196,7 +195,7 @@ export declare class PrepareProvider extends Provider implements PreparationProv
      * @param operation RPCOperation object or RPCOperation array
      * @returns a PreparedOperation object
      */
-    contractCall(contractMethod: ContractMethod<ContractProvider> | ContractMethodObject<ContractProvider>): Promise<PreparedOperation>;
+    contractCall(contractMethod: ContractMethodObject<ContractProvider>): Promise<PreparedOperation>;
     /**
      *
      * @description Method to convert a PreparedOperation to the params needed for the preapplyOperation method

package/dist/types/provider.d.ts

@@ -1,4 +1,4 @@
-import { OperationContentsAndResult, RPCRunOperationParam, RPCSimulateOperationParam, RpcClientInterface } from '@taquito/rpc';
+import { OperationContentsAndResult, RPCSimulateOperationParam, RpcClientInterface } from '@taquito/rpc';
 import { Context } from './context';
 import { ForgedBytes, ParamsWithKind, RPCOperation } from './operations/types';
 import { PreparedOperation } from './prepare';
@@ -27,11 +27,6 @@ export declare abstract class Provider {
         storageLimit: number | undefined;
     }>;
     getRPCOp(param: ParamsWithKind): Promise<import("./operations/types").RPCTransferOperation | import("./operations/types").RPCOriginationOperation | import("./operations/types").RPCDelegateOperation | import("./operations/types").RPCRegisterGlobalConstantOperation | import("./operations/types").RPCIncreasePaidStorageOperation | import("./operations/types").RPCUpdateConsensusKeyOperation | import("./operations/types").RPCUpdateCompanionKeyOperation | import("./operations/types").RPCTransferTicketOperation | import("./operations/types").RPCSmartRollupAddMessagesOperation | import("./operations/types").RPCSmartRollupOriginateOperation | import("./operations/types").RPCSmartRollupOutboxMessageOperation>;
-    protected runOperation(op: RPCRunOperationParam): Promise<{
-        opResponse: import("@taquito/rpc").PreapplyResponse;
-        op: RPCRunOperationParam;
-        context: Context;
-    }>;
     protected simulate(op: RPCSimulateOperationParam): Promise<{
         opResponse: import("@taquito/rpc").PreapplyResponse;
         op: RPCSimulateOperationParam;

package/dist/types/taquito.d.ts

@@ -4,7 +4,6 @@
  */
 import { RpcClientInterface } from '@taquito/rpc';
 import { Forger } from '@taquito/local-forging';
-import { RPCBatchProvider } from './batch/rpc-batch-provider';
 import { Protocols } from './constants';
 import { ConfigConfirmation, TaquitoProvider } from './context';
 import { ContractProvider } from './contract/interface';
@@ -58,6 +57,7 @@ export { RpcReadAdapter } from './read-provider/rpc-read-adapter';
 export * from './estimate';
 export { TaquitoLocalForger } from './forger/taquito-local-forger';
 export * from './prepare';
+export { importKey } from './import-key';
 export interface SetProviderOptions {
     forger?: Forger;
     wallet?: WalletProvider;
@@ -87,11 +87,6 @@ export declare class TezosToolkit {
     private _rpcClient;
     private _wallet;
     private _context;
-    /**
-     * @deprecated TezosToolkit.batch has been deprecated in favor of TezosToolkit.contract.batch
-     *
-     */
-    batch: RPCBatchProvider['batch'];
     readonly format: typeof format;
     constructor(_rpc: RpcClientInterface | string);
     /**

package/dist/types/wallet/batch-operation.d.ts

@@ -1,7 +1,8 @@
-import { BlockResponse, OperationContentsAndResultReveal } from '@taquito/rpc';
+import { BlockResponse, OperationContentsAndResultReveal, OpKind } from '@taquito/rpc';
 import { Observable } from 'rxjs';
 import { Context } from '../context';
 import { WalletOperation, OperationStatus } from './operation';
+export declare const WALLET_BATCH_KINDS: OpKind[];
 export declare class BatchWalletOperation extends WalletOperation {
     readonly opHash: string;
     protected readonly context: Context;

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

@@ -4,5 +4,6 @@ export * from './transaction-operation';
 export * from './origination-operation';
 export * from './delegation-operation';
 export * from './transfer-ticket-operation';
+export * from './register-global-constant-operation';
 export * from './interface';
 export * from './legacy';

package/dist/types/wallet/interface.d.ts

@@ -1,4 +1,4 @@
-import { DelegateParams, FailingNoopParams, IncreasePaidStorageParams, OriginateParams, TransferParams, StakeParams, UnstakeParams, FinalizeUnstakeParams, TransferTicketParams } from '../operations/types';
+import { DelegateParams, FailingNoopParams, IncreasePaidStorageParams, OriginateParams, TransferParams, StakeParams, UnstakeParams, FinalizeUnstakeParams, TransferTicketParams, RegisterGlobalConstantParams } from '../operations/types';
 export type WalletDefinedFields = 'source';
 export type WalletTransferParams = Omit<TransferParams, WalletDefinedFields>;
 export type WalletStakeParams = Omit<StakeParams, WalletDefinedFields>;
@@ -9,13 +9,14 @@ export type WalletDelegateParams = Omit<DelegateParams, WalletDefinedFields>;
 export type WalletFailingNoopParams = Omit<FailingNoopParams, WalletDefinedFields>;
 export type WalletIncreasePaidStorageParams = Omit<IncreasePaidStorageParams, WalletDefinedFields>;
 export type WalletTransferTicketParams = Omit<TransferTicketParams, WalletDefinedFields>;
+export type WalletRegisterGlobalConstantParams = Omit<RegisterGlobalConstantParams, WalletDefinedFields>;
 export interface WalletProvider {
     /**
      * @description Request the public key hash from the wallet
      */
     getPKH: () => Promise<string>;
     /**
-     * @description Get the public key from the wallet
+     * @description Request the public key from the wallet
      */
     getPK: () => Promise<string>;
     /**
@@ -26,6 +27,10 @@ export interface WalletProvider {
      * @description Transform WalletTransferTicketParams into a format compliant with the underlying wallet
      */
     mapTransferTicketParamsToWalletParams: (params: () => Promise<WalletTransferTicketParams>) => Promise<any>;
+    /**
+     * @description Transform WalletRegisterGlobalConstantParams into a format compliant with the underlying wallet
+     */
+    mapRegisterGlobalConstantParamsToWalletParams: (params: () => Promise<WalletRegisterGlobalConstantParams>) => Promise<any>;
     /**
      * @description Transform WalletStakeParams into a format compliant with the underlying wallet
      */

package/dist/types/wallet/legacy.d.ts

@@ -1,6 +1,6 @@
 import { Context } from '../context';
 import { OpKind } from '../operations/types';
-import { WalletDelegateParams, WalletIncreasePaidStorageParams, WalletOriginateParams, WalletProvider, WalletTransferParams, WalletStakeParams, WalletUnstakeParams, WalletFinalizeUnstakeParams, WalletTransferTicketParams } from './interface';
+import { WalletDelegateParams, WalletIncreasePaidStorageParams, WalletOriginateParams, WalletProvider, WalletTransferParams, WalletStakeParams, WalletUnstakeParams, WalletFinalizeUnstakeParams, WalletTransferTicketParams, WalletRegisterGlobalConstantParams } from './interface';
 import { WalletParamsWithKind } from './wallet';
 export declare class LegacyWalletProvider implements WalletProvider {
     private context;
@@ -15,6 +15,7 @@ export declare class LegacyWalletProvider implements WalletProvider {
     mapDelegateParamsToWalletParams(params: () => Promise<WalletDelegateParams>): Promise<import("../operations/types").withKind<WalletDelegateParams, OpKind.DELEGATION>>;
     mapIncreasePaidStorageWalletParams(params: () => Promise<WalletIncreasePaidStorageParams>): Promise<import("../operations/types").withKind<WalletIncreasePaidStorageParams, OpKind.INCREASE_PAID_STORAGE>>;
     mapTransferTicketParamsToWalletParams(params: () => Promise<WalletTransferTicketParams>): Promise<import("../operations/types").withKind<WalletTransferTicketParams, OpKind.TRANSFER_TICKET>>;
+    mapRegisterGlobalConstantParamsToWalletParams(params: () => Promise<WalletRegisterGlobalConstantParams>): Promise<import("../operations/types").withKind<WalletRegisterGlobalConstantParams, OpKind.REGISTER_GLOBAL_CONSTANT>>;
     sendOperations(params: WalletParamsWithKind[]): Promise<string>;
     sign(bytes: string, watermark?: Uint8Array): Promise<string>;
 }

package/dist/types/wallet/operation-factory.d.ts

@@ -8,6 +8,7 @@ import { WalletOperation } from './operation';
 import { OriginationWalletOperation } from './origination-operation';
 import { TransactionWalletOperation } from './transaction-operation';
 import { TransferTicketWalletOperation } from './transfer-ticket-operation';
+import { RegisterGlobalConstantWalletOperation } from './register-global-constant-operation';
 export declare function timeoutAfter<T>(timeoutMillisec: number): (source: Observable<T>) => Observable<T>;
 export declare const createNewPollingBasedHeadObservable: (sharedHeadOb: Observable<BlockResponse>, context: Context, _scheduler?: SchedulerLike) => Observable<BlockResponse>;
 export interface OperationFactoryConfig {
@@ -27,4 +28,5 @@ export declare class OperationFactory {
     createDelegationOperation(hash: string, config?: OperationFactoryConfig): Promise<DelegationWalletOperation>;
     createOriginationOperation(hash: string, config?: OperationFactoryConfig): Promise<OriginationWalletOperation>;
     createIncreasePaidStorageOperation(hash: string, config?: OperationFactoryConfig): Promise<IncreasePaidStorageWalletOperation>;
+    createRegisterGlobalConstantOperation(hash: string, config?: OperationFactoryConfig): Promise<RegisterGlobalConstantWalletOperation>;
 }

package/dist/types/wallet/register-global-constant-operation.d.ts

@@ -0,0 +1,13 @@
+import { BlockResponse, OperationContentsAndResultRegisterGlobalConstant, OperationContentsAndResultReveal } from '@taquito/rpc';
+import { Observable } from 'rxjs';
+import { Context } from '../context';
+import { WalletOperation, OperationStatus } from './operation';
+export declare class RegisterGlobalConstantWalletOperation extends WalletOperation {
+    readonly opHash: string;
+    protected readonly context: Context;
+    constructor(opHash: string, context: Context, newHead$: Observable<BlockResponse>);
+    revealOperation(): Promise<OperationContentsAndResultReveal | undefined>;
+    registerGlobalConstantOperation(): Promise<OperationContentsAndResultRegisterGlobalConstant | undefined>;
+    status(): Promise<OperationStatus>;
+    globalConstantHash(): Promise<string | undefined>;
+}