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

package/dist/types/taquito-michelson-encoder/src/tokens/ticket-deprecated.d.ts

@@ -0,0 +1,38 @@
+import { TaquitoError } from '@taquito/core';
+import { TicketDeprecatedTokenSchema } from '../schema/types';
+import { Token, TokenFactory, Semantic, SemanticEncoding } from './token';
+/**
+ *  @category Error
+ *  Error that indicates a failure when encoding and sending a ticket to the blockchain
+ */
+export declare class EncodeTicketDeprecatedError extends TaquitoError {
+    name: string;
+    constructor();
+}
+export declare class TicketDeprecatedToken extends Token {
+    protected val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    };
+    protected idx: number;
+    protected fac: TokenFactory;
+    static prim: 'ticket_deprecated';
+    constructor(val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    }, idx: number, fac: TokenFactory);
+    get valueToken(): Token;
+    /**
+     * @throws {@link EncodeTicketDeprecatedError}
+     */
+    Encode(_args: any[]): any;
+    /**
+     * @throws {@link EncodeTicketDeprecatedError}
+     */
+    EncodeObject(args: any, semantic?: SemanticEncoding): any;
+    Execute(val: any, semantics?: Semantic): any;
+    generateSchema(): TicketDeprecatedTokenSchema;
+    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
+}

package/dist/types/taquito-michelson-encoder/src/tokens/ticket.d.ts

@@ -0,0 +1,38 @@
+import { TaquitoError } from '@taquito/core';
+import { TicketTokenSchema } from '../schema/types';
+import { Token, TokenFactory, Semantic, SemanticEncoding } from './token';
+/**
+ *  @category Error
+ *  Error that indicates a failure when encoding and sending a ticket to the blockchain
+ */
+export declare class EncodeTicketError extends TaquitoError {
+    name: string;
+    constructor();
+}
+export declare class TicketToken extends Token {
+    protected val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    };
+    protected idx: number;
+    protected fac: TokenFactory;
+    static prim: 'ticket';
+    constructor(val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    }, idx: number, fac: TokenFactory);
+    get valueToken(): Token;
+    /**
+     * @throws {@link EncodeTicketError}
+     */
+    Encode(_args: any[]): any;
+    /**
+     * @throws {@link EncodeTicketError}
+     */
+    EncodeObject(args: any, semantic?: SemanticEncoding): any;
+    Execute(val: any, semantics?: Semantic): any;
+    generateSchema(): TicketTokenSchema;
+    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
+}

package/dist/types/taquito-michelson-encoder/src/tokens/token.d.ts

@@ -0,0 +1,68 @@
+import { MichelsonV1Expression, MichelsonV1ExpressionExtended } from '@taquito/rpc';
+import { TokenSchema } from '../schema/types';
+import { TaquitoError } from '@taquito/core';
+/**
+ *  @category Error
+ *  Error that indicates a failure when encoding invalid or incorrect data (e.g. if an address is expected but a number is received)
+ */
+export declare abstract class TokenValidationError extends TaquitoError {
+    readonly value: any;
+    readonly token: Token;
+    name: string;
+    constructor(value: any, token: Token, baseMessage: string);
+}
+export type TokenFactory = (val: any, idx: number, parentTokenType?: 'Or' | 'Pair' | 'Other') => Token;
+export interface Semantic {
+    [key: string]: (value: MichelsonV1Expression, schema: MichelsonV1Expression) => any;
+}
+export interface SemanticEncoding {
+    [key: string]: (value: any, type?: MichelsonV1Expression) => MichelsonV1Expression;
+}
+/**
+ * Possible strategies for mapping between javascript classes and Michelson values
+ * Legacy: The old behaviour: { annot1: 'some value', annot2: 'other Value', annot3: { 2: 'yet another value', 3: 'also some value' }}
+ * ResetFieldNumbersInNestedObjects: { annot1: 'some value', annot2: 'other Value', annot3: { 0: 'yet another value', 1: 'also some value' }}
+ * Latest: This will include new changes as we might implement in the future. This is the suggested value if it does not break your code
+ */
+export type FieldNumberingStrategy = 'Legacy' | 'ResetFieldNumbersInNestedObjects' | 'Latest';
+export declare abstract class Token {
+    protected val: MichelsonV1ExpressionExtended;
+    protected idx: number;
+    protected fac: TokenFactory;
+    protected parentTokenType?: "Or" | "Pair" | "Other" | undefined;
+    private static _fieldNumberingStrategy;
+    /**
+     * Gets the strategy used for field numbering in Token execute/encode/decode to convert Michelson values to/from javascript objects, returns a value of type {@link FieldNumberingStrategy} that controls how field numbers are calculated
+     */
+    static get fieldNumberingStrategy(): FieldNumberingStrategy;
+    /**
+     * Sets the strategy used for field numbering in Token execute/encode/decode to convert Michelson values to/from javascript objects, accepts a value of type {@link FieldNumberingStrategy} that controls how field numbers are calculated
+     */
+    static set fieldNumberingStrategy(value: FieldNumberingStrategy);
+    constructor(val: MichelsonV1ExpressionExtended, idx: number, fac: TokenFactory, parentTokenType?: "Or" | "Pair" | "Other" | undefined);
+    protected typeWithoutAnnotations(): Omit<MichelsonV1ExpressionExtended, "annots">;
+    annot(): string;
+    hasAnnotations(): number | false;
+    get tokenVal(): MichelsonV1ExpressionExtended;
+    createToken: TokenFactory;
+    abstract generateSchema(): TokenSchema;
+    abstract Execute(val: any, semantics?: Semantic): any;
+    abstract Encode(_args: any[]): any;
+    abstract EncodeObject(args: any, semantics?: SemanticEncoding): any;
+    ExtractSignature(): TokenSchema[][];
+    abstract findAndReturnTokens(tokenToFind: string, tokens: Array<Token>): Array<Token>;
+}
+export type BigMapKeyType = string | number | object;
+export declare abstract class ComparableToken extends Token {
+    abstract ToBigMapKey(val: BigMapKeyType): {
+        key: {
+            [key: string]: string | object[];
+        };
+        type: {
+            prim: string;
+            args?: object[];
+        };
+    };
+    abstract ToKey(val: string | MichelsonV1Expression): any;
+    compare(o1: string, o2: string): number;
+}

package/dist/types/taquito-michelson-encoder/src/tokens/tokens.d.ts

@@ -0,0 +1,36 @@
+import { PairToken } from './pair';
+import { NatToken } from './comparable/nat';
+import { StringToken } from './comparable/string';
+import { BigMapToken } from './bigmap';
+import { AddressToken } from './comparable/address';
+import { MapToken } from './map';
+import { BoolToken } from './comparable/bool';
+import { OrToken } from './or';
+import { ContractToken } from './contract';
+import { ListToken } from './list';
+import { MutezToken } from './comparable/mutez';
+import { BytesToken } from './comparable/bytes';
+import { OptionToken } from './option';
+import { TimestampToken } from './comparable/timestamp';
+import { IntToken } from './comparable/int';
+import { UnitToken } from './unit';
+import { KeyToken } from './key';
+import { KeyHashToken } from './comparable/key_hash';
+import { SignatureToken } from './signature';
+import { LambdaToken } from './lambda';
+import { OperationToken } from './operation';
+import { SetToken } from './set';
+import { ChainIDToken } from './chain-id';
+import { TicketToken } from './ticket';
+import { TicketDeprecatedToken } from './ticket-deprecated';
+import { NeverToken } from './never';
+import { SaplingStateToken } from './sapling-state';
+import { SaplingTransactionToken } from './sapling-transaction';
+import { SaplingTransactionDeprecatedToken } from './sapling-transaction-deprecated';
+import { Bls12381frToken } from './bls12-381-fr';
+import { Bls12381g1Token } from './bls12-381-g1';
+import { Bls12381g2Token } from './bls12-381-g2';
+import { ChestToken } from './chest';
+import { ChestKeyToken } from './chest-key';
+import { GlobalConstantToken } from './constant';
+export declare const tokens: (typeof PairToken | typeof NatToken | typeof StringToken | typeof BigMapToken | typeof AddressToken | typeof MapToken | typeof BoolToken | typeof OrToken | typeof ContractToken | typeof ListToken | typeof MutezToken | typeof BytesToken | typeof OptionToken | typeof TimestampToken | typeof IntToken | typeof UnitToken | typeof KeyToken | typeof KeyHashToken | typeof SignatureToken | typeof LambdaToken | typeof OperationToken | typeof SetToken | typeof ChainIDToken | typeof TicketToken | typeof TicketDeprecatedToken | typeof NeverToken | typeof SaplingStateToken | typeof SaplingTransactionToken | typeof SaplingTransactionDeprecatedToken | typeof Bls12381frToken | typeof Bls12381g1Token | typeof Bls12381g2Token | typeof ChestToken | typeof ChestKeyToken | typeof GlobalConstantToken)[];

package/dist/types/taquito-michelson-encoder/src/tokens/unit.d.ts

@@ -0,0 +1,34 @@
+import { ComparableToken, SemanticEncoding, Token, TokenFactory } from './token';
+import { BaseTokenSchema } from '../schema/types';
+export declare class UnitToken extends ComparableToken {
+    protected val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    };
+    protected idx: number;
+    protected fac: TokenFactory;
+    static prim: 'unit';
+    constructor(val: {
+        prim: string;
+        args: any[];
+        annots: any[];
+    }, idx: number, fac: TokenFactory);
+    Encode(args: any[]): any;
+    EncodeObject(val: any, semantic?: SemanticEncoding): any;
+    Execute(_val: {
+        prim: string;
+    }): symbol;
+    generateSchema(): BaseTokenSchema;
+    compare(_val1: any, _val2: any): number;
+    ToKey(_val: any): symbol;
+    ToBigMapKey(_val: any): {
+        key: {
+            prim: string;
+        };
+        type: {
+            prim: "unit";
+        };
+    };
+    findAndReturnTokens(tokenToFind: string, tokens: Token[]): Token[];
+}

package/dist/types/taquito-michelson-encoder/src/version.d.ts

@@ -0,0 +1,4 @@
+export declare const VERSION: {
+    commitHash: string;
+    version: string;
+};

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

@@ -0,0 +1,45 @@
+export declare enum OpKind {
+    ORIGINATION = "origination",
+    DELEGATION = "delegation",
+    REVEAL = "reveal",
+    TRANSACTION = "transaction",
+    ACTIVATION = "activate_account",
+    ATTESTATION = "attestation",
+    ENDORSEMENT = "endorsement",
+    PREATTESTATION = "preattestation",
+    PREENDORSEMENT = "preendorsement",
+    SET_DEPOSITS_LIMIT = "set_deposits_limit",
+    DOUBLE_PREATTESTATION_EVIDENCE = "double_preattestation_evidence",
+    DOUBLE_PREENDORSEMENT_EVIDENCE = "double_preendorsement_evidence",
+    ATTESTATION_WITH_DAL = "attestation_with_dal",
+    ENDORSEMENT_WITH_DAL = "endorsement_with_dal",
+    SEED_NONCE_REVELATION = "seed_nonce_revelation",
+    DOUBLE_ATTESTATION_EVIDENCE = "double_attestation_evidence",
+    DOUBLE_ENDORSEMENT_EVIDENCE = "double_endorsement_evidence",
+    DOUBLE_BAKING_EVIDENCE = "double_baking_evidence",
+    PROPOSALS = "proposals",
+    BALLOT = "ballot",
+    FAILING_NOOP = "failing_noop",
+    REGISTER_GLOBAL_CONSTANT = "register_global_constant",
+    TRANSFER_TICKET = "transfer_ticket",
+    INCREASE_PAID_STORAGE = "increase_paid_storage",
+    UPDATE_CONSENSUS_KEY = "update_consensus_key",
+    DRAIN_DELEGATE = "drain_delegate",
+    VDF_REVELATION = "vdf_revelation",
+    EVENT = "event",
+    TICKET_UPDATES = "ticket_updates",
+    SMART_ROLLUP_ORIGINATE = "smart_rollup_originate",
+    SMART_ROLLUP_ADD_MESSAGES = "smart_rollup_add_messages",
+    SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE = "smart_rollup_execute_outbox_message",
+    SMART_ROLLUP_PUBLISH = "smart_rollup_publish",
+    SMART_ROLLUP_CEMENT = "smart_rollup_cement",
+    SMART_ROLLUP_RECOVER_BOND = "smart_rollup_recover_bond",
+    SMART_ROLLUP_REFUTE = "smart_rollup_refute",
+    SMART_ROLLUP_TIMEOUT = "smart_rollup_timeout",
+    DAL_PUBLISH_COMMITMENT = "dal_publish_commitment",
+    DAL_ENTRAPMENT_EVIDENCE = "dal_entrapment_evidence",
+    PREATTESTATIONS_AGGREGATE = "preattestations_aggregate",
+    ATTESTATIONS_AGGREGATE = "attestations_aggregate",
+    UPDATE_COMPANION_KEY = "update_companion_key",
+    DOUBLE_CONSENSUS_OPERATION_EVIDENCE = "double_consensus_operation_evidence"
+}

package/dist/types/taquito-rpc/src/rpc-client-interface.d.ts

@@ -0,0 +1,126 @@
+import { BakingRightsQueryArguments, BakingRightsResponse, BalanceResponse, UnstakeRequestsResponse, BallotListResponse, BallotsResponse, BigMapResponse, BlockHeaderResponse, BlockMetadata, BlockResponse, ConstantsResponse, ContractResponse, CurrentProposalResponse, CurrentQuorumResponse, DelegateResponse, DelegatesResponse, AttestationRightsQueryArguments, AttestationRightsResponse, EntrypointsResponse, ForgeOperationsParams, ManagerKeyResponse, OperationHash, PackDataParams, PreapplyParams, PreapplyResponse, ProposalsResponse, ProtocolsResponse, RPCRunCodeParam, RPCRunScriptViewParam, RPCRunViewParam, RunCodeResult, RunScriptViewResult, RunViewResult, SaplingDiffResponse, ScriptResponse, StorageResponse, UnparsingMode, VotesListingsResponse, VotingInfoResponse, VotingPeriodBlockResult, TicketTokenParams, AllTicketBalances, PendingOperationsV2, PendingOperationsQueryArguments, MempoolFilterQueryArguments, MempoolFilterResponse, RPCSimulateOperationParam, AILaunchCycleResponse, AllDelegatesQueryArguments, ProtocolActivationsResponse, ActiveStakingParametersResponse, PendingStakingParametersResponse, DestinationIndexResponse } from './types';
+export interface RPCOptions {
+    block: string;
+    version?: 1 | '1';
+}
+export declare const defaultChain = "main";
+export declare const defaultRPCOptions: RPCOptions;
+export interface RpcClientInterface {
+    getBlockHash(options?: RPCOptions): Promise<string>;
+    getLiveBlocks(options?: RPCOptions): Promise<string[]>;
+    getBalance(address: string, options?: RPCOptions): Promise<BalanceResponse>;
+    getSpendable(address: string, options?: RPCOptions): Promise<BalanceResponse>;
+    getBalanceAndFrozenBonds(address: string, options?: RPCOptions): Promise<BalanceResponse>;
+    getSpendableAndFrozenBonds(address: string, options?: RPCOptions): Promise<BalanceResponse>;
+    getFullBalance(address: string, options?: RPCOptions): Promise<BalanceResponse>;
+    getStakedBalance(address: string, options?: RPCOptions): Promise<BalanceResponse>;
+    getUnstakedFinalizableBalance(address: string, options?: RPCOptions): Promise<BalanceResponse>;
+    getUnstakedFrozenBalance(address: string, options?: RPCOptions): Promise<BalanceResponse>;
+    getUnstakeRequests(address: string, options?: RPCOptions): Promise<UnstakeRequestsResponse>;
+    getStorage(address: string, options?: RPCOptions): Promise<StorageResponse>;
+    getScript(address: string, options?: RPCOptions): Promise<ScriptResponse>;
+    getNormalizedScript(address: string, unparsingMode?: UnparsingMode, options?: RPCOptions): Promise<ScriptResponse>;
+    getContract(address: string, options?: RPCOptions): Promise<ContractResponse>;
+    getManagerKey(address: string, options?: RPCOptions): Promise<ManagerKeyResponse>;
+    getDelegate(address: string, options?: RPCOptions): Promise<DelegateResponse>;
+    getBigMapExpr(id: string, expr: string, options?: RPCOptions): Promise<BigMapResponse>;
+    getAllDelegates(args: AllDelegatesQueryArguments, options?: RPCOptions): Promise<string[]>;
+    getDelegates(address: string, options?: RPCOptions): Promise<DelegatesResponse>;
+    getVotingInfo(address: string, options?: RPCOptions): Promise<VotingInfoResponse>;
+    getConstants(options?: RPCOptions): Promise<ConstantsResponse>;
+    getBlock(options?: RPCOptions): Promise<BlockResponse>;
+    getBlockHeader(options?: RPCOptions): Promise<BlockHeaderResponse>;
+    getBlockMetadata(options?: RPCOptions): Promise<BlockMetadata>;
+    getBakingRights(args: BakingRightsQueryArguments, options?: RPCOptions): Promise<BakingRightsResponse>;
+    getAttestationRights(args: AttestationRightsQueryArguments, options?: RPCOptions): Promise<AttestationRightsResponse>;
+    getBallotList(options?: RPCOptions): Promise<BallotListResponse>;
+    getBallots(options?: RPCOptions): Promise<BallotsResponse>;
+    getCurrentProposal(options?: RPCOptions): Promise<CurrentProposalResponse>;
+    getCurrentQuorum(options?: RPCOptions): Promise<CurrentQuorumResponse>;
+    getVotesListings(options?: RPCOptions): Promise<VotesListingsResponse>;
+    getProposals(options?: RPCOptions): Promise<ProposalsResponse>;
+    forgeOperations(data: ForgeOperationsParams, options?: RPCOptions): Promise<string>;
+    injectOperation(signedOpBytes: string): Promise<OperationHash>;
+    preapplyOperations(ops: PreapplyParams, options?: RPCOptions): Promise<PreapplyResponse[]>;
+    getEntrypoints(contract: string, options?: RPCOptions): Promise<EntrypointsResponse>;
+    simulateOperation(op: RPCSimulateOperationParam, options?: RPCOptions): Promise<PreapplyResponse>;
+    runCode(code: RPCRunCodeParam, options?: RPCOptions): Promise<RunCodeResult>;
+    runScriptView(viewScriptParams: RPCRunScriptViewParam, options?: RPCOptions): Promise<RunScriptViewResult>;
+    runView(viewParams: RPCRunViewParam, options?: RPCOptions): Promise<RunViewResult>;
+    getChainId(): Promise<string>;
+    packData(data: PackDataParams, options?: RPCOptions): Promise<{
+        packed: string;
+        gas: BigNumber | 'unaccounted' | undefined;
+    }>;
+    getRpcUrl(): string;
+    getCurrentPeriod(options?: RPCOptions): Promise<VotingPeriodBlockResult>;
+    getSuccessorPeriod(options?: RPCOptions): Promise<VotingPeriodBlockResult>;
+    getSaplingDiffById(id: string, options?: RPCOptions): Promise<SaplingDiffResponse>;
+    getSaplingDiffByContract(contract: string, options?: RPCOptions): Promise<SaplingDiffResponse>;
+    getProtocols(options?: RPCOptions): Promise<ProtocolsResponse>;
+    getProtocolActivations(protocol?: string): Promise<ProtocolActivationsResponse>;
+    getStorageUsedSpace(contract: string, options?: RPCOptions): Promise<string>;
+    getStoragePaidSpace(contract: string, options?: RPCOptions): Promise<string>;
+    getTicketBalance(contract: string, ticket: TicketTokenParams, options?: RPCOptions): Promise<string>;
+    getAllTicketBalances(contract: string, options?: RPCOptions): Promise<AllTicketBalances>;
+    getAdaptiveIssuanceLaunchCycle(options?: RPCOptions): Promise<AILaunchCycleResponse>;
+    getPendingOperations(args: PendingOperationsQueryArguments): Promise<PendingOperationsV2>;
+    getMempoolFilter(args?: MempoolFilterQueryArguments): Promise<MempoolFilterResponse>;
+    getActiveStakingParameters(delegate: string, options?: RPCOptions): Promise<ActiveStakingParametersResponse>;
+    getPendingStakingParameters(delegate: string, options?: RPCOptions): Promise<PendingStakingParametersResponse>;
+    getDestinationIndex(destination: string, options?: RPCOptions): Promise<DestinationIndexResponse>;
+}
+export declare enum RPCMethodName {
+    GET_BAKING_RIGHTS = "getBakingRights",
+    GET_BALLOTS = "getBallots",
+    GET_BALLOT_LIST = "getBallotList",
+    GET_BIG_MAP_EXPR = "getBigMapExpr",
+    GET_BLOCK_HASH = "getBlockHash",
+    GET_BLOCK = "getBlock",
+    GET_BLOCK_HEADER = "getBlockHeader",
+    GET_BLOCK_METADATA = "getBlockMetadata",
+    GET_BALANCE = "getBalance",
+    GET_SPENDABLE = "getSpendable",
+    GET_BALANCE_AND_FROZEN_BONDS = "getBalanceAndFrozenBonds",
+    GET_SPENDABLE_AND_FROZEN_BONDS = "getSpendableAndFrozenBonds",
+    GET_FULL_BALANCE = "getFullBalance",
+    GET_STAKED_BALANCE = "getStakedBalance",
+    GET_UNSTAKED_FINALIZABLE_BALANCE = "getUnstakedFinalizableBalance",
+    GET_UNSTAKED_FROZEN_BALANCE = "getUnstakedFrozenBalance",
+    GET_UNSTAKE_REQUESTS = "getUnstakeRequests",
+    GET_CHAIN_ID = "getChainId",
+    GET_CONSTANTS = "getConstants",
+    GET_CONTRACT = "getContract",
+    GET_CURRENT_PERIOD = "getCurrentPeriod",
+    GET_CURRENT_PROPOSAL = "getCurrentProposal",
+    GET_CURRENT_QUORUM = "getCurrentQuorum",
+    GET_DELEGATE = "getDelegate",
+    GET_ALL_DELEGATES = "getAllDelegates",
+    GET_DELEGATES = "getDelegates",
+    GET_VOTING_INFO = "getVotingInfo",
+    GET_ACTIVE_STAKING_PARAMETERS = "getActiveStakingParameters",
+    GET_PENDING_STAKING_PARAMETERS = "getPendingStakingParameters",
+    GET_ATTESTATION_RIGHTS = "getAttestationRights",
+    GET_ENTRYPOINTS = "getEntrypoints",
+    GET_LIVE_BLOCKS = "getLiveBlocks",
+    GET_MANAGER_KEY = "getManagerKey",
+    GET_NORMALIZED_SCRIPT = "getNormalizedScript",
+    GET_PROPOSALS = "getProposals",
+    GET_PROTOCOLS = "getProtocols",
+    GET_SAPLING_DIFF_BY_CONTRACT = "getSaplingDiffByContract",
+    GET_PROTOCOL_ACTIVATIONS = "getProtocolActivations",
+    GET_SAPLING_DIFF_BY_ID = "getSaplingDiffById",
+    GET_SCRIPT = "getScript",
+    GET_STORAGE = "getStorage",
+    GET_SUCCESSOR_PERIOD = "getSuccessorPeriod",
+    GET_VOTES_LISTINGS = "getVotesListings",
+    PACK_DATA = "packData",
+    GET_STORAGE_USED_SPACE = "getStorageUsedSpace",
+    GET_STORAGE_PAID_SPACE = "getStoragePaidSpace",
+    GET_TICKET_BALANCE = "getTicketBalance",
+    GET_ALL_TICKET_BALANCES = "getAllTicketBalances",
+    GET_ADAPTIVE_ISSUANCE_LAUNCH_CYCLE = "getAdaptiveIssuanceLaunchCycle",
+    GET_PENDING_OPERATIONS = "getPendingOperations",
+    GET_MEMPOOL_FILTER = "getMempoolFilter",
+    GET_DESTINATION_INDEX = "getDestinationIndex"
+}