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

package/dist/lib/taquito/src/wallet/wallet.js

@@ -1,445 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Wallet = exports.WalletOperationBatch = void 0;
-const contract_1 = require("../contract/contract");
-const types_1 = require("../operations/types");
-const core_1 = require("@taquito/core");
-const http_utils_1 = require("@taquito/http-utils");
-const utils_1 = require("@taquito/utils");
-class WalletOperationBatch {
-    constructor(walletProvider, context) {
-        this.walletProvider = walletProvider;
-        this.context = context;
-        this.operations = [];
-    }
-    /**
-     * Add a transaction operation to the batch
-     * @param params Transfer operation parameter
-     */
-    withTransfer(params) {
-        const toValidation = (0, utils_1.validateAddress)(params.to);
-        if (toValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.to, toValidation);
-        }
-        this.operations.push({ kind: types_1.OpKind.TRANSACTION, ...params });
-        return this;
-    }
-    /**
-     * Add a contract call to the batch
-     * @param params Call a contract method
-     * @param options Generic operation parameters
-     */
-    withContractCall(params, options = {}) {
-        return this.withTransfer(params.toTransferParams(options));
-    }
-    /**
-     * Add a delegation operation to the batch
-     * @param params Delegation operation parameter
-     */
-    withDelegation(params) {
-        const delegateValidation = (0, utils_1.validateAddress)(params.delegate ?? '');
-        if (params.delegate && delegateValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.delegate, delegateValidation);
-        }
-        this.operations.push({ kind: types_1.OpKind.DELEGATION, ...params });
-        return this;
-    }
-    /**
-     * Add an origination operation to the batch
-     * @param params Origination operation parameter
-     */
-    withOrigination(params) {
-        this.operations.push({ kind: types_1.OpKind.ORIGINATION, ...params });
-        return this;
-    }
-    /**
-     * Add an IncreasePaidStorage operation to the batch
-     * @param params IncreasePaidStorage operation parameter
-     */
-    withIncreasePaidStorage(params) {
-        const destinationValidation = (0, utils_1.validateAddress)(params.destination);
-        if (destinationValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.destination, destinationValidation);
-        }
-        this.operations.push({ kind: types_1.OpKind.INCREASE_PAID_STORAGE, ...params });
-        return this;
-    }
-    /**
-     * Add an TransferTicket operation to the batch
-     * @param params TransferTicket operation parameter
-     */
-    withTransferTicket(params) {
-        const destinationValidation = (0, utils_1.validateAddress)(params.destination);
-        if (destinationValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.destination, destinationValidation);
-        }
-        this.operations.push({ kind: types_1.OpKind.TRANSFER_TICKET, ...params });
-        return this;
-    }
-    /**
-     * Add a RegisterGlobalConstant operation to the batch
-     * @param params RegisterGlobalConstant operation parameter
-     */
-    withRegisterGlobalConstant(params) {
-        this.operations.push({ kind: types_1.OpKind.REGISTER_GLOBAL_CONSTANT, ...params });
-        return this;
-    }
-    async mapOperation(param) {
-        switch (param.kind) {
-            case types_1.OpKind.TRANSACTION:
-                return this.walletProvider.mapTransferParamsToWalletParams(async () => param);
-            case types_1.OpKind.ORIGINATION:
-                return this.walletProvider.mapOriginateParamsToWalletParams(async () => this.context.parser.prepareCodeOrigination({
-                    ...param,
-                }));
-            case types_1.OpKind.DELEGATION:
-                return this.walletProvider.mapDelegateParamsToWalletParams(async () => param);
-            case types_1.OpKind.INCREASE_PAID_STORAGE:
-                return this.walletProvider.mapIncreasePaidStorageWalletParams(async () => param);
-            case types_1.OpKind.REGISTER_GLOBAL_CONSTANT:
-                return this.walletProvider.mapRegisterGlobalConstantParamsToWalletParams(async () => param);
-            case types_1.OpKind.TRANSFER_TICKET:
-                return this.walletProvider.mapTransferTicketParamsToWalletParams(async () => param);
-            default:
-                throw new core_1.InvalidOperationKindError(JSON.stringify(param.kind));
-        }
-    }
-    /**
-     * Add a group operation to the batch. Operation will be applied in the order they are in the params array
-     * @param params Operations parameter
-     * @throws InvalidOperationKindError
-     */
-    with(params) {
-        for (const param of params) {
-            switch (param.kind) {
-                case types_1.OpKind.TRANSACTION:
-                    this.withTransfer(param);
-                    break;
-                case types_1.OpKind.ORIGINATION:
-                    this.withOrigination(param);
-                    break;
-                case types_1.OpKind.DELEGATION:
-                    this.withDelegation(param);
-                    break;
-                case types_1.OpKind.INCREASE_PAID_STORAGE:
-                    this.withIncreasePaidStorage(param);
-                    break;
-                case types_1.OpKind.REGISTER_GLOBAL_CONSTANT:
-                    this.withRegisterGlobalConstant(param);
-                    break;
-                case types_1.OpKind.TRANSFER_TICKET:
-                    this.withTransferTicket(param);
-                    break;
-                default:
-                    throw new core_1.InvalidOperationKindError(JSON.stringify(param.kind));
-            }
-        }
-        return this;
-    }
-    /**
-     * Submit batch operation to wallet
-     */
-    async send() {
-        const ops = [];
-        for (const op of this.operations) {
-            ops.push(await this.mapOperation(op));
-        }
-        const opHash = await this.walletProvider.sendOperations(ops);
-        return this.context.operationFactory.createBatchOperation(opHash);
-    }
-}
-exports.WalletOperationBatch = WalletOperationBatch;
-class Wallet {
-    constructor(context) {
-        this.context = context;
-        this.walletCommand = (send) => {
-            return {
-                send,
-            };
-        };
-    }
-    get walletProvider() {
-        return this.context.walletProvider;
-    }
-    /**
-     * Retrieve the PKH of the account that is currently in use by the wallet
-     * @param option Option to use while fetching the PKH.
-     * If forceRefetch is specified the wallet provider implementation will refetch the PKH from the wallet
-     */
-    async pkh({ forceRefetch } = {}) {
-        if (!this._pkh || forceRefetch) {
-            this._pkh = await this.walletProvider.getPKH();
-        }
-        return this._pkh;
-    }
-    /**
-     * Retrieve the PK of the account that is currently in use by the wallet
-     * @param option Option to use while fetching the PK.
-     * If forceRefetch is specified the wallet provider implementation will refetch the PK from the wallet
-     */
-    async pk({ forceRefetch } = {}) {
-        if (!this._pk || forceRefetch) {
-            this._pk = await this.walletProvider.getPK();
-        }
-        return this._pk;
-    }
-    /**
-     * Originate a new contract according to the script in parameters.
-     * @returns a OriginationWalletOperation promise object when followed by .send()
-     * @param params Originate operation parameter
-     */
-    originate(params) {
-        return this.walletCommand(async () => {
-            const mappedParams = await this.walletProvider.mapOriginateParamsToWalletParams(() => this.context.parser.prepareCodeOrigination({
-                ...params,
-            }));
-            const opHash = await this.walletProvider.sendOperations([mappedParams]);
-            return this.context.operationFactory.createOriginationOperation(opHash);
-        });
-    }
-    /**
-     * Set the delegate for a contract.
-     * @returns a WalletDelegateParams promise object when followed by .send()
-     * @param params operation parameter
-     */
-    setDelegate(params) {
-        const delegateValidation = (0, utils_1.validateAddress)(params.delegate ?? '');
-        if (params.delegate && delegateValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.delegate, delegateValidation);
-        }
-        return this.walletCommand(async () => {
-            const mappedParams = await this.walletProvider.mapDelegateParamsToWalletParams(async () => params);
-            const opHash = await this.walletProvider.sendOperations([mappedParams]);
-            return this.context.operationFactory.createDelegationOperation(opHash);
-        });
-    }
-    /**
-     * failing_noop operation that is guaranteed to fail. DISCLAIMER: Not all wallets support signing failing_noop operations.
-     * @returns Signature for a failing_noop
-     * @param params operation parameter
-     */
-    async signFailingNoop(params) {
-        const op = {
-            kind: types_1.OpKind.FAILING_NOOP,
-            arbitrary: params.arbitrary,
-        };
-        const hash = await this.context.readProvider.getBlockHash(params.basedOnBlock);
-        const forgedBytes = await this.context.forger.forge({
-            branch: hash,
-            contents: [op],
-        });
-        const signature = await this.walletProvider.sign(forgedBytes, Uint8Array.from([3]));
-        return {
-            signature,
-            bytes: forgedBytes,
-            signedContent: {
-                branch: hash,
-                contents: [
-                    {
-                        kind: types_1.OpKind.FAILING_NOOP,
-                        arbitrary: params.arbitrary,
-                    },
-                ],
-            },
-        };
-    }
-    /**
-     * Register the current address as delegate.
-     * @returns a DelegationWalletOperation promise object when followed by .send()
-     */
-    registerDelegate() {
-        return this.walletCommand(async () => {
-            const mappedParams = await this.walletProvider.mapDelegateParamsToWalletParams(async () => {
-                const delegate = await this.pkh();
-                return { delegate };
-            });
-            const opHash = await this.walletProvider.sendOperations([mappedParams]);
-            return this.context.operationFactory.createDelegationOperation(opHash);
-        });
-    }
-    /**
-     * Transfer tezos tokens from current address to a specific address or call a smart contract.
-     * @returns a TransactionWalletOperation promise object when followed by .send()
-     * @param params operation parameter
-     */
-    transfer(params) {
-        const toValidation = (0, utils_1.validateAddress)(params.to);
-        if (toValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.to, toValidation);
-        }
-        return this.walletCommand(async () => {
-            const mappedParams = await this.walletProvider.mapTransferParamsToWalletParams(async () => params);
-            const opHash = await this.walletProvider.sendOperations([mappedParams]);
-            return this.context.operationFactory.createTransactionOperation(opHash);
-        });
-    }
-    /**
-     * Transfer tezos tickets from current address to a specific address or a smart contract
-     * @returns a TransferTicketWalletOperation promise object when followed by .send()
-     * @param params operation parameter
-     */
-    transferTicket(params) {
-        const toValidation = (0, utils_1.validateAddress)(params.destination);
-        if (toValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.destination, toValidation);
-        }
-        return this.walletCommand(async () => {
-            const mappedParams = await this.walletProvider.mapTransferTicketParamsToWalletParams(async () => params);
-            const opHash = await this.walletProvider.sendOperations([mappedParams]);
-            return this.context.operationFactory.createTransferTicketOperation(opHash);
-        });
-    }
-    /**
-     * Stake a given amount for the source address
-     * @returns a TransactionWalletOperation promise object when followed by .send()
-     * @param params Stake pseudo-operation parameter
-     */
-    stake(params) {
-        return this.walletCommand(async () => {
-            const mappedParams = await this.walletProvider.mapStakeParamsToWalletParams(async () => {
-                const source = await this.pkh();
-                if (!params.to) {
-                    params.to = source;
-                }
-                if (params.to !== source) {
-                    throw new core_1.InvalidStakingAddressError(params.to);
-                }
-                params.parameter = { entrypoint: 'stake', value: { prim: 'Unit' } };
-                return params;
-            });
-            const opHash = await this.walletProvider.sendOperations([mappedParams]);
-            return this.context.operationFactory.createTransactionOperation(opHash);
-        });
-    }
-    /**
-     * Unstake the given amount. If "everything" is given as amount, unstakes everything from the staking balance.
-     * Unstaked tez remains frozen for a set amount of cycles (the slashing period) after the operation. Once this period is over,
-     * the operation "finalize unstake" must be called for the funds to appear in the liquid balance.
-     * @returns a TransactionWalletOperation promise object when followed by .send()
-     * @param params Unstake pseudo-operation parameter
-     */
-    unstake(params) {
-        return this.walletCommand(async () => {
-            const mappedParams = await this.walletProvider.mapUnstakeParamsToWalletParams(async () => {
-                const source = await this.pkh();
-                if (!params.to) {
-                    params.to = source;
-                }
-                if (params.to !== source) {
-                    throw new core_1.InvalidStakingAddressError(params.to);
-                }
-                params.parameter = { entrypoint: 'unstake', value: { prim: 'Unit' } };
-                return params;
-            });
-            const opHash = await this.walletProvider.sendOperations([mappedParams]);
-            return await this.context.operationFactory.createTransactionOperation(opHash);
-        });
-    }
-    /**
-     * Transfer all the finalizable unstaked funds of the source to their liquid balance
-     * @returns a TransactionWalletOperation promise object when followed by .send()
-     * @param params Finalize_unstake pseudo-operation parameter
-     */
-    finalizeUnstake(params) {
-        return this.walletCommand(async () => {
-            const mappedParams = await this.walletProvider.mapFinalizeUnstakeParamsToWalletParams(async () => {
-                const source = await this.pkh();
-                if (!params.to) {
-                    params.to = source;
-                }
-                if (!params.amount) {
-                    params.amount = 0;
-                }
-                if (params.amount !== 0) {
-                    throw new core_1.InvalidFinalizeUnstakeAmountError('Amount must be 0 to finalize unstake.');
-                }
-                params.parameter = { entrypoint: 'finalize_unstake', value: { prim: 'Unit' } };
-                return params;
-            });
-            const opHash = await this.walletProvider.sendOperations([mappedParams]);
-            return await this.context.operationFactory.createTransactionOperation(opHash);
-        });
-    }
-    /**
-     * Increase the paid storage of a smart contract.
-     * @returns a IncreasePaidStorageWalletOperation promise object when followed by .send()
-     * @param params operation parameter
-     */
-    increasePaidStorage(params) {
-        const destinationValidation = (0, utils_1.validateAddress)(params.destination);
-        if (destinationValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidAddressError(params.destination, destinationValidation);
-        }
-        return this.walletCommand(async () => {
-            const mappedParams = await this.walletProvider.mapIncreasePaidStorageWalletParams(async () => params);
-            const opHash = await this.walletProvider.sendOperations([mappedParams]);
-            return this.context.operationFactory.createIncreasePaidStorageOperation(opHash);
-        });
-    }
-    /**
-     * 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) {
-        return this.walletCommand(async () => {
-            const mappedParams = await this.walletProvider.mapRegisterGlobalConstantParamsToWalletParams(async () => params);
-            const opHash = await this.walletProvider.sendOperations([mappedParams]);
-            return this.context.operationFactory.createRegisterGlobalConstantOperation(opHash);
-        });
-    }
-    /**
-     * 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
-     * @param params List of operation to initialize the batch with
-     */
-    batch(params) {
-        const batch = new WalletOperationBatch(this.walletProvider, this.context);
-        if (Array.isArray(params)) {
-            batch.with(params);
-        }
-        return batch;
-    }
-    /**
-     * Create an smart contract abstraction for the address specified. Calling entrypoints with the returned
-     * smart contract abstraction will leverage the wallet provider to make smart contract calls
-     * @param address Smart contract address
-     * @throws InvalidContractAddressError If the contract address is not valid
-     */
-    async at(address, contractAbstractionComposer = (x) => x, block = 'head') {
-        const addressValidation = (0, utils_1.validateContractAddress)(address);
-        if (addressValidation !== utils_1.ValidationResult.VALID) {
-            throw new core_1.InvalidContractAddressError(address, addressValidation);
-        }
-        const rpc = this.context.withExtensions().rpc;
-        const readProvider = this.context.withExtensions().readProvider;
-        const loadContractState = async (requestedBlock) => {
-            const script = await readProvider.getScript(address, requestedBlock);
-            const entrypoints = requestedBlock === 'head'
-                ? await readProvider.getEntrypoints(address)
-                : await rpc.getEntrypoints(address, { block: String(requestedBlock) });
-            return { script, entrypoints };
-        };
-        let contractState;
-        try {
-            contractState = await loadContractState(block);
-        }
-        catch (error) {
-            // Newly originated contracts can be visible at the operation's inclusion level in one RPC
-            // call and still lag on another endpoint of the same rolling node. Retry at head so
-            // wallet op.contract() behaves like octez-client, which resolves the originated contract
-            // after confirmation instead of pinning itself to a stale context forever.
-            if (block !== 'head' &&
-                error instanceof http_utils_1.HttpResponseError &&
-                error.status === http_utils_1.STATUS_CODE.NOT_FOUND) {
-                contractState = await loadContractState('head');
-            }
-            else {
-                throw error;
-            }
-        }
-        const abs = new contract_1.ContractAbstraction(address, contractState.script, this, this.context.contract, contractState.entrypoints, rpc, readProvider);
-        return contractAbstractionComposer(abs, this.context);
-    }
-}
-exports.Wallet = Wallet;