@taquito/taquito 19.2.1-beta.2 → 20.0.0-beta.1

package/dist/taquito.umd.js

@@ -227,6 +227,7 @@
         Protocols["PtMumbai2"] = "PtMumbai2TmsJHNGRkD8v8YDbtao7BLUC3wjASn1inAKLFCjaH1";
         Protocols["PtNairobi"] = "PtNairobiyssHuh87hEhfVBGCVrK3WnS8Z2FT4ymB5tAa4r1nQf";
         Protocols["ProxfordY"] = "ProxfordYmVfjWnRcgjWH36fW6PArwqykTFzotUxRs6gmTcZDuH";
+        Protocols["PtParisBQ"] = "PtParisBQscdCm6Cfow6ndeU6wKJyA3aV1j4D3gQBQMsTQyJCrz";
         Protocols["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
     })(exports.Protocols || (exports.Protocols = {}));
     const protocols = {
@@ -265,6 +266,7 @@
         ChainIds["MUMBAINET2"] = "NetXgbcrNtXD2yA";
         ChainIds["NAIROBINET"] = "NetXyuzvDo2Ugzb";
         ChainIds["OXFORDNET2"] = "NetXxWsskGahzQB";
+        ChainIds["PARISNET"] = "NetXo8SqH1c38SS";
     })(exports.ChainIds || (exports.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);
@@ -1158,9 +1160,7 @@
             this.operations = [];
         }
         /**
-         *
          * @description Add a transaction operation to the batch
-         *
          * @param params Transfer operation parameter
          */
         withTransfer(params) {
@@ -1172,9 +1172,7 @@
             return this;
         }
         /**
-         *
          * @description Add a contract call to the batch
-         *
          * @param params Call a contract method
          * @param options Generic operation parameters
          */
@@ -1182,9 +1180,7 @@
             return this.withTransfer(params.toTransferParams(options));
         }
         /**
-         *
          * @description Add a delegation operation to the batch
-         *
          * @param params Delegation operation parameter
          */
         withDelegation(params) {
@@ -1197,9 +1193,7 @@
             return this;
         }
         /**
-         *
          * @description Add an origination operation to the batch
-         *
          * @param params Origination operation parameter
          */
         withOrigination(params) {
@@ -1207,9 +1201,7 @@
             return this;
         }
         /**
-         *
          * @description Add an IncreasePaidStorage operation to the batch
-         *
          * @param param IncreasePaidStorage operation parameter
          */
         withIncreasePaidStorage(params) {
@@ -1239,9 +1231,7 @@
             });
         }
         /**
-         *
          * @description 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 {@link InvalidOperationKindError}
          */
@@ -1267,9 +1257,7 @@
             return this;
         }
         /**
-         *
          * @description Submit batch operation to wallet
-         *
          */
         send() {
             return __awaiter(this, void 0, void 0, function* () {
@@ -1296,7 +1284,6 @@
         }
         /**
          * @description 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
          */
@@ -1310,7 +1297,6 @@
         }
         /**
          * @description 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
          */
@@ -1323,11 +1309,8 @@
             });
         }
         /**
-         *
          * @description Originate a new contract according to the script in parameters.
-         *
-         * @returns An operation handle with the result from the rpc node
-         *
+         * @returns a OriginationWalletOperation promise object when followed by .send()
          * @param originateParams Originate operation parameter
          */
         originate(params) {
@@ -1338,11 +1321,8 @@
             }));
         }
         /**
-         *
          * @description Set the delegate for a contract.
-         *
-         * @returns An operation handle with the result from the rpc node
-         *
+         * @returns a WalletDelegateParams promise object when followed by .send()
          * @param delegateParams operation parameter
          */
         setDelegate(params) {
@@ -1358,11 +1338,8 @@
             }));
         }
         /**
-         *
          * @description 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
          */
         signFailingNoop(params) {
@@ -1393,11 +1370,8 @@
             });
         }
         /**
-         *
          * @description Register the current address as delegate.
-         *
-         * @returns An operation handle with the result from the rpc node
-         *
+         * @returns a DelegationWalletOperation promise object when followed by .send()
          */
         registerDelegate() {
             return this.walletCommand(() => __awaiter(this, void 0, void 0, function* () {
@@ -1410,11 +1384,8 @@
             }));
         }
         /**
-         *
          * @description Transfer tezos tokens from current address to a specific address or call a smart contract.
-         *
-         * @returns A wallet command from which we can send the operation to the wallet
-         *
+         * @returns a TransactionWalletOperation promise object when followed by .send()
          * @param params operation parameter
          */
         transfer(params) {
@@ -1429,12 +1400,83 @@
             }));
         }
         /**
-         *
-         * @description
-         *
-         * @returns
-         *
-         * @param params
+         * @description Stake a given amount for the source address
+         * @returns a TransactionWalletOperation promise object when followed by .send()
+         * @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.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.
+         * @returns a TransactionWalletOperation promise object when followed by .send()
+         * @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.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 a TransactionWalletOperation promise object when followed by .send()
+         * @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.InvalidStakingAddressError(params.to);
+                    }
+                    if (!params.amount) {
+                        params.amount = 0;
+                    }
+                    if (params.amount !== 0) {
+                        throw new core.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 IncreasePaidStorageWalletOperation promise object when followed by .send()
+         * @param params operation parameter
          */
         increasePaidStorage(params) {
             const destinationValidation = utils.validateAddress(params.destination);
@@ -1448,11 +1490,8 @@
             }));
         }
         /**
-         *
          * @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
-         *
          * @param params List of operation to initialize the batch with
          */
         batch(params) {
@@ -1463,10 +1502,8 @@
             return batch;
         }
         /**
-         *
          * @description 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 {@link InvalidContractAddressError} If the contract address is not valid
          */
@@ -1841,6 +1878,21 @@
                 return attachKind(yield params(), rpc.OpKind.TRANSACTION);
             });
         }
+        mapStakeParamsToWalletParams(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return attachKind(yield params(), rpc.OpKind.TRANSACTION);
+            });
+        }
+        mapUnstakeParamsToWalletParams(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return attachKind(yield params(), rpc.OpKind.TRANSACTION);
+            });
+        }
+        mapFinalizeUnstakeParamsToWalletParams(params) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return attachKind(yield params(), rpc.OpKind.TRANSACTION);
+            });
+        }
         mapOriginateParamsToWalletParams(params) {
             return __awaiter(this, void 0, void 0, function* () {
                 return attachKind(yield params(), rpc.OpKind.ORIGINATION);
@@ -2802,6 +2854,110 @@
                 };
             });
         }
+        /**
+         *
+         * @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 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 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 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
@@ -4083,6 +4239,120 @@
                 return 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 = utils.validateAddress((_b = rest.source) !== null && _b !== void 0 ? _b : '');
+                if (rest.source && sourceValidation !== utils.ValidationResult.VALID) {
+                    throw new core.InvalidAddressError(rest.source, utils.invalidDetail(sourceValidation));
+                }
+                if (!rest.to) {
+                    rest.to = rest.source;
+                }
+                if (rest.to && rest.to !== rest.source) {
+                    throw new core.InvalidStakingAddressError(rest.to);
+                }
+                if (rest.amount < 0) {
+                    throw new core.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.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 = utils.validateAddress((_b = rest.source) !== null && _b !== void 0 ? _b : '');
+                if (rest.source && sourceValidation !== utils.ValidationResult.VALID) {
+                    throw new core.InvalidAddressError(rest.source, utils.invalidDetail(sourceValidation));
+                }
+                if (!rest.to) {
+                    rest.to = rest.source;
+                }
+                if (rest.to && rest.to !== rest.source) {
+                    throw new core.InvalidStakingAddressError(rest.to);
+                }
+                if (rest.amount < 0) {
+                    throw new core.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.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 = utils.validateAddress((_b = rest.source) !== null && _b !== void 0 ? _b : '');
+                if (rest.source && sourceValidation !== utils.ValidationResult.VALID) {
+                    throw new core.InvalidAddressError(rest.source, utils.invalidDetail(sourceValidation));
+                }
+                if (!rest.to) {
+                    rest.to = rest.source;
+                }
+                if (rest.to && rest.to !== rest.source) {
+                    throw new core.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.createEstimateInstanceFromProperties(estimateProperties);
+            });
+        }
         /**
          *
          * @description Estimate gasLimit, storageLimit and fees for a transferTicket operation
@@ -5283,6 +5553,112 @@
                 return new 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 = utils.validateAddress((_a = params.source) !== null && _a !== void 0 ? _a : '');
+                if (params.source && sourceValidation !== utils.ValidationResult.VALID) {
+                    throw new core.InvalidAddressError(params.source, utils.invalidDetail(sourceValidation));
+                }
+                if (!params.to) {
+                    params.to = params.source;
+                }
+                if (params.to && params.to !== params.source) {
+                    throw new core.InvalidStakingAddressError(params.to);
+                }
+                if (params.amount < 0) {
+                    throw new core.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.OpKind.TRANSACTION);
+                const opBytes = yield this.forge(prepared);
+                const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
+                return new 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 = utils.validateAddress((_a = params.source) !== null && _a !== void 0 ? _a : '');
+                if (params.source && sourceValidation !== utils.ValidationResult.VALID) {
+                    throw new core.InvalidAddressError(params.source, utils.invalidDetail(sourceValidation));
+                }
+                if (!params.to) {
+                    params.to = params.source;
+                }
+                if (params.to && params.to !== params.source) {
+                    throw new core.InvalidStakingAddressError(params.to);
+                }
+                if (params.amount < 0) {
+                    throw new core.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.OpKind.TRANSACTION);
+                const opBytes = yield this.forge(prepared);
+                const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
+                return new 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 = utils.validateAddress((_a = params.source) !== null && _a !== void 0 ? _a : '');
+                if (params.source && sourceValidation !== utils.ValidationResult.VALID) {
+                    throw new core.InvalidAddressError(params.source, utils.invalidDetail(sourceValidation));
+                }
+                if (!params.to) {
+                    params.to = params.source;
+                }
+                if (params.to && params.to !== params.source) {
+                    throw new core.InvalidStakingAddressError(params.to);
+                }
+                if (!params.amount) {
+                    params.amount = 0;
+                }
+                if (params.amount !== undefined && params.amount > 0) {
+                    throw new core.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.OpKind.TRANSACTION);
+                const opBytes = yield this.forge(prepared);
+                const { hash, context, forgedBytes, opResponse } = yield this.signAndInject(opBytes);
+                return new TransactionOperation(hash, content, source, forgedBytes, opResponse, context);
+            });
+        }
         /**
          *
          * @description Transfer Tickets to a smart contract address
@@ -5755,7 +6131,7 @@
             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
@@ -5943,6 +6319,13 @@
         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) });
+        }
     }
 
     /**
@@ -6407,8 +6790,8 @@
 
     // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
     const VERSION = {
-        "commitHash": "06c78f51d36ac42cd51e4fc747ebceb5df3cd19b",
-        "version": "19.2.1-beta.2"
+        "commitHash": "4c6e079465fdb978c1627dfdcced0435c9ef87fc",
+        "version": "20.0.0-beta.1"
     };
 
     /**
@@ -6767,6 +7150,13 @@
                 this._options.injectorProvider = injectorProvider;
             }
         }
+        /**
+         * @description Sets the strategy used for field numbering in Token execute/encode/decode to convert Michelson values to/from javascript objects
+         * @param strategy a value of type FieldNumberingStrategy that controls how field numbers are calculated
+         */
+        setFieldNumberingStrategy(strategy) {
+            michelsonEncoder.Token.fieldNumberingStrategy = strategy;
+        }
         /**
          * @description Provide access to tezos account management
          */
@@ -6857,6 +7247,10 @@
         enumerable: true,
         get: function () { return michelsonEncoder.MichelsonMap; }
     });
+    Object.defineProperty(exports, "Token", {
+        enumerable: true,
+        get: function () { return michelsonEncoder.Token; }
+    });
     Object.defineProperty(exports, "UnitValue", {
         enumerable: true,
         get: function () { return michelsonEncoder.UnitValue; }