@taquito/wallet-connect 24.3.0-beta.0 → 24.3.0-beta.2

package/dist/types/taquito/src/operations/update-companion-key-operation.d.ts

@@ -0,0 +1,23 @@
+import { OperationContentsAndResult, OperationContentsUpdateCompanionKey } from '@taquito/rpc';
+import { Context } from '../context';
+import { Operation } from './operations';
+import { FeeConsumingOperation, ForgedBytes, GasConsumingOperation, StorageConsumingOperation } from './types';
+/**
+ *
+ * UpdateCompanionKeyOperation provides utility to fetch properties for Operation of kind UpdateCompanionKey
+ *
+ */
+export declare class UpdateCompanionKeyOperation extends Operation implements GasConsumingOperation, StorageConsumingOperation, FeeConsumingOperation {
+    private readonly params;
+    readonly source: string;
+    constructor(hash: string, params: OperationContentsUpdateCompanionKey, source: string, raw: ForgedBytes, results: OperationContentsAndResult[], context: Context);
+    get operationResults(): import("@taquito/rpc").OperationResultUpdateConsensusKey | undefined;
+    get status(): import("@taquito/rpc").OperationResultStatusEnum | "unknown";
+    get fee(): number;
+    get gasLimit(): number;
+    get storageLimit(): number;
+    get pk(): string;
+    get proof(): string;
+    get consumedMilliGas(): string | undefined;
+    get errors(): import("@taquito/rpc").TezosGenericOperationError[] | undefined;
+}

package/dist/types/taquito/src/operations/update-consensus-key-operation.d.ts

@@ -0,0 +1,23 @@
+import { OperationContentsAndResult, OperationContentsUpdateConsensusKey } from '@taquito/rpc';
+import { Context } from '../context';
+import { Operation } from './operations';
+import { FeeConsumingOperation, ForgedBytes, GasConsumingOperation, StorageConsumingOperation } from './types';
+/**
+ *
+ * UpdateConsensusKeyOperation provides utility to fetch properties for Operation of kind UpdateConsensusKey
+ *
+ */
+export declare class UpdateConsensusKeyOperation extends Operation implements GasConsumingOperation, StorageConsumingOperation, FeeConsumingOperation {
+    private readonly params;
+    readonly source: string;
+    constructor(hash: string, params: OperationContentsUpdateConsensusKey, source: string, raw: ForgedBytes, results: OperationContentsAndResult[], context: Context);
+    get operationResults(): import("@taquito/rpc").OperationResultUpdateConsensusKey | undefined;
+    get status(): import("@taquito/rpc").OperationResultStatusEnum | "unknown";
+    get fee(): number;
+    get gasLimit(): number;
+    get storageLimit(): number;
+    get pk(): string;
+    get proof(): string;
+    get consumedMilliGas(): string | undefined;
+    get errors(): import("@taquito/rpc").TezosGenericOperationError[] | undefined;
+}

package/dist/types/taquito/src/packer/interface.d.ts

@@ -0,0 +1,4 @@
+import { PackDataParams, PackDataResponse } from '@taquito/rpc';
+export interface Packer {
+    packData(data: PackDataParams): Promise<PackDataResponse>;
+}

package/dist/types/taquito/src/packer/michel-codec-packer.d.ts

@@ -0,0 +1,5 @@
+import { Packer } from './interface';
+import { PackDataResponse, PackDataParams } from '@taquito/rpc';
+export declare class MichelCodecPacker implements Packer {
+    packData(data: PackDataParams): Promise<PackDataResponse>;
+}

package/dist/types/taquito/src/packer/rpc-packer.d.ts

@@ -0,0 +1,8 @@
+import { Packer } from './interface';
+import { Context } from '../context';
+import { PackDataParams, PackDataResponse } from '@taquito/rpc';
+export declare class RpcPacker implements Packer {
+    private context;
+    constructor(context: Context);
+    packData(data: PackDataParams): Promise<PackDataResponse>;
+}

package/dist/types/taquito/src/parser/interface.d.ts

@@ -0,0 +1,4 @@
+import { OriginateParams } from '../operations/types';
+export interface ParserProvider {
+    prepareCodeOrigination(params: OriginateParams): Promise<OriginateParams>;
+}

package/dist/types/taquito/src/parser/michel-codec-parser.d.ts

@@ -0,0 +1,16 @@
+import { Context } from '../context';
+import { ParserProvider } from './interface';
+import { Expr } from '@taquito/michel-codec';
+import { OriginateParams } from '../operations/types';
+export declare class MichelCodecParser implements ParserProvider {
+    private context;
+    constructor(context: Context);
+    private getNextProto;
+    parseScript(src: string): Promise<Expr[] | null>;
+    parseMichelineExpression(src: string): Promise<Expr | null>;
+    parseJSON(src: object): Promise<Expr>;
+    prepareCodeOrigination(params: OriginateParams): Promise<OriginateParams>;
+    private formatCodeParam;
+    private formatInitParam;
+    private findGlobalConstantsHashAndValue;
+}

package/dist/types/taquito/src/parser/noop-parser.d.ts

@@ -0,0 +1,5 @@
+import { OriginateParams } from "../operations/types";
+import { ParserProvider } from "./interface";
+export declare class NoopParser implements ParserProvider {
+    prepareCodeOrigination(params: OriginateParams): Promise<OriginateParams>;
+}

package/dist/types/taquito/src/prepare/index.d.ts

@@ -0,0 +1,2 @@
+export * from './interface';
+export * from './prepare-provider';

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

@@ -0,0 +1,152 @@
+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 { ContractMethodObject } from '../contract/contract-methods/contract-method-object-param';
+import { ContractProvider } from '../contract/interface';
+import { ParamsWithKind } from '../operations/types';
+import { ForgeParams } from '@taquito/local-forging';
+/**
+ * PrepareProvider is a utility class to output the prepared format of an operation
+ */
+export interface PreparationProvider {
+    /**
+     * Method to prepare an activation operation
+     * @param params activation operation parameters
+     * @returns a PreparedOperation object
+     */
+    activate(params: ActivationParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a reveal operation
+     * @param params reveal operation parameters
+     * @returns a PreparedOperation object
+     */
+    reveal(params: RevealParams): Promise<PreparedOperation>;
+    /**
+     * Method to prepare an origination operation
+     * @param params originate operation parameters
+     * @returns a PreparedOperation object
+     */
+    originate(params: OriginateParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a transaction operation
+     *
+     * @param params transaction operation parameters
+     *
+     * @returns a PreparedOperation object
+     */
+    transaction(params: TransferParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a delegation operation
+     * @param params delegation operation parameters
+     * @returns a PreparedOperation object
+     */
+    delegation(params: DelegateParams): Promise<PreparedOperation>;
+    /**
+     * Method to prepare a register_global_constant operation
+     * @param params registerGlobalConstant operation parameters
+     * @returns a PreparedOperation object
+     */
+    registerGlobalConstant(params: RegisterGlobalConstantParams): Promise<PreparedOperation>;
+    /**
+     * Method to prepare an update_consensus_key operation
+     * @param params updateConsensusKey operation parameters
+     * @returns a PreparedOperation object
+     */
+    updateConsensusKey(params: UpdateConsensusKeyParams): Promise<PreparedOperation>;
+    /**
+     * Method to prepare an update_companion_key operation
+     * @param params updateCompanionKey operation parameters
+     * @returns a PreparedOperation object
+     */
+    updateCompanionKey(params: UpdateCompanionKeyParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a transfer_ticket operation
+     * @param params TransferTicket operation parameters
+     * @returns a PreparedOperation object
+     */
+    transferTicket(params: TransferTicketParams): Promise<PreparedOperation>;
+    /**
+     * Method to prepare an increase_paid_storage operation
+     * @param params increasePaidStorage operation parameters
+     * @returns a PreparedOperation object
+     */
+    increasePaidStorage(params: IncreasePaidStorageParams): Promise<PreparedOperation>;
+    /**
+     * Method to prepare a ballot operation
+     * @param params ballot operation parameters
+     * @returns a PreparedOperation object
+     */
+    ballot(params: BallotParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a proposals operation
+     * @param params proposals operation parameters
+     * @returns a PreparedOperation object
+     */
+    proposals(params: ProposalsParams): Promise<PreparedOperation>;
+    /**
+     * Method to prepare a drain_delegate operation
+     * @param params drainDelegate operation parameters
+     * @returns a PreparedOperation object
+     */
+    drainDelegate(params: DrainDelegateParams): Promise<PreparedOperation>;
+    /**
+     * Method to prepare a smart_rollup_add_messages operation
+     * @param params smartRollupAddMessages operation parameters
+     * @returns a PreparedOperation object
+     */
+    smartRollupAddMessages(params: SmartRollupAddMessagesParams): Promise<PreparedOperation>;
+    /**
+     * Method to prepare a smart_rollup_originate operation
+     * @param params smartRollupOriginate operation parameters
+     * @returns a PreparedOperation object
+     */
+    smartRollupOriginate(params: SmartRollupOriginateParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a batch operation
+     * @param batchParams batch operation parameters
+     * @returns a PreparedOperation object
+     */
+    batch(batchParams: ParamsWithKind[]): Promise<PreparedOperation>;
+    /**
+     * Method to prepare a contract call (transfer) operation
+     * @param contractMethod ContractMethodObject retrieved from smart contract
+     * @returns a PreparedOperation object
+     */
+    contractCall(contractMethod: ContractMethodObject<ContractProvider>): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to convert a PreparedOperation to the params needed for the preapplyOperation method
+     * @param prepared a Prepared Operation
+     * @returns a PreapplyParams object
+     */
+    toPreapply(prepared: PreparedOperation): Promise<PreapplyParams>;
+    /**
+     *
+     * Method to convert a PreparedOperation to the params needed for forging
+     * @param param a Prepared Operation
+     * @returns a ForgeParams object
+     */
+    toForge(param: PreparedOperation): ForgeParams;
+}
+export interface PreparedOperation {
+    opOb: {
+        branch: string;
+        contents: OperationContents[];
+        protocol: string;
+    };
+    counter: number;
+    simulation?: {
+        /**
+         * Indexes of operation contents whose gas limit was auto-assigned for simulation.
+         * This mirrors octez-client's `may_patch_limits` behavior, which tracks manager
+         * operations with unknown gas limits and rebalances only that set against the
+         * block gas budget during simulation.
+         */
+        gasLimitPatchableIndexes?: number[];
+    };
+}

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

@@ -0,0 +1,187 @@
+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 { ContractMethodObject } from '../contract/contract-methods/contract-method-object-param';
+import { ContractProvider } from '../contract/interface';
+import { DefaultContractType, ContractStorageType } from '../contract';
+import { Estimate } from '../estimate';
+import { ForgeParams } from '@taquito/local-forging';
+import { Provider } from '../provider';
+/**
+ * PrepareProvider is a utility class to output the prepared format of an operation
+ */
+export declare class PrepareProvider extends Provider implements PreparationProvider {
+    #private;
+    protected context: Context;
+    constructor(context: Context);
+    private getBlockHash;
+    private getProtocolHash;
+    private getHeadCounter;
+    private adjustGasForManagerOperations;
+    private getOperationLimits;
+    private getOperationLimitsForManagerOperation;
+    private getFee;
+    private getSource;
+    private addRevealOperationIfNeeded;
+    private getKeys;
+    private convertIntoArray;
+    private getSingleManagerOperationSimulation;
+    private withSimulationMetadata;
+    private constructOpContents;
+    /**
+     *
+     * Method to prepare an activation operation
+     * @returns a PreparedOperation object
+     */
+    activate({ pkh, secret }: ActivationParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a reveal operation
+     * @returns a PreparedOperation object
+     */
+    reveal({ fee, gasLimit, storageLimit, proof }: RevealParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare an origination operation
+     * @param source string or undefined source pkh
+     * @returns a PreparedOperation object
+     */
+    originate<TContract extends DefaultContractType = DefaultContractType>({ fee, storageLimit, gasLimit, ...rest }: OriginateParams<ContractStorageType<TContract>>, source?: string): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a transaction operation
+     * @returns a PreparedOperation object
+     */
+    transaction({ fee, storageLimit, gasLimit, ...rest }: TransferParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a stake pseudo-operation
+     * @returns a PreparedOperation object
+     */
+    stake({ fee, storageLimit, gasLimit, ...rest }: StakeParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a unstake pseudo-operation
+     * @returns a PreparedOperation object
+     */
+    unstake({ fee, storageLimit, gasLimit, ...rest }: UnstakeParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a finalize_unstake pseudo-operation
+     * @returns a PreparedOperation object
+     */
+    finalizeUnstake({ fee, storageLimit, gasLimit, to, ...rest }: FinalizeUnstakeParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a delegation operation
+     * @returns a PreparedOperation object
+     */
+    delegation({ fee, storageLimit, gasLimit, ...rest }: DelegateParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a register delegate operation
+     * @param source string or undefined source pkh
+     * @returns a PreparedOperation object
+     */
+    registerDelegate({ fee, storageLimit, gasLimit }: RegisterDelegateParams, source?: string): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a register_global_constant operation
+     * @returns a PreparedOperation object
+     */
+    registerGlobalConstant({ fee, storageLimit, gasLimit, ...rest }: RegisterGlobalConstantParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare an update_consensus_key operation
+     * @param source string or undefined source pkh
+     * @returns a PreparedOperation object
+     */
+    updateConsensusKey({ fee, storageLimit, gasLimit, ...rest }: UpdateConsensusKeyParams, source?: string): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare an update_companion_key operation
+     * @param source string or undefined source pkh
+     * @returns a PreparedOperation object
+     */
+    updateCompanionKey({ fee, storageLimit, gasLimit, ...rest }: UpdateCompanionKeyParams, source?: string): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare an increase_paid_storage operation
+     * @returns a PreparedOperation object
+     */
+    increasePaidStorage({ fee, storageLimit, gasLimit, ...rest }: IncreasePaidStorageParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a ballot operation
+     * @param params ballot operation parameters
+     * @returns a PreparedOperation object
+     */
+    ballot(params: BallotParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a proposals operation
+     * @param params proposals operation parameters
+     * @returns a PreparedOperation object
+     */
+    proposals(params: ProposalsParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a drain_delegate operation
+     * @param params drainDelegate operation parameters
+     * @returns a PreparedOperation object
+     */
+    drainDelegate(params: DrainDelegateParams, source?: string): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a transfer_ticket operation
+     * @returns a PreparedOperation object
+     */
+    transferTicket({ fee, storageLimit, gasLimit, ...rest }: TransferTicketParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a smart_rollup_add_messages operation
+     * @returns a PreparedOperation object
+     */
+    smartRollupAddMessages({ fee, storageLimit, gasLimit, ...rest }: SmartRollupAddMessagesParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a smart_rollup_originate operation
+     * @returns a PreparedOperation object
+     */
+    smartRollupOriginate({ fee, storageLimit, gasLimit, ...rest }: SmartRollupOriginateParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a smart_rollup_execute_outbox_message operation
+     * @returns a PreparedOperation object
+     */
+    smartRollupExecuteOutboxMessage({ fee, storageLimit, gasLimit, ...rest }: SmartRollupExecuteOutboxMessageParams): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a batch operation
+     * @param batchParams batch operation parameters
+     * @returns a PreparedOperation object
+     */
+    batch(batchParams: ParamsWithKind[], estimates?: Estimate[]): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to prepare a contract call operation
+     * @param contractMethod ContractMethodObject retrieved from smart contract
+     * @returns a PreparedOperation object
+     */
+    contractCall(contractMethod: ContractMethodObject<ContractProvider>): Promise<PreparedOperation>;
+    /**
+     *
+     * Method to convert a PreparedOperation to the params needed for the preapplyOperation method
+     * @param prepared a Prepared Operation
+     * @returns a PreapplyParams object
+     */
+    toPreapply(prepared: PreparedOperation): Promise<PreapplyParams>;
+    /**
+     *
+     * Method to convert a PreparedOperation to the params needed for forging
+     * @param param a Prepared Operation
+     * @returns a ForgeParams object
+     */
+    toForge({ opOb: { contents, branch } }: PreparedOperation): ForgeParams;
+}

package/dist/types/taquito/src/provider.d.ts

@@ -0,0 +1,50 @@
+import { OperationContentsAndResult, RPCSimulateOperationParam, RpcClientInterface } from '@taquito/rpc';
+import { Context } from './context';
+import { ForgedBytes, ParamsWithKind, RPCOperation } from './operations/types';
+import { PreparedOperation } from './prepare';
+import { Estimate } from './estimate';
+export declare abstract class Provider {
+    protected context: Context;
+    private parseRpcErrors;
+    private toBigInt;
+    private parseCounterInThePastAdjustments;
+    private hasGasLimitTooHighAndBlockExhausted;
+    private patchSimulationGasLimits;
+    private patchSimulationCounters;
+    get rpc(): RpcClientInterface;
+    get signer(): import("@taquito/core").Signer;
+    constructor(context: Context);
+    protected forge({ opOb: { branch, contents, protocol }, counter }: PreparedOperation): Promise<{
+        opbytes: string;
+        opOb: {
+            branch: string;
+            contents: import("@taquito/rpc").OperationContents[];
+            protocol: string;
+        };
+        counter: number;
+    }>;
+    protected estimate<T extends {
+        fee?: number;
+        gasLimit?: number;
+        storageLimit?: number;
+    }>({ fee, gasLimit, storageLimit, ...rest }: T, estimator: (param: T) => Promise<Estimate>): Promise<{
+        fee: number | undefined;
+        gasLimit: number | undefined;
+        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 simulate(op: RPCSimulateOperationParam, preparedOperation?: PreparedOperation): Promise<{
+        opResponse: import("@taquito/rpc").PreapplyResponse;
+        op: RPCSimulateOperationParam;
+        context: Context;
+    }>;
+    protected isRevealOpNeeded(op: RPCOperation[] | ParamsWithKind[], pkh: string): Promise<boolean>;
+    protected isAccountRevealRequired(publicKeyHash: string): Promise<boolean>;
+    protected isRevealRequiredForOpType(op: RPCOperation[] | ParamsWithKind[]): boolean;
+    protected signAndInject(forgedBytes: ForgedBytes): Promise<{
+        hash: string;
+        forgedBytes: ForgedBytes;
+        opResponse: OperationContentsAndResult[];
+        context: Context;
+    }>;
+}

package/dist/types/taquito/src/read-provider/interface.d.ts

@@ -0,0 +1,132 @@
+import { BlockResponse, EntrypointsResponse, MichelsonV1Expression, SaplingDiffResponse, ScriptedContracts, AILaunchCycleResponse } from '@taquito/rpc';
+import BigNumber from 'bignumber.js';
+export type BigMapQuery = {
+    id: string;
+    expr: string;
+};
+export type SaplingStateQuery = {
+    id: string;
+};
+export type BlockIdentifier = 'head' | `head~${number}` | `B${string}` | number;
+export interface TzReadProvider {
+    /**
+     * The spendable balance of a contract (in mutez), also known as liquid balance. Corresponds to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds. Identical to the 'spendable' RPC.
+     * @param address address from which we want to retrieve the spendable balance
+     * @param block from which we want to retrieve the balance
+     * @returns the balance in mutez
+     */
+    getBalance(address: string, block: BlockIdentifier): Promise<BigNumber>;
+    /**
+     * The spendable balance of a contract (in mutez), also known as liquid balance. Corresponds to tez owned by the contract that are neither staked, nor in unstaked requests, nor in frozen bonds. Identical to the 'balance' RPC.
+     * @param address address from which we want to retrieve the spendable balance
+     * @param block from which we want to retrieve the balance
+     * @returns the balance in mutez
+     */
+    getSpendable(address: string, block: BlockIdentifier): Promise<BigNumber>;
+    /**
+     * Access the delegate of a contract, if any.
+     * @param address contract address from which we want to retrieve the delegate (baker)
+     * @param block from which we want to retrieve the delegate
+     * @returns the public key hash of the delegate or null if no delegate
+     */
+    getDelegate(address: string, block: BlockIdentifier): Promise<string | null>;
+    /**
+     * Access the next protocol hash
+     * @param block from which we want to retrieve the next protocol hash
+     */
+    getNextProtocol(block: BlockIdentifier): Promise<string>;
+    /**
+     * Access protocol constants used in Taquito
+     * @param block from which we want to retrieve the constants
+     */
+    getProtocolConstants(block: BlockIdentifier): Promise<{
+        time_between_blocks?: BigNumber[];
+        minimal_block_delay?: BigNumber;
+        hard_gas_limit_per_operation: BigNumber;
+        hard_gas_limit_per_block: BigNumber;
+        hard_storage_limit_per_operation: BigNumber;
+        cost_per_byte: BigNumber;
+        smart_rollup_origination_size: number;
+    }>;
+    /**
+     * Access the script (code and storage) of a smart contract
+     * @param contract contract address from which we want to retrieve the script
+     * @param block from which we want to retrieve the storage value
+     * @returns Note: The code must be in the JSON format and not contain global constant
+     */
+    getScript(contract: string, block: BlockIdentifier): Promise<ScriptedContracts>;
+    /**
+     * Access the storage of a contract
+     * @param contract contract address from which we want to retrieve the storage
+     * @param block from which we want to retrieve the storage value
+     */
+    getStorage(contract: string, block: BlockIdentifier): Promise<MichelsonV1Expression>;
+    /**
+     * Access the block hash
+     */
+    getBlockHash(block: BlockIdentifier): Promise<string>;
+    /**
+     * Access the block level
+     */
+    getBlockLevel(block: BlockIdentifier): Promise<number>;
+    /**
+     * Access the counter of an address
+     * @param pkh from which we want to retrieve the counter
+     * @param block from which we want to retrieve the counter
+     */
+    getCounter(pkh: string, block: BlockIdentifier): Promise<string>;
+    /**
+     * Access the timestamp of a block
+     * @param block from which we want to retrieve the timestamp
+     * @returns date ISO format zero UTC offset ("2022-01-19T22:37:07Z")
+     */
+    getBlockTimestamp(block: BlockIdentifier): Promise<string>;
+    /**
+     * Access the value associated with a key in a big map.
+     * @param bigMapQuery Big Map ID and Expression hash to query (A b58check encoded Blake2b hash of the expression)
+     * @param block from which we want to retrieve the big map value
+     */
+    getBigMapValue(bigMapQuery: BigMapQuery, block: BlockIdentifier): Promise<MichelsonV1Expression>;
+    /**
+     * Access the value associated with a sapling state ID.
+     * @param saplingStateQuery Sapling state ID query
+     * @param block from which we want to retrieve the sapling state
+     */
+    getSaplingDiffById(saplingStateQuery: SaplingStateQuery, block: BlockIdentifier): Promise<SaplingDiffResponse>;
+    /**
+     * Access the sapling state of a smart contract.
+     * @param contractAddress The address of the smart contract
+     * @param block The block you want to retrieve the sapling state from
+     */
+    getSaplingDiffByContract(contractAddress: string, block: BlockIdentifier): Promise<SaplingDiffResponse>;
+    /**
+     * Return the list of entrypoints of the contract
+     * @param contract address of the contract we want to get the entrypoints of
+     */
+    getEntrypoints(contract: string): Promise<EntrypointsResponse>;
+    /**
+     * Access the chain id
+     */
+    getChainId(): Promise<string>;
+    /**
+     * Indicate if an account is revealed
+     * @param publicKeyHash of the account
+     * @param block from which we want to know if the account is revealed
+     */
+    isAccountRevealed(publicKeyHash: string, block: BlockIdentifier): Promise<boolean>;
+    /**
+     * Return all the information about a block
+     * @param block from which we want to retrieve the information
+     */
+    getBlock(block: BlockIdentifier): Promise<BlockResponse>;
+    /**
+     * Return a list of the ancestors of the given block which, if referred to as the branch in an operation header, are recent enough for that operation to be included in the current block.
+     * @param block from which we want to retrieve the information
+     */
+    getLiveBlocks(block: BlockIdentifier): Promise<string[]>;
+    /**
+     * Returns the cycle at which the launch of the Adaptive Issuance feature is set to happen. A result of null means that the feature is not yet set to launch.
+     * @param block from which we want to retrieve the information
+     */
+    getAdaptiveIssuanceLaunchCycle(block: BlockIdentifier): Promise<AILaunchCycleResponse>;
+}