@taquito/taquito 23.0.3 → 24.0.0-beta.0

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

@@ -1,14 +1,15 @@
 import { Context } from '../context';
-import { ContractAbstraction, ContractStorageType, DefaultWalletType, SendParams } from '../contract';
-import { ContractMethod } from '../contract/contract-methods/contract-method-flat-param';
-import { ContractMethodObject } from '../contract/contract-methods/contract-method-object-param';
+import { ContractAbstraction } from '../contract/contract';
+import type { ContractStorageType, DefaultWalletType } from '../contract/contract';
+import { SendParams } from '../contract/contract-methods/contract-method-interface';
+import type { ContractMethodObject } from '../contract/contract-methods/contract-method-object-param';
 import { OpKind, withKind } from '../operations/types';
 import { OriginationWalletOperation } from './origination-operation';
-import { WalletDelegateParams, WalletFailingNoopParams, WalletIncreasePaidStorageParams, WalletOriginateParams, WalletProvider, WalletTransferParams, WalletStakeParams, WalletUnstakeParams, WalletFinalizeUnstakeParams, WalletTransferTicketParams } from './interface';
+import { WalletDelegateParams, WalletFailingNoopParams, WalletIncreasePaidStorageParams, WalletOriginateParams, WalletProvider, WalletTransferParams, WalletStakeParams, WalletUnstakeParams, WalletFinalizeUnstakeParams, WalletTransferTicketParams, WalletRegisterGlobalConstantParams } from './interface';
 export interface PKHOption {
     forceRefetch?: boolean;
 }
-export type WalletParamsWithKind = withKind<WalletTransferParams, OpKind.TRANSACTION> | withKind<WalletOriginateParams, OpKind.ORIGINATION> | withKind<WalletDelegateParams, OpKind.DELEGATION> | withKind<WalletIncreasePaidStorageParams, OpKind.INCREASE_PAID_STORAGE> | withKind<WalletTransferTicketParams, OpKind.TRANSFER_TICKET>;
+export type WalletParamsWithKind = withKind<WalletTransferParams, OpKind.TRANSACTION> | withKind<WalletOriginateParams, OpKind.ORIGINATION> | withKind<WalletDelegateParams, OpKind.DELEGATION> | withKind<WalletIncreasePaidStorageParams, OpKind.INCREASE_PAID_STORAGE> | withKind<WalletTransferTicketParams, OpKind.TRANSFER_TICKET> | withKind<WalletRegisterGlobalConstantParams, OpKind.REGISTER_GLOBAL_CONSTANT>;
 export declare class WalletOperationBatch {
     private walletProvider;
     private context;
@@ -24,7 +25,7 @@ export declare class WalletOperationBatch {
      * @param params Call a contract method
      * @param options Generic operation parameters
      */
-    withContractCall(params: ContractMethod<Wallet> | ContractMethodObject<Wallet>, options?: Partial<SendParams>): this;
+    withContractCall(params: ContractMethodObject<Wallet>, options?: Partial<SendParams>): this;
     /**
      * @description Add a delegation operation to the batch
      * @param params Delegation operation parameter
@@ -45,6 +46,11 @@ export declare class WalletOperationBatch {
      * @param param TransferTicket operation parameter
      */
     withTransferTicket(params: WalletTransferTicketParams): this;
+    /**
+     * @description Add a RegisterGlobalConstant operation to the batch
+     * @param param RegisterGlobalConstant operation parameter
+     */
+    withRegisterGlobalConstant(params: WalletRegisterGlobalConstantParams): this;
     private mapOperation;
     /**
      * @description Add a group operation to the batch. Operation will be applied in the order they are in the params array
@@ -165,6 +171,14 @@ export declare class Wallet {
     increasePaidStorage(params: WalletIncreasePaidStorageParams): {
         send: () => Promise<import("./increase-paid-storage-operation").IncreasePaidStorageWalletOperation>;
     };
+    /**
+     * @description Register a Micheline expression in a global table of constants.
+     * @returns a RegisterGlobalConstantWalletOperation promise object when followed by .send()
+     * @param params operation parameter
+     */
+    registerGlobalConstant(params: WalletRegisterGlobalConstantParams): {
+        send: () => Promise<import("./register-global-constant-operation").RegisterGlobalConstantWalletOperation>;
+    };
     /**
      * @description Create a batch of operation
      * @returns A batch object from which we can add more operation or send a command to the wallet to execute the batch
@@ -178,9 +192,4 @@ export declare class Wallet {
      * @throws {@link InvalidContractAddressError} If the contract address is not valid
      */
     at<T extends ContractAbstraction<Wallet>>(address: string, contractAbstractionComposer?: (abs: ContractAbstraction<Wallet>, context: Context) => T): Promise<T>;
-    /**
-     * @deprecated Deprecated in favor of {@link Wallet.pk} will be removed in v19.1
-     * @description Retrieve the PK of the account that is currently in use by the wallet
-     */
-    getPK(): Promise<string>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@taquito/taquito",
-  "version": "23.0.3",
+  "version": "24.0.0-beta.0",
   "description": "High level functionality that builds upon the other packages in the Tezos Typescript Library Suite.",
   "keywords": [
     "tezos",
@@ -28,7 +28,7 @@
   },
   "license": "Apache-2.0",
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "scripts": {
     "test": "jest --coverage",
@@ -77,13 +77,14 @@
     ]
   },
   "dependencies": {
-    "@taquito/core": "^23.0.3",
-    "@taquito/http-utils": "^23.0.3",
-    "@taquito/local-forging": "^23.0.3",
-    "@taquito/michel-codec": "^23.0.3",
-    "@taquito/michelson-encoder": "^23.0.3",
-    "@taquito/rpc": "^23.0.3",
-    "@taquito/utils": "^23.0.3",
+    "@taquito/core": "^24.0.0-beta.0",
+    "@taquito/http-utils": "^24.0.0-beta.0",
+    "@taquito/local-forging": "^24.0.0-beta.0",
+    "@taquito/michel-codec": "^24.0.0-beta.0",
+    "@taquito/michelson-encoder": "^24.0.0-beta.0",
+    "@taquito/rpc": "^24.0.0-beta.0",
+    "@taquito/signer": "^24.0.0-beta.0",
+    "@taquito/utils": "^24.0.0-beta.0",
     "bignumber.js": "^9.1.2",
     "rxjs": "^7.8.2"
   },
@@ -92,7 +93,7 @@
     "@types/bluebird": "^3.5.42",
     "@types/estree": "^1.0.5",
     "@types/jest": "^29.5.12",
-    "@types/node": "^18",
+    "@types/node": "^20",
     "@typescript-eslint/eslint-plugin": "^6.21.0",
     "@typescript-eslint/parser": "^6.21.0",
     "buffer": "^6.0.3",
@@ -111,6 +112,7 @@
     "rimraf": "^6.0.1",
     "rollup": "^4.22.4",
     "rollup-plugin-json": "^4.0.0",
+    "rollup-plugin-polyfill-node": "^0.13.0",
     "rollup-plugin-typescript2": "^0.36.0",
     "rx-sandbox": "^2.0.5",
     "shelljs": "^0.8.5",
@@ -125,5 +127,5 @@
     "webpack-cli": "^5.1.4",
     "webpack-subresource-integrity": "^5.1.0"
   },
-  "gitHead": "2abf349e97af45f11210b3121078b9d96699d5da"
+  "gitHead": "f212ea3edaf1fac34d738b5d00a9892ab7a3b721"
 }

package/dist/400.taquito.min.js

@@ -1 +0,0 @@
-(self.webpackChunktaquito=self.webpackChunktaquito||[]).push([[400],{6400:()=>{}}]);

package/dist/993.taquito.min.js

@@ -1 +0,0 @@
-(self.webpackChunktaquito=self.webpackChunktaquito||[]).push([[993],{5993:()=>{}}]);

package/dist/lib/contract/contract-methods/contract-method-flat-param.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContractMethod = void 0;
-const wallet_1 = require("../../wallet");
-const contract_1 = require("../contract");
-const errors_1 = require("../errors");
-/**
- * @description Utility class to send smart contract operation
- * The format for the arguments is the flattened representation
- */
-class ContractMethod {
-    constructor(provider, address, parameterSchema, name, args, isMultipleEntrypoint = true, isAnonymous = false) {
-        this.provider = provider;
-        this.address = address;
-        this.parameterSchema = parameterSchema;
-        this.name = name;
-        this.args = args;
-        this.isMultipleEntrypoint = isMultipleEntrypoint;
-        this.isAnonymous = isAnonymous;
-    }
-    validateArgs(args, schema, name) {
-        const sigs = schema.ExtractSignatures();
-        if (!sigs.find((x) => x.length === args.length)) {
-            throw new errors_1.InvalidParameterError(name, sigs, args);
-        }
-    }
-    /**
-     * @description Get the schema of the smart contract method
-     */
-    get schema() {
-        return this.isAnonymous
-            ? this.parameterSchema.ExtractSchema()[this.name]
-            : this.parameterSchema.ExtractSchema();
-    }
-    /**
-     * @description Get the signature of the smart contract method
-     */
-    getSignature() {
-        if (this.isAnonymous) {
-            const sig = this.parameterSchema.ExtractSignatures().find((x) => x[0] === this.name);
-            if (sig) {
-                sig.shift();
-                return sig;
-            }
-        }
-        else {
-            const sig = this.parameterSchema.ExtractSignatures();
-            return sig.length == 1 ? sig[0] : sig;
-        }
-    }
-    /**
-     *
-     * @description Send the smart contract operation
-     *
-     * @param Options generic operation parameter
-     */
-    send(params = {}) {
-        if (this.provider instanceof wallet_1.Wallet) {
-            return this.provider
-                .transfer(this.toTransferParams(params))
-                .send();
-        }
-        else {
-            return this.provider.transfer(this.toTransferParams(params));
-        }
-    }
-    /**
-     *
-     * @description Create transfer params to be used with TezosToolkit.contract.transfer methods
-     *
-     * @param Options generic transfer operation parameters
-     */
-    toTransferParams({ fee, gasLimit, storageLimit, source, amount = 0, mutez = false, } = {}) {
-        const fullTransferParams = {
-            to: this.address,
-            amount,
-            fee,
-            mutez,
-            source,
-            gasLimit,
-            storageLimit,
-            parameter: {
-                entrypoint: this.isMultipleEntrypoint ? this.name : contract_1.DEFAULT_SMART_CONTRACT_METHOD_NAME,
-                value: this.isAnonymous
-                    ? this.parameterSchema.Encode(this.name, ...this.args)
-                    : this.parameterSchema.Encode(...this.args),
-            },
-        };
-        return fullTransferParams;
-    }
-}
-exports.ContractMethod = ContractMethod;

package/dist/lib/contract/lambda-view.js

@@ -1,253 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("../operations/errors");
-/**
- *
- * @deprecated LambdaView has been deprecated in favor of rpc.runView to simulate calls to views following the TZIP-4 standard
- */
-class LambdaView {
-    constructor(lambdaContract, viewContract, viewMethod = 'default', contractParameter = { prim: 'Unit' }) {
-        this.lambdaContract = lambdaContract;
-        this.viewContract = viewContract;
-        this.viewMethod = viewMethod;
-        this.contractParameter = contractParameter;
-        this.voidLambda = this.createVoidLambda();
-    }
-    execute() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.lambdaContract.methods.default(this.voidLambda).send();
-            }
-            catch (ex) {
-                if (ex instanceof errors_1.TezosOperationError) {
-                    return ex.lastError.with;
-                }
-                else {
-                    throw ex;
-                }
-            }
-        });
-    }
-    createVoidLambda() {
-        const [parameter, callback] = this.getView();
-        let contractArgs = [
-            {
-                prim: 'pair',
-                args: [parameter, { prim: 'contract', args: [callback] }],
-            },
-        ];
-        if (this.viewMethod === 'default') {
-            contractArgs = [{ string: '%default' }].concat(contractArgs);
-        }
-        return [
-            { prim: 'PUSH', args: [{ prim: 'mutez' }, { int: '0' }] },
-            { prim: 'NONE', args: [{ prim: 'key_hash' }] },
-            {
-                prim: 'CREATE_CONTRACT',
-                args: [
-                    [
-                        { prim: 'parameter', args: [callback] },
-                        { prim: 'storage', args: [{ prim: 'unit' }] },
-                        {
-                            prim: 'code',
-                            args: [[{ prim: 'CAR' }, { prim: 'FAILWITH' }]],
-                        },
-                    ],
-                ],
-            },
-            {
-                prim: 'DIP',
-                args: [
-                    [
-                        {
-                            prim: 'DIP',
-                            args: [
-                                [
-                                    {
-                                        prim: 'LAMBDA',
-                                        args: [
-                                            {
-                                                prim: 'pair',
-                                                args: [{ prim: 'address' }, { prim: 'unit' }],
-                                            },
-                                            {
-                                                prim: 'pair',
-                                                args: [{ prim: 'list', args: [{ prim: 'operation' }] }, { prim: 'unit' }],
-                                            },
-                                            [
-                                                { prim: 'CAR' },
-                                                { prim: 'CONTRACT', args: [callback] },
-                                                {
-                                                    prim: 'IF_NONE',
-                                                    args: [
-                                                        [
-                                                            {
-                                                                prim: 'PUSH',
-                                                                args: [{ prim: 'string' }, { string: `Callback type unmatched` }],
-                                                            },
-                                                            { prim: 'FAILWITH' },
-                                                        ],
-                                                        [],
-                                                    ],
-                                                },
-                                                {
-                                                    prim: 'PUSH',
-                                                    args: [parameter, this.contractParameter],
-                                                },
-                                                { prim: 'PAIR' },
-                                                {
-                                                    prim: 'DIP',
-                                                    args: [
-                                                        [
-                                                            {
-                                                                prim: 'PUSH',
-                                                                args: [
-                                                                    { prim: 'address' },
-                                                                    { string: `${this.viewContract.address}%${this.viewMethod}` },
-                                                                ],
-                                                            },
-                                                            { prim: 'DUP' },
-                                                            { prim: 'CONTRACT', args: contractArgs },
-                                                            {
-                                                                prim: 'IF_NONE',
-                                                                args: [
-                                                                    [
-                                                                        {
-                                                                            prim: 'PUSH',
-                                                                            args: [
-                                                                                { prim: 'string' },
-                                                                                { string: `Contract does not exist` },
-                                                                            ],
-                                                                        },
-                                                                        { prim: 'FAILWITH' },
-                                                                    ],
-                                                                    [{ prim: 'DIP', args: [[{ prim: 'DROP' }]] }],
-                                                                ],
-                                                            },
-                                                            {
-                                                                prim: 'PUSH',
-                                                                args: [{ prim: 'mutez' }, { int: '0' }],
-                                                            },
-                                                        ],
-                                                    ],
-                                                },
-                                                { prim: 'TRANSFER_TOKENS' },
-                                                {
-                                                    prim: 'DIP',
-                                                    args: [[{ prim: 'NIL', args: [{ prim: 'operation' }] }]],
-                                                },
-                                                { prim: 'CONS' },
-                                                { prim: 'DIP', args: [[{ prim: 'UNIT' }]] },
-                                                { prim: 'PAIR' },
-                                            ],
-                                        ],
-                                    },
-                                ],
-                            ],
-                        },
-                        { prim: 'APPLY' },
-                        {
-                            prim: 'DIP',
-                            args: [
-                                [
-                                    {
-                                        prim: 'PUSH',
-                                        args: [{ prim: 'address' }, { string: this.lambdaContract.address }],
-                                    },
-                                    { prim: 'DUP' },
-                                    {
-                                        prim: 'CONTRACT',
-                                        args: [
-                                            {
-                                                prim: 'lambda',
-                                                args: [
-                                                    { prim: 'unit' },
-                                                    {
-                                                        prim: 'pair',
-                                                        args: [
-                                                            { prim: 'list', args: [{ prim: 'operation' }] },
-                                                            { prim: 'unit' },
-                                                        ],
-                                                    },
-                                                ],
-                                            },
-                                        ],
-                                    },
-                                    {
-                                        prim: 'IF_NONE',
-                                        args: [
-                                            [
-                                                {
-                                                    prim: 'PUSH',
-                                                    args: [{ prim: 'string' }, { string: `Contract does not exists` }],
-                                                },
-                                                { prim: 'FAILWITH' },
-                                            ],
-                                            [{ prim: 'DIP', args: [[{ prim: 'DROP' }]] }],
-                                        ],
-                                    },
-                                    { prim: 'PUSH', args: [{ prim: 'mutez' }, { int: '0' }] },
-                                ],
-                            ],
-                        },
-                        { prim: 'TRANSFER_TOKENS' },
-                        {
-                            prim: 'DIP',
-                            args: [[{ prim: 'NIL', args: [{ prim: 'operation' }] }]],
-                        },
-                        { prim: 'CONS' },
-                    ],
-                ],
-            },
-            { prim: 'CONS' },
-            { prim: 'DIP', args: [[{ prim: 'UNIT' }]] },
-            { prim: 'PAIR' },
-        ];
-    }
-    getView() {
-        const entrypoints = this.viewContract.entrypoints.entrypoints;
-        const entrypoint = entrypoints[this.viewMethod];
-        if (!entrypoint) {
-            throw Error(`Contract at ${this.viewContract.address} does not have entrypoint: ${this.viewMethod}`);
-        }
-        if (!('prim' in entrypoint) || !entrypoint.args) {
-            // TODO: Enhance this error message to be more descriptive
-            throw Error('Entrypoint args undefined');
-        }
-        const args = Array.from(entrypoint.args);
-        const [parameter, callbackContract] = args;
-        if ('annots' in parameter) {
-            delete parameter['annots'];
-        }
-        if (!('prim' in callbackContract) || !callbackContract.args) {
-            // TODO: Enhance this error message to be more descriptive
-            throw Error('Callback contract args undefined');
-        }
-        let message;
-        if (entrypoint.prim !== 'pair') {
-            message = `Expected {'prim': 'pair', ..} but found {'prim': ${entrypoint.prim}, ..}`;
-        }
-        else if (args.length !== 2) {
-            message = `Expected an Array of length 2, but found: ${args}`;
-        }
-        else if (callbackContract.prim !== 'contract') {
-            message = `Expected a {prim: 'contract', ...}, but found: ${callbackContract.prim}`;
-        }
-        else if (callbackContract.args && callbackContract.args.length !== 1) {
-            message = `Expected a single argument to 'contract', but found: ${callbackContract.args}`;
-        }
-        if (message)
-            throw Error(message);
-        return [parameter, callbackContract.args[0]];
-    }
-}
-exports.default = LambdaView;

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

@@ -1,43 +0,0 @@
-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 { ContractMethodInterface, SendParams } from './contract-method-interface';
-/**
- * @description Utility class to send smart contract operation
- * The format for the arguments is the flattened representation
- */
-export declare class ContractMethod<T extends ContractProvider | Wallet> implements ContractMethodInterface {
-    private provider;
-    private address;
-    private parameterSchema;
-    private name;
-    private args;
-    private isMultipleEntrypoint;
-    private isAnonymous;
-    constructor(provider: T, address: string, parameterSchema: ParameterSchema, name: string, args: any[], isMultipleEntrypoint?: boolean, isAnonymous?: boolean);
-    private validateArgs;
-    /**
-     * @description Get the schema of the smart contract method
-     */
-    get schema(): any;
-    /**
-     * @description Get the signature of the smart contract method
-     */
-    getSignature(): any[] | undefined;
-    /**
-     *
-     * @description Send the smart contract operation
-     *
-     * @param Options generic operation parameter
-     */
-    send(params?: Partial<SendParams>): Promise<T extends Wallet ? TransactionWalletOperation : TransactionOperation>;
-    /**
-     *
-     * @description Create transfer params to be used with TezosToolkit.contract.transfer methods
-     *
-     * @param Options generic transfer operation parameters
-     */
-    toTransferParams({ fee, gasLimit, storageLimit, source, amount, mutez, }?: Partial<SendParams>): TransferParams;
-}

package/dist/types/contract/lambda-view.d.ts

@@ -1,19 +0,0 @@
-import { MichelsonV1Expression } from '@taquito/rpc';
-import { Contract, ContractAbstraction, WalletContract } from './contract';
-import { ContractProvider } from './interface';
-import { Wallet } from '../wallet';
-/**
- *
- * @deprecated LambdaView has been deprecated in favor of rpc.runView to simulate calls to views following the TZIP-4 standard
- */
-export default class LambdaView {
-    private lambdaContract;
-    private viewContract;
-    readonly viewMethod: string;
-    private contractParameter;
-    readonly voidLambda: object;
-    constructor(lambdaContract: Contract | WalletContract, viewContract: ContractAbstraction<ContractProvider | Wallet>, viewMethod?: string, contractParameter?: MichelsonV1Expression);
-    execute(): Promise<any>;
-    private createVoidLambda;
-    private getView;
-}