@taquito/taquito 19.2.0 → 20.0.0-beta.0

package/README.md

@@ -7,7 +7,7 @@ The `@taquito/taquito` package contains higher-level functionality that builds u
 ## CDN Bundle
 
 ```html
-<script src="https://unpkg.com/@taquito/taquito@19.2.0/dist/taquito.min.js"
+<script src="https://unpkg.com/@taquito/taquito@20.0.0-beta.0/dist/taquito.min.js"
 crossorigin="anonymous" integrity="sha384-IxvP0ECHi5oqLyz94wF85pU9+ktcsL1HHtA42MITxZsGbsUMEu/g+0Vkjj5vqiMR"></script>
 ```
 

package/dist/lib/constants.js

@@ -71,6 +71,7 @@ var Protocols;
     Protocols["PtMumbai2"] = "PtMumbai2TmsJHNGRkD8v8YDbtao7BLUC3wjASn1inAKLFCjaH1";
     Protocols["PtNairobi"] = "PtNairobiyssHuh87hEhfVBGCVrK3WnS8Z2FT4ymB5tAa4r1nQf";
     Protocols["ProxfordY"] = "ProxfordYmVfjWnRcgjWH36fW6PArwqykTFzotUxRs6gmTcZDuH";
+    Protocols["PtParisBQ"] = "PtParisBQscdCm6Cfow6ndeU6wKJyA3aV1j4D3gQBQMsTQyJCrz";
     Protocols["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
 })(Protocols || (exports.Protocols = Protocols = {}));
 exports.protocols = {
@@ -109,6 +110,7 @@ var ChainIds;
     ChainIds["MUMBAINET2"] = "NetXgbcrNtXD2yA";
     ChainIds["NAIROBINET"] = "NetXyuzvDo2Ugzb";
     ChainIds["OXFORDNET2"] = "NetXxWsskGahzQB";
+    ChainIds["PARISNET"] = "NetXo8SqH1c38SS";
 })(ChainIds || (exports.ChainIds = ChainIds = {}));
 // A fixed fee reveal operation gasLimit accepted by both simulate and injection endpoint is between 1.2-5 times of actual gas consumption (3.5 fails occasionally with gas exhausted; 4 fails occasionally with fee too low)
 const getRevealGasLimit = (address) => Math.round((getRevealGasLimitInternal(address) * 37) / 10);

package/dist/lib/contract/rpc-contract-provider.js

@@ -302,6 +302,112 @@ class RpcContractProvider extends provider_1.Provider {
             return new transaction_operation_1.TransactionOperation(hash, content, source, forgedBytes, opResponse, context);
         });
     }
+    /**
+     *
+     * @description Stake a given amount for the source address
+     *
+     * @returns An operation handle with the result from the rpc node
+     *
+     * @param Stake pseudo-operation parameter
+     */
+    stake(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const sourceValidation = (0, utils_1.validateAddress)((_a = params.source) !== null && _a !== void 0 ? _a : '');
+            if (params.source && sourceValidation !== utils_1.ValidationResult.VALID) {
+                throw new core_1.InvalidAddressError(params.source, (0, utils_1.invalidDetail)(sourceValidation));
+            }
+            if (!params.to) {
+                params.to = params.source;
+            }
+            if (params.to && params.to !== params.source) {
+                throw new core_1.InvalidStakingAddressError(params.to);
+            }
+            if (params.amount < 0) {
+                throw new core_1.InvalidAmountError(params.amount.toString());
+            }
+            const publicKeyHash = yield this.signer.publicKeyHash();
+            const estimate = yield this.estimate(params, this.estimator.stake.bind(this.estimator));
+            const source = params.source || publicKeyHash;
+            const prepared = yield this.prepare.stake(Object.assign(Object.assign({}, params), estimate));
+            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.TRANSACTION);
+            const opBytes = yield this.forge(prepared);
+            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
+            return new transaction_operation_1.TransactionOperation(hash, content, source, forgedBytes, opResponse, context);
+        });
+    }
+    /**
+     *
+     * @description 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 An operation handle with the result from the rpc node
+     *
+     * @param Unstake pseudo-operation parameter
+     */
+    unstake(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const sourceValidation = (0, utils_1.validateAddress)((_a = params.source) !== null && _a !== void 0 ? _a : '');
+            if (params.source && sourceValidation !== utils_1.ValidationResult.VALID) {
+                throw new core_1.InvalidAddressError(params.source, (0, utils_1.invalidDetail)(sourceValidation));
+            }
+            if (!params.to) {
+                params.to = params.source;
+            }
+            if (params.to && params.to !== params.source) {
+                throw new core_1.InvalidStakingAddressError(params.to);
+            }
+            if (params.amount < 0) {
+                throw new core_1.InvalidAmountError(params.amount.toString());
+            }
+            const publicKeyHash = yield this.signer.publicKeyHash();
+            const estimate = yield this.estimate(params, this.estimator.unstake.bind(this.estimator));
+            const source = params.source || publicKeyHash;
+            const prepared = yield this.prepare.unstake(Object.assign(Object.assign({}, params), estimate));
+            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.TRANSACTION);
+            const opBytes = yield this.forge(prepared);
+            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
+            return new transaction_operation_1.TransactionOperation(hash, content, source, forgedBytes, opResponse, context);
+        });
+    }
+    /**
+     *
+     * @description Transfer all the finalizable unstaked funds of the source to their liquid balance
+     * @returns An operation handle with the result from the rpc node
+     *
+     * @param Finalize_unstake pseudo-operation parameter
+     */
+    finalizeUnstake(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const sourceValidation = (0, utils_1.validateAddress)((_a = params.source) !== null && _a !== void 0 ? _a : '');
+            if (params.source && sourceValidation !== utils_1.ValidationResult.VALID) {
+                throw new core_1.InvalidAddressError(params.source, (0, utils_1.invalidDetail)(sourceValidation));
+            }
+            if (!params.to) {
+                params.to = params.source;
+            }
+            if (params.to && params.to !== params.source) {
+                throw new core_1.InvalidStakingAddressError(params.to);
+            }
+            if (!params.amount) {
+                params.amount = 0;
+            }
+            if (params.amount !== undefined && params.amount > 0) {
+                throw new core_1.InvalidFinalizeUnstakeAmountError('Amount must be 0 to finalize unstake.');
+            }
+            const publicKeyHash = yield this.signer.publicKeyHash();
+            const estimate = yield this.estimate(params, this.estimator.finalizeUnstake.bind(this.estimator));
+            const source = params.source || publicKeyHash;
+            const prepared = yield this.prepare.finalizeUnstake(Object.assign(Object.assign({}, params), estimate));
+            const content = prepared.opOb.contents.find((op) => op.kind === rpc_1.OpKind.TRANSACTION);
+            const opBytes = yield this.forge(prepared);
+            const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
+            return new transaction_operation_1.TransactionOperation(hash, content, source, forgedBytes, opResponse, context);
+        });
+    }
     /**
      *
      * @description Transfer Tickets to a smart contract address

package/dist/lib/estimate/rpc-estimate-provider.js

@@ -178,6 +178,120 @@ class RPCEstimateProvider extends provider_1.Provider {
             return estimate_1.Estimate.createEstimateInstanceFromProperties(estimateProperties);
         });
     }
+    /**
+     *
+     * @description Estimate gasLimit, storageLimit and fees for an stake pseudo-operation
+     *
+     * @returns An estimation of gasLimit, storageLimit and fees for the operation
+     *
+     * @param Stake pseudo-operation parameter
+     */
+    stake(_a) {
+        var _b;
+        var { fee, storageLimit, gasLimit } = _a, rest = __rest(_a, ["fee", "storageLimit", "gasLimit"]);
+        return __awaiter(this, void 0, void 0, function* () {
+            const sourceValidation = (0, utils_1.validateAddress)((_b = rest.source) !== null && _b !== void 0 ? _b : '');
+            if (rest.source && sourceValidation !== utils_1.ValidationResult.VALID) {
+                throw new core_1.InvalidAddressError(rest.source, (0, utils_1.invalidDetail)(sourceValidation));
+            }
+            if (!rest.to) {
+                rest.to = rest.source;
+            }
+            if (rest.to && rest.to !== rest.source) {
+                throw new core_1.InvalidStakingAddressError(rest.to);
+            }
+            if (rest.amount < 0) {
+                throw new core_1.InvalidAmountError(rest.amount.toString());
+            }
+            const preparedOperation = yield this.prepare.stake(Object.assign({ fee,
+                storageLimit,
+                gasLimit }, rest));
+            const protocolConstants = yield this.context.readProvider.getProtocolConstants('head');
+            const estimateProperties = yield this.calculateEstimates(preparedOperation, protocolConstants);
+            if (preparedOperation.opOb.contents[0].kind === 'reveal') {
+                estimateProperties.shift();
+                estimateProperties[0].opSize -= this.OP_SIZE_REVEAL / 2;
+            }
+            return estimate_1.Estimate.createEstimateInstanceFromProperties(estimateProperties);
+        });
+    }
+    /**
+     *
+     * @description Estimate gasLimit, storageLimit and fees for an Unstake pseudo-operation
+     *
+     * @returns An estimation of gasLimit, storageLimit and fees for the operation
+     *
+     * @param Unstake pseudo-operation parameter
+     */
+    unstake(_a) {
+        var _b;
+        var { fee, storageLimit, gasLimit } = _a, rest = __rest(_a, ["fee", "storageLimit", "gasLimit"]);
+        return __awaiter(this, void 0, void 0, function* () {
+            const sourceValidation = (0, utils_1.validateAddress)((_b = rest.source) !== null && _b !== void 0 ? _b : '');
+            if (rest.source && sourceValidation !== utils_1.ValidationResult.VALID) {
+                throw new core_1.InvalidAddressError(rest.source, (0, utils_1.invalidDetail)(sourceValidation));
+            }
+            if (!rest.to) {
+                rest.to = rest.source;
+            }
+            if (rest.to && rest.to !== rest.source) {
+                throw new core_1.InvalidStakingAddressError(rest.to);
+            }
+            if (rest.amount < 0) {
+                throw new core_1.InvalidAmountError(rest.amount.toString());
+            }
+            const preparedOperation = yield this.prepare.unstake(Object.assign({ fee,
+                storageLimit,
+                gasLimit }, rest));
+            const protocolConstants = yield this.context.readProvider.getProtocolConstants('head');
+            const estimateProperties = yield this.calculateEstimates(preparedOperation, protocolConstants);
+            if (preparedOperation.opOb.contents[0].kind === 'reveal') {
+                estimateProperties.shift();
+                estimateProperties[0].opSize -= this.OP_SIZE_REVEAL / 2;
+            }
+            return estimate_1.Estimate.createEstimateInstanceFromProperties(estimateProperties);
+        });
+    }
+    /**
+     *
+     * @description Estimate gasLimit, storageLimit and fees for an finalize_unstake pseudo-operation
+     *
+     * @returns An estimation of gasLimit, storageLimit and fees for the operation
+     *
+     * @param finalize_unstake pseudo-operation parameter
+     */
+    finalizeUnstake(_a) {
+        var _b;
+        var { fee, storageLimit, gasLimit } = _a, rest = __rest(_a, ["fee", "storageLimit", "gasLimit"]);
+        return __awaiter(this, void 0, void 0, function* () {
+            const sourceValidation = (0, utils_1.validateAddress)((_b = rest.source) !== null && _b !== void 0 ? _b : '');
+            if (rest.source && sourceValidation !== utils_1.ValidationResult.VALID) {
+                throw new core_1.InvalidAddressError(rest.source, (0, utils_1.invalidDetail)(sourceValidation));
+            }
+            if (!rest.to) {
+                rest.to = rest.source;
+            }
+            if (rest.to && rest.to !== rest.source) {
+                throw new core_1.InvalidStakingAddressError(rest.to);
+            }
+            if (!rest.amount) {
+                rest.amount = 0;
+            }
+            if (rest.amount !== undefined && rest.amount !== 0) {
+                throw new Error('Amount must be 0 for finalize_unstake operation');
+            }
+            const preparedOperation = yield this.prepare.finalizeUnstake(Object.assign({ fee,
+                storageLimit,
+                gasLimit }, rest));
+            const protocolConstants = yield this.context.readProvider.getProtocolConstants('head');
+            const estimateProperties = yield this.calculateEstimates(preparedOperation, protocolConstants);
+            if (preparedOperation.opOb.contents[0].kind === 'reveal') {
+                estimateProperties.shift();
+                estimateProperties[0].opSize -= this.OP_SIZE_REVEAL / 2;
+            }
+            return estimate_1.Estimate.createEstimateInstanceFromProperties(estimateProperties);
+        });
+    }
     /**
      *
      * @description Estimate gasLimit, storageLimit and fees for a transferTicket operation

package/dist/lib/prepare/prepare-provider.js

@@ -314,6 +314,110 @@ class PrepareProvider extends provider_1.Provider {
             };
         });
     }
+    /**
+     *
+     * @description Method to prepare a stake pseudo-operation
+     * @param operation RPCOperation object or RPCOperation array
+     * @param source string or undefined source pkh
+     * @returns a PreparedOperation object
+     */
+    stake(_a) {
+        var { fee, storageLimit, gasLimit } = _a, rest = __rest(_a, ["fee", "storageLimit", "gasLimit"]);
+        return __awaiter(this, void 0, void 0, function* () {
+            const { pkh } = yield this.getKeys();
+            const protocolConstants = yield this.context.readProvider.getProtocolConstants('head');
+            const DEFAULT_PARAMS = yield this.getOperationLimits(protocolConstants);
+            const op = yield (0, contract_1.createTransferOperation)(Object.assign(Object.assign(Object.assign(Object.assign({}, rest), { to: pkh }), mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS)), { parameter: {
+                    entrypoint: 'stake',
+                    value: {
+                        prim: 'Unit',
+                    },
+                } }));
+            const operation = yield this.addRevealOperationIfNeeded(op, pkh);
+            const ops = this.convertIntoArray(operation);
+            const hash = yield this.getBlockHash();
+            const protocol = yield this.getProtocolHash();
+            __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
+            const headCounter = parseInt(yield this.getHeadCounter(pkh), 10);
+            const contents = this.constructOpContents(ops, headCounter, pkh, rest.source);
+            return {
+                opOb: {
+                    branch: hash,
+                    contents,
+                    protocol,
+                },
+                counter: headCounter,
+            };
+        });
+    }
+    /**
+     *
+     * @description Method to prepare a unstake pseudo-operation
+     * @param operation RPCOperation object or RPCOperation array
+     * @param source string or undefined source pkh
+     * @returns a PreparedOperation object
+     */
+    unstake(_a) {
+        var { fee, storageLimit, gasLimit } = _a, rest = __rest(_a, ["fee", "storageLimit", "gasLimit"]);
+        return __awaiter(this, void 0, void 0, function* () {
+            const { pkh } = yield this.getKeys();
+            const protocolConstants = yield this.context.readProvider.getProtocolConstants('head');
+            const DEFAULT_PARAMS = yield this.getOperationLimits(protocolConstants);
+            const op = yield (0, contract_1.createTransferOperation)(Object.assign(Object.assign(Object.assign(Object.assign({}, rest), { to: pkh }), mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS)), { parameter: {
+                    entrypoint: 'unstake',
+                    value: { prim: 'Unit' },
+                } }));
+            const operation = yield this.addRevealOperationIfNeeded(op, pkh);
+            const ops = this.convertIntoArray(operation);
+            const hash = yield this.getBlockHash();
+            const protocol = yield this.getProtocolHash();
+            __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
+            const headCounter = parseInt(yield this.getHeadCounter(pkh), 10);
+            const contents = this.constructOpContents(ops, headCounter, pkh, rest.source);
+            return {
+                opOb: {
+                    branch: hash,
+                    contents,
+                    protocol,
+                },
+                counter: headCounter,
+            };
+        });
+    }
+    /**
+     *
+     * @description Method to prepare a finalize_unstake pseudo-operation
+     * @param operation RPCOperation object or RPCOperation array
+     * @param source string or undefined source pkh
+     * @returns a PreparedOperation object
+     */
+    finalizeUnstake(_a) {
+        var { fee, storageLimit, gasLimit } = _a, rest = __rest(_a, ["fee", "storageLimit", "gasLimit"]);
+        return __awaiter(this, void 0, void 0, function* () {
+            const { pkh } = yield this.getKeys();
+            const protocolConstants = yield this.context.readProvider.getProtocolConstants('head');
+            const DEFAULT_PARAMS = yield this.getOperationLimits(protocolConstants);
+            const op = yield (0, contract_1.createTransferOperation)(Object.assign(Object.assign(Object.assign(Object.assign({}, rest), { to: pkh, amount: 0 }), mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS)), { parameter: {
+                    entrypoint: 'finalize_unstake',
+                    value: { prim: 'Unit' },
+                } }));
+            const operation = yield this.addRevealOperationIfNeeded(op, pkh);
+            const ops = this.convertIntoArray(operation);
+            const hash = yield this.getBlockHash();
+            const protocol = yield this.getProtocolHash();
+            __classPrivateFieldSet(this, _PrepareProvider_counters, {}, "f");
+            const headCounter = parseInt(yield this.getHeadCounter(pkh), 10);
+            const contents = this.constructOpContents(ops, headCounter, pkh, rest.source);
+            return {
+                opOb: {
+                    branch: hash,
+                    contents,
+                    protocol,
+                },
+                counter: headCounter,
+            };
+        });
+    }
     /**
      *
      * @description Method to prepare a delegation operation

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

@@ -18,7 +18,7 @@ class RpcReadAdapter {
         this.rpc = rpc;
     }
     /**
-     * @description Access the balance of a contract.
+     * @description Access the spendable balance of a contract, excluding frozen bonds.
      * @param address address from which we want to retrieve the balance
      * @param block from which we want to retrieve the balance
      * @returns the balance in mutez
@@ -206,5 +206,12 @@ class RpcReadAdapter {
     getLiveBlocks(block) {
         return this.rpc.getLiveBlocks({ block: String(block) });
     }
+    /**
+     * @description 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/version.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 exports.VERSION = {
-    "commitHash": "79be4991733872e1a9d0b3b9159462100349421a",
-    "version": "19.2.0"
+    "commitHash": "0ef631853ccfda5c5faed584f16069f34085817e",
+    "version": "20.0.0-beta.0"
 };

package/dist/lib/wallet/legacy.js

@@ -30,6 +30,21 @@ class LegacyWalletProvider {
             return (0, types_1.attachKind)(yield params(), types_1.OpKind.TRANSACTION);
         });
     }
+    mapStakeParamsToWalletParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, types_1.attachKind)(yield params(), types_1.OpKind.TRANSACTION);
+        });
+    }
+    mapUnstakeParamsToWalletParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, types_1.attachKind)(yield params(), types_1.OpKind.TRANSACTION);
+        });
+    }
+    mapFinalizeUnstakeParamsToWalletParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (0, types_1.attachKind)(yield params(), types_1.OpKind.TRANSACTION);
+        });
+    }
     mapOriginateParamsToWalletParams(params) {
         return __awaiter(this, void 0, void 0, function* () {
             return (0, types_1.attachKind)(yield params(), types_1.OpKind.ORIGINATION);

package/dist/lib/wallet/wallet.js

@@ -294,11 +294,93 @@ class Wallet {
     }
     /**
      *
-     * @description
+     * @description Stake a given amount for the source address
      *
-     * @returns
+     * @returns An operation handle with the result from the rpc node
+     *
+     * @param Stake pseudo-operation parameter
+     */
+    stake(params) {
+        return this.walletCommand(() => __awaiter(this, void 0, void 0, function* () {
+            const mappedParams = yield this.walletProvider.mapStakeParamsToWalletParams(() => __awaiter(this, void 0, void 0, function* () {
+                const source = yield 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 = yield this.walletProvider.sendOperations([mappedParams]);
+            return this.context.operationFactory.createTransactionOperation(opHash);
+        }));
+    }
+    /**
+     *
+     * @description 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.
      *
-     * @param params
+     * @returns An operation handle with the result from the rpc node
+     *
+     * @param Unstake pseudo-operation parameter
+     */
+    unstake(params) {
+        return this.walletCommand(() => __awaiter(this, void 0, void 0, function* () {
+            const mappedParams = yield this.walletProvider.mapUnstakeParamsToWalletParams(() => __awaiter(this, void 0, void 0, function* () {
+                const source = yield 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 = yield this.walletProvider.sendOperations([mappedParams]);
+            return yield this.context.operationFactory.createTransactionOperation(opHash);
+        }));
+    }
+    /**
+     *
+     * @description Transfer all the finalizable unstaked funds of the source to their liquid balance
+     * @returns An operation handle with the result from the rpc node
+     *
+     * @param Finalize_unstake pseudo-operation parameter
+     */
+    finalizeUnstake(params) {
+        return this.walletCommand(() => __awaiter(this, void 0, void 0, function* () {
+            const mappedParams = yield this.walletProvider.mapFinalizeUnstakeParamsToWalletParams(() => __awaiter(this, void 0, void 0, function* () {
+                const source = yield this.pkh();
+                if (!params.to) {
+                    params.to = source;
+                }
+                if (params.to !== source) {
+                    throw new core_1.InvalidStakingAddressError(params.to);
+                }
+                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 = yield this.walletProvider.sendOperations([mappedParams]);
+            return yield this.context.operationFactory.createTransactionOperation(opHash);
+        }));
+    }
+    /**
+     *
+     * @description Increase the paid storage of a smart contract.
+     *
+     * @returns A wallet command from which we can send the operation to the wallet
+     *
+     * @param params operation parameter
      */
     increasePaidStorage(params) {
         const destinationValidation = (0, utils_1.validateAddress)(params.destination);