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

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

@@ -1,363 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Provider = void 0;
-const http_utils_1 = require("@taquito/http-utils");
-const types_1 = require("./operations/types");
-const errors_1 = require("./operations/errors");
-const prepare_1 = require("./contract/prepare");
-const rpc_1 = require("@taquito/rpc");
-const utils_1 = require("@taquito/utils");
-class Provider {
-    parseRpcErrors(error) {
-        if (!(error instanceof http_utils_1.HttpResponseError)) {
-            return [];
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(error.body);
-        }
-        catch {
-            return [];
-        }
-        if (!Array.isArray(parsed)) {
-            return [];
-        }
-        return parsed.filter((value) => {
-            return typeof value === 'object' && value !== null;
-        });
-    }
-    toBigInt(value) {
-        if (typeof value === 'bigint') {
-            return value;
-        }
-        if (typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value)) {
-            return BigInt(value);
-        }
-        if (typeof value === 'string' && /^-?\d+$/.test(value)) {
-            return BigInt(value);
-        }
-        if (typeof value === 'object' && value !== null && 'toString' in value) {
-            const normalized = value.toString();
-            if (/^-?\d+$/.test(normalized)) {
-                return BigInt(normalized);
-            }
-        }
-    }
-    parseCounterInThePastAdjustments(error) {
-        return this.parseRpcErrors(error)
-            .filter((value) => {
-            const id = value.id;
-            const contract = value.contract;
-            const expected = value.expected;
-            const found = value.found;
-            return (typeof id === 'string' &&
-                id.endsWith('contract.counter_in_the_past') &&
-                typeof contract === 'string' &&
-                typeof expected === 'string' &&
-                typeof found === 'string');
-        })
-            .map((value) => ({
-            contract: value.contract,
-            expected: BigInt(value.expected),
-            found: BigInt(value.found),
-        }))
-            .filter((value) => value.expected > value.found);
-    }
-    hasGasLimitTooHighAndBlockExhausted(error) {
-        const ids = this.parseRpcErrors(error)
-            .map((value) => value.id)
-            .filter((value) => typeof value === 'string');
-        return (ids.some((id) => id.endsWith('gas_limit_too_high')) &&
-            ids.some((id) => id.endsWith('gas_exhausted.block')));
-    }
-    async patchSimulationGasLimits(op, error, gasLimitPatchableIndexes) {
-        if (!this.hasGasLimitTooHighAndBlockExhausted(error)) {
-            return;
-        }
-        if (!Array.isArray(op.operation.contents)) {
-            return;
-        }
-        const constants = await this.context.readProvider.getProtocolConstants('head');
-        const hardGasLimitPerOperation = this.toBigInt(constants.hard_gas_limit_per_operation);
-        const hardGasLimitPerBlock = this.toBigInt(constants.hard_gas_limit_per_block);
-        const zero = BigInt(0);
-        if (typeof hardGasLimitPerOperation === 'undefined' ||
-            typeof hardGasLimitPerBlock === 'undefined' ||
-            hardGasLimitPerOperation <= zero ||
-            hardGasLimitPerBlock <= zero) {
-            return;
-        }
-        const contents = op.operation.contents.map((content) => ({ ...content }));
-        const adjustableIndexes = gasLimitPatchableIndexes && gasLimitPatchableIndexes.length > 0
-            ? gasLimitPatchableIndexes.filter((index) => index >= 0 && index < contents.length)
-            : [];
-        let explicitGasLimitTotal = zero;
-        for (const [index, content] of contents.entries()) {
-            const kind = content.kind;
-            const gasLimit = this.toBigInt(content.gas_limit);
-            if (typeof gasLimit === 'undefined') {
-                continue;
-            }
-            if (adjustableIndexes.length === 0) {
-                if (kind !== 'reveal' && gasLimit >= hardGasLimitPerOperation) {
-                    adjustableIndexes.push(index);
-                    continue;
-                }
-            }
-            else if (adjustableIndexes.includes(index)) {
-                continue;
-            }
-            explicitGasLimitTotal += gasLimit;
-        }
-        if (adjustableIndexes.length === 0) {
-            return;
-        }
-        // Mirror octez-client's `may_patch_limits` logic in injection.ml:
-        // only rebalance manager operations whose gas limit was auto-assigned for
-        // simulation, while treating reveal and user-specified gas limits as already
-        // consuming part of the block budget.
-        const remainingBlockGas = hardGasLimitPerBlock - explicitGasLimitTotal;
-        const evenlyDistributedGas = remainingBlockGas > zero ? remainingBlockGas / BigInt(adjustableIndexes.length) : zero;
-        const patchedGasLimit = evenlyDistributedGas > hardGasLimitPerOperation
-            ? hardGasLimitPerOperation
-            : evenlyDistributedGas;
-        let patched = false;
-        for (const index of adjustableIndexes) {
-            const content = contents[index];
-            const currentGasLimit = this.toBigInt(content.gas_limit);
-            if (currentGasLimit === patchedGasLimit) {
-                continue;
-            }
-            contents[index].gas_limit = patchedGasLimit.toString();
-            patched = true;
-        }
-        if (!patched) {
-            return;
-        }
-        return {
-            ...op,
-            operation: {
-                ...op.operation,
-                contents,
-            },
-        };
-    }
-    patchSimulationCounters(op, adjustments) {
-        if (adjustments.length === 0) {
-            return;
-        }
-        if (!Array.isArray(op.operation.contents)) {
-            return;
-        }
-        const contents = op.operation.contents.map((content) => ({ ...content }));
-        let patched = false;
-        for (const adjustment of adjustments) {
-            const delta = adjustment.expected - adjustment.found;
-            for (const content of contents) {
-                const source = content.source;
-                const counter = content.counter;
-                if (source !== adjustment.contract || typeof counter === 'undefined') {
-                    continue;
-                }
-                const contentCounter = BigInt(String(counter));
-                if (contentCounter < adjustment.found) {
-                    continue;
-                }
-                content.counter = (contentCounter + delta).toString();
-                patched = true;
-            }
-        }
-        if (!patched) {
-            return;
-        }
-        return {
-            ...op,
-            operation: {
-                ...op.operation,
-                contents,
-            },
-        };
-    }
-    get rpc() {
-        return this.context.rpc;
-    }
-    get signer() {
-        return this.context.signer;
-    }
-    constructor(context) {
-        this.context = context;
-    }
-    async forge({ opOb: { branch, contents, protocol }, counter }) {
-        const forgedBytes = await this.context.forger.forge({ branch, contents });
-        return {
-            opbytes: forgedBytes,
-            opOb: {
-                branch,
-                contents,
-                protocol,
-            },
-            counter,
-        };
-    }
-    async estimate({ fee, gasLimit, storageLimit, ...rest }, estimator) {
-        let calculatedFee = fee;
-        let calculatedGas = gasLimit;
-        let calculatedStorage = storageLimit;
-        if (calculatedFee && calculatedFee % 1 !== 0) {
-            throw new errors_1.InvalidEstimateValueError(`Fee value must not be a decimal: ${calculatedFee}`);
-        }
-        if (calculatedGas && calculatedGas % 1 !== 0) {
-            throw new errors_1.InvalidEstimateValueError(`Gas Limit value must not be a decimal: ${calculatedGas}`);
-        }
-        if (calculatedStorage && calculatedStorage % 1 !== 0) {
-            throw new errors_1.InvalidEstimateValueError(`Storage Limit value must not be a decimal: ${calculatedStorage}`);
-        }
-        if (fee === undefined || gasLimit === undefined || storageLimit === undefined) {
-            const estimation = await estimator({ fee, gasLimit, storageLimit, ...rest });
-            calculatedFee ?? (calculatedFee = estimation.suggestedFeeMutez);
-            calculatedGas ?? (calculatedGas = estimation.gasLimit);
-            calculatedStorage ?? (calculatedStorage = estimation.storageLimit);
-        }
-        return {
-            fee: calculatedFee,
-            gasLimit: calculatedGas,
-            storageLimit: calculatedStorage,
-        };
-    }
-    async getRPCOp(param) {
-        switch (param.kind) {
-            case rpc_1.OpKind.TRANSACTION:
-                return (0, prepare_1.createTransferOperation)({
-                    ...param,
-                });
-            case rpc_1.OpKind.ORIGINATION:
-                return (0, prepare_1.createOriginationOperation)(await this.context.parser.prepareCodeOrigination({
-                    ...param,
-                }));
-            case rpc_1.OpKind.DELEGATION:
-                return (0, prepare_1.createSetDelegateOperation)({
-                    ...param,
-                });
-            case rpc_1.OpKind.REGISTER_GLOBAL_CONSTANT:
-                return (0, prepare_1.createRegisterGlobalConstantOperation)({
-                    ...param,
-                });
-            case rpc_1.OpKind.INCREASE_PAID_STORAGE:
-                return (0, prepare_1.createIncreasePaidStorageOperation)({
-                    ...param,
-                });
-            case rpc_1.OpKind.UPDATE_CONSENSUS_KEY:
-                return (0, prepare_1.createUpdateConsensusKeyOperation)({
-                    ...param,
-                });
-            case rpc_1.OpKind.UPDATE_COMPANION_KEY:
-                return (0, prepare_1.createUpdateCompanionKeyOperation)({
-                    ...param,
-                });
-            case rpc_1.OpKind.TRANSFER_TICKET:
-                return (0, prepare_1.createTransferTicketOperation)({
-                    ...param,
-                });
-            case rpc_1.OpKind.SMART_ROLLUP_ADD_MESSAGES:
-                return (0, prepare_1.createSmartRollupAddMessagesOperation)({
-                    ...param,
-                });
-            case rpc_1.OpKind.SMART_ROLLUP_ORIGINATE:
-                return (0, prepare_1.createSmartRollupOriginateOperation)({
-                    ...param,
-                });
-            case rpc_1.OpKind.SMART_ROLLUP_EXECUTE_OUTBOX_MESSAGE:
-                return (0, prepare_1.createSmartRollupExecuteOutboxMessageOperation)({
-                    ...param,
-                });
-            default:
-                throw new utils_1.InvalidOperationKindError(param.kind);
-        }
-    }
-    async simulate(op, preparedOperation) {
-        const gasLimitPatchableIndexes = preparedOperation?.simulation?.gasLimitPatchableIndexes;
-        try {
-            return {
-                opResponse: await this.rpc.simulateOperation(op),
-                op,
-                context: this.context.clone(),
-            };
-        }
-        catch (error) {
-            const adjustments = this.parseCounterInThePastAdjustments(error);
-            const patchedOp = this.patchSimulationCounters(op, adjustments);
-            if (patchedOp) {
-                try {
-                    return {
-                        opResponse: await this.rpc.simulateOperation(patchedOp),
-                        op: patchedOp,
-                        context: this.context.clone(),
-                    };
-                }
-                catch (counterRetryError) {
-                    const gasPatchedOp = await this.patchSimulationGasLimits(patchedOp, counterRetryError, gasLimitPatchableIndexes);
-                    if (!gasPatchedOp) {
-                        throw counterRetryError;
-                    }
-                    return {
-                        opResponse: await this.rpc.simulateOperation(gasPatchedOp),
-                        op: gasPatchedOp,
-                        context: this.context.clone(),
-                    };
-                }
-            }
-            const gasPatchedOp = await this.patchSimulationGasLimits(op, error, gasLimitPatchableIndexes);
-            if (!gasPatchedOp) {
-                throw error;
-            }
-            return {
-                opResponse: await this.rpc.simulateOperation(gasPatchedOp),
-                op: gasPatchedOp,
-                context: this.context.clone(),
-            };
-        }
-    }
-    async isRevealOpNeeded(op, pkh) {
-        return !(await this.isAccountRevealRequired(pkh)) || !this.isRevealRequiredForOpType(op)
-            ? false
-            : true;
-    }
-    async isAccountRevealRequired(publicKeyHash) {
-        return !(await this.context.readProvider.isAccountRevealed(publicKeyHash, 'head'));
-    }
-    isRevealRequiredForOpType(op) {
-        let opRequireReveal = false;
-        for (const operation of op) {
-            if ((0, types_1.isOpRequireReveal)(operation)) {
-                opRequireReveal = true;
-            }
-        }
-        return opRequireReveal;
-    }
-    async signAndInject(forgedBytes) {
-        const signed = await this.signer.sign(forgedBytes.opbytes, new Uint8Array([3]));
-        forgedBytes.opbytes = signed.sbytes;
-        forgedBytes.opOb.signature = signed.prefixSig;
-        const opResponse = [];
-        const results = await this.rpc.preapplyOperations([forgedBytes.opOb]);
-        if (!Array.isArray(results)) {
-            throw new errors_1.TezosPreapplyFailureError(results);
-        }
-        for (let i = 0; i < results.length; i++) {
-            for (let j = 0; j < results[i].contents.length; j++) {
-                opResponse.push(results[i].contents[j]);
-            }
-        }
-        const errors = (0, errors_1.flattenErrors)(results);
-        if (errors.length) {
-            throw new errors_1.TezosOperationError(errors, 'Error occurred during validation simulation of operation', opResponse);
-        }
-        return {
-            hash: await this.context.injector.inject(forgedBytes.opbytes),
-            forgedBytes,
-            opResponse,
-            context: this.context.clone(),
-        };
-    }
-}
-exports.Provider = Provider;

package/dist/lib/taquito/src/read-provider/interface.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/taquito/src/read-provider/rpc-read-adapter.js

@@ -1,183 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RpcReadAdapter = void 0;
-/**
- * Converts calls from TzReadProvider into calls to the wrapped RpcClient in a format it can understand.
- */
-class RpcReadAdapter {
-    constructor(rpc) {
-        this.rpc = rpc;
-    }
-    /**
-     * 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
-     */
-    async getBalance(address, block) {
-        return this.rpc.getBalance(address, { block: String(block) });
-    }
-    /**
-     * 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
-     */
-    async getSpendable(address, block) {
-        return this.rpc.getSpendable(address, { block: String(block) });
-    }
-    /**
-     * 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
-     */
-    async getDelegate(address, block) {
-        return this.rpc.getDelegate(address, { block: String(block) });
-    }
-    /**
-     * Access the next protocol hash
-     * @param block from which we want to retrieve the next protocol hash
-     */
-    async getNextProtocol(block) {
-        const protocols = await this.rpc.getProtocols({ block: String(block) });
-        return protocols.next_protocol;
-    }
-    /**
-     * Access protocol constants used in Taquito
-     * @param block from which we want to retrieve the constants
-     */
-    async getProtocolConstants(block) {
-        const { time_between_blocks, minimal_block_delay, hard_gas_limit_per_operation, hard_gas_limit_per_block, hard_storage_limit_per_operation, cost_per_byte, smart_rollup_origination_size, } = await this.rpc.getConstants({ block: String(block) });
-        return {
-            time_between_blocks,
-            minimal_block_delay,
-            hard_gas_limit_per_operation,
-            hard_gas_limit_per_block,
-            hard_storage_limit_per_operation,
-            cost_per_byte,
-            smart_rollup_origination_size,
-        };
-    }
-    /**
-     * 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
-     */
-    async getScript(contract, block) {
-        const { script } = await this.rpc.getContract(contract, { block: String(block) });
-        return script;
-    }
-    /**
-     * Access the storage value 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
-     */
-    async getStorage(contract, block) {
-        return this.rpc.getStorage(contract, { block: String(block) });
-    }
-    /**
-     * Access the block hash
-     */
-    async getBlockHash(block) {
-        const { hash } = await this.rpc.getBlockHeader({ block: String(block) });
-        return hash;
-    }
-    /**
-     * Access the block level
-     */
-    async getBlockLevel(block) {
-        const { level } = await this.rpc.getBlockHeader({ block: String(block) });
-        return level;
-    }
-    /**
-     * 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
-     */
-    async getCounter(pkh, block) {
-        const { counter } = await this.rpc.getContract(pkh, { block: String(block) });
-        return counter || '0';
-    }
-    /**
-     * 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")
-     */
-    async getBlockTimestamp(block) {
-        const { timestamp } = await this.rpc.getBlockHeader({ block: String(block) });
-        return timestamp;
-    }
-    /**
-     * 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
-     */
-    async getBigMapValue(bigMapQuery, block) {
-        return this.rpc.getBigMapExpr(bigMapQuery.id, bigMapQuery.expr, {
-            block: String(block),
-        });
-    }
-    /**
-     * 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
-     */
-    async getSaplingDiffById(saplingStateQuery, block) {
-        return this.rpc.getSaplingDiffById(saplingStateQuery.id, { block: String(block) });
-    }
-    /**
-     * 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
-     */
-    async getSaplingDiffByContract(contractAddress, block) {
-        return this.rpc.getSaplingDiffByContract(contractAddress, { block: String(block) });
-    }
-    /**
-     * Return the list of entrypoints of the contract
-     * @param contract address of the contract we want to get the entrypoints of
-     */
-    async getEntrypoints(contract) {
-        return this.rpc.getEntrypoints(contract);
-    }
-    /**
-     * Access the chain id
-     */
-    async getChainId() {
-        return this.rpc.getChainId();
-    }
-    /**
-     * Indicate if an account is revealed
-     * @param publicKeyHash of the account
-     * @param block from which we want to know if the account is revealed
-     */
-    async isAccountRevealed(publicKeyHash, block) {
-        const manager = await this.rpc.getManagerKey(publicKeyHash, { block: String(block) });
-        const haveManager = manager && typeof manager === 'object' ? !!manager.key : !!manager;
-        return haveManager;
-    }
-    /**
-     * Return all the information about a block
-     * @param block from which we want to retrieve the information
-     */
-    async getBlock(block) {
-        return this.rpc.getBlock({ block: String(block) });
-    }
-    /**
-     * 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) {
-        return this.rpc.getLiveBlocks({ block: String(block) });
-    }
-    /**
-     * 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) {
-        return this.rpc.getAdaptiveIssuanceLaunchCycle({ block: String(block) });
-    }
-}
-exports.RpcReadAdapter = RpcReadAdapter;

package/dist/lib/taquito/src/signer/errors.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnconfiguredSignerError = void 0;
-const core_1 = require("@taquito/core");
-/**
- *  @category Error
- *  Error that indicates no signer has been configured in the TezosToolkit instance
- */
-class UnconfiguredSignerError extends core_1.TezosToolkitConfigError {
-    constructor() {
-        super();
-        this.name = 'UnconfiguredSignerError';
-        this.message =
-            'No signer has been configured. Please configure one by calling setProvider({signer}) on your TezosToolkit instance.';
-    }
-}
-exports.UnconfiguredSignerError = UnconfiguredSignerError;

package/dist/lib/taquito/src/signer/noop.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NoopSigner = void 0;
-const errors_1 = require("./errors");
-/**
- * Default signer implementation which does nothing and produce invalid signature
- * @throw {@link UnconfiguredSignerError}
- */
-class NoopSigner {
-    async publicKey() {
-        throw new errors_1.UnconfiguredSignerError();
-    }
-    async publicKeyHash() {
-        throw new errors_1.UnconfiguredSignerError();
-    }
-    async secretKey() {
-        throw new errors_1.UnconfiguredSignerError();
-    }
-    async sign(_bytes, _watermark) {
-        throw new errors_1.UnconfiguredSignerError();
-    }
-}
-exports.NoopSigner = NoopSigner;

package/dist/lib/taquito/src/subscribe/create-observable-from-subscription.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createObservableFromSubscription = createObservableFromSubscription;
-const rxjs_1 = require("rxjs");
-function createObservableFromSubscription(sub) {
-    return new rxjs_1.Observable((subscriber) => {
-        sub.on('data', (data) => {
-            subscriber.next(data);
-        });
-        sub.on('error', (error) => {
-            subscriber.error(error);
-        });
-        sub.on('close', () => {
-            subscriber.complete();
-        });
-        return () => {
-            sub.close();
-        };
-    });
-}

package/dist/lib/taquito/src/subscribe/errors.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidFilterExpressionError = exports.UnsupportedEventError = void 0;
-const core_1 = require("@taquito/core");
-/**
- *  @category Error
- *  Error that indicates an unsupported event being passed or used
- */
-class UnsupportedEventError extends core_1.ParameterValidationError {
-    constructor(type) {
-        super();
-        this.type = type;
-        this.name = 'UnsupportedEventError';
-        this.message = `Unsupported event type "${type}" expecting one of the "data", "error", or "close".`;
-    }
-}
-exports.UnsupportedEventError = UnsupportedEventError;
-/**
- *  @category Error
- *  Error that indicates an invalid filter expression being passed or used
- */
-class InvalidFilterExpressionError extends core_1.ParameterValidationError {
-    constructor(invalidExpression) {
-        super();
-        this.invalidExpression = invalidExpression;
-        this.name = 'InvalidFilterExpressionError';
-        this.message = `Invalid filter expression expecting the object to contain either and/or property`;
-    }
-}
-exports.InvalidFilterExpressionError = InvalidFilterExpressionError;