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

package/dist/taquito.es6.js

@@ -1,11 +1,11 @@
 import { OpKind, RpcClient } from '@taquito/rpc';
 export { OpKind } from '@taquito/rpc';
 import { HttpResponseError, STATUS_CODE } from '@taquito/http-utils';
-import { TezosToolkitConfigError, ParameterValidationError, RpcError, TaquitoError, NetworkError, InvalidOperationHashError, InvalidAddressError, InvalidOperationKindError as InvalidOperationKindError$1, InvalidContractAddressError, InvalidViewParameterError, DeprecationError, InvalidChainIdError, PublicKeyNotFoundError, InvalidAmountError, InvalidKeyHashError } from '@taquito/core';
+import { TezosToolkitConfigError, ParameterValidationError, RpcError, TaquitoError, NetworkError, InvalidOperationHashError, InvalidAddressError, InvalidOperationKindError as InvalidOperationKindError$1, InvalidStakingAddressError, InvalidFinalizeUnstakeAmountError, InvalidContractAddressError, InvalidViewParameterError, DeprecationError, InvalidChainIdError, PublicKeyNotFoundError, InvalidAmountError, InvalidKeyHashError } from '@taquito/core';
 import { Observable, ReplaySubject, BehaviorSubject, throwError, defer, range, of, EMPTY, combineLatest, from, concat, Subject, NEVER, timer } from 'rxjs';
 import { switchMap, timeout, concatMap, endWith, tap, shareReplay, map, filter, first, catchError, share, distinctUntilChanged, takeWhile, startWith, mergeMap, takeUntil, retry, pluck, distinctUntilKeyChanged, publish, refCount } from 'rxjs/operators';
-import { Schema, ParameterSchema, ViewSchema, EventSchema, MichelsonMap } from '@taquito/michelson-encoder';
-export { MichelsonMap, UnitValue } from '@taquito/michelson-encoder';
+import { Schema, ParameterSchema, ViewSchema, EventSchema, MichelsonMap, Token } from '@taquito/michelson-encoder';
+export { MichelsonMap, Token, UnitValue } from '@taquito/michelson-encoder';
 import { format, validateOperation, ValidationResult, InvalidOperationKindError, validateAddress, invalidDetail, validateContractAddress, validateChain, validateKeyHash, InvalidKeyHashError as InvalidKeyHashError$1, encodeExpr } from '@taquito/utils';
 import BigNumber, { BigNumber as BigNumber$1 } from 'bignumber.js';
 import { Parser, packDataBytes } from '@taquito/michel-codec';
@@ -234,6 +234,7 @@ var Protocols;
     Protocols["PtMumbai2"] = "PtMumbai2TmsJHNGRkD8v8YDbtao7BLUC3wjASn1inAKLFCjaH1";
     Protocols["PtNairobi"] = "PtNairobiyssHuh87hEhfVBGCVrK3WnS8Z2FT4ymB5tAa4r1nQf";
     Protocols["ProxfordY"] = "ProxfordYmVfjWnRcgjWH36fW6PArwqykTFzotUxRs6gmTcZDuH";
+    Protocols["PtParisBQ"] = "PtParisBQscdCm6Cfow6ndeU6wKJyA3aV1j4D3gQBQMsTQyJCrz";
     Protocols["ProtoALpha"] = "ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK";
 })(Protocols || (Protocols = {}));
 const protocols = {
@@ -272,6 +273,7 @@ var ChainIds;
     ChainIds["MUMBAINET2"] = "NetXgbcrNtXD2yA";
     ChainIds["NAIROBINET"] = "NetXyuzvDo2Ugzb";
     ChainIds["OXFORDNET2"] = "NetXxWsskGahzQB";
+    ChainIds["PARISNET"] = "NetXo8SqH1c38SS";
 })(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);
@@ -1165,9 +1167,7 @@ class WalletOperationBatch {
         this.operations = [];
     }
     /**
-     *
      * @description Add a transaction operation to the batch
-     *
      * @param params Transfer operation parameter
      */
     withTransfer(params) {
@@ -1179,9 +1179,7 @@ class WalletOperationBatch {
         return this;
     }
     /**
-     *
      * @description Add a contract call to the batch
-     *
      * @param params Call a contract method
      * @param options Generic operation parameters
      */
@@ -1189,9 +1187,7 @@ class WalletOperationBatch {
         return this.withTransfer(params.toTransferParams(options));
     }
     /**
-     *
      * @description Add a delegation operation to the batch
-     *
      * @param params Delegation operation parameter
      */
     withDelegation(params) {
@@ -1204,9 +1200,7 @@ class WalletOperationBatch {
         return this;
     }
     /**
-     *
      * @description Add an origination operation to the batch
-     *
      * @param params Origination operation parameter
      */
     withOrigination(params) {
@@ -1214,9 +1208,7 @@ class WalletOperationBatch {
         return this;
     }
     /**
-     *
      * @description Add an IncreasePaidStorage operation to the batch
-     *
      * @param param IncreasePaidStorage operation parameter
      */
     withIncreasePaidStorage(params) {
@@ -1246,9 +1238,7 @@ class WalletOperationBatch {
         });
     }
     /**
-     *
      * @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}
      */
@@ -1274,9 +1264,7 @@ class WalletOperationBatch {
         return this;
     }
     /**
-     *
      * @description Submit batch operation to wallet
-     *
      */
     send() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1303,7 +1291,6 @@ class Wallet {
     }
     /**
      * @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
      */
@@ -1317,7 +1304,6 @@ class Wallet {
     }
     /**
      * @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
      */
@@ -1330,11 +1316,8 @@ class Wallet {
         });
     }
     /**
-     *
      * @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) {
@@ -1345,11 +1328,8 @@ class Wallet {
         }));
     }
     /**
-     *
      * @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) {
@@ -1365,11 +1345,8 @@ class Wallet {
         }));
     }
     /**
-     *
      * @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) {
@@ -1400,11 +1377,8 @@ class Wallet {
         });
     }
     /**
-     *
      * @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* () {
@@ -1417,11 +1391,8 @@ class Wallet {
         }));
     }
     /**
-     *
      * @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) {
@@ -1436,12 +1407,83 @@ class Wallet {
         }));
     }
     /**
-     *
-     * @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 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 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 InvalidStakingAddressError(params.to);
+                }
+                if (!params.amount) {
+                    params.amount = 0;
+                }
+                if (params.amount !== 0) {
+                    throw new 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 = validateAddress(params.destination);
@@ -1455,11 +1497,8 @@ class Wallet {
         }));
     }
     /**
-     *
      * @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) {
@@ -1470,10 +1509,8 @@ class Wallet {
         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
      */
@@ -1848,6 +1885,21 @@ class LegacyWalletProvider {
             return attachKind(yield params(), OpKind.TRANSACTION);
         });
     }
+    mapStakeParamsToWalletParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return attachKind(yield params(), OpKind.TRANSACTION);
+        });
+    }
+    mapUnstakeParamsToWalletParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return attachKind(yield params(), OpKind.TRANSACTION);
+        });
+    }
+    mapFinalizeUnstakeParamsToWalletParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return attachKind(yield params(), OpKind.TRANSACTION);
+        });
+    }
     mapOriginateParamsToWalletParams(params) {
         return __awaiter(this, void 0, void 0, function* () {
             return attachKind(yield params(), OpKind.ORIGINATION);
@@ -2809,6 +2861,110 @@ class PrepareProvider extends 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 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
@@ -4090,6 +4246,120 @@ class RPCEstimateProvider extends Provider {
             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 = validateAddress((_b = rest.source) !== null && _b !== void 0 ? _b : '');
+            if (rest.source && sourceValidation !== ValidationResult.VALID) {
+                throw new InvalidAddressError(rest.source, invalidDetail(sourceValidation));
+            }
+            if (!rest.to) {
+                rest.to = rest.source;
+            }
+            if (rest.to && rest.to !== rest.source) {
+                throw new InvalidStakingAddressError(rest.to);
+            }
+            if (rest.amount < 0) {
+                throw new 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 = validateAddress((_b = rest.source) !== null && _b !== void 0 ? _b : '');
+            if (rest.source && sourceValidation !== ValidationResult.VALID) {
+                throw new InvalidAddressError(rest.source, invalidDetail(sourceValidation));
+            }
+            if (!rest.to) {
+                rest.to = rest.source;
+            }
+            if (rest.to && rest.to !== rest.source) {
+                throw new InvalidStakingAddressError(rest.to);
+            }
+            if (rest.amount < 0) {
+                throw new 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 = validateAddress((_b = rest.source) !== null && _b !== void 0 ? _b : '');
+            if (rest.source && sourceValidation !== ValidationResult.VALID) {
+                throw new InvalidAddressError(rest.source, invalidDetail(sourceValidation));
+            }
+            if (!rest.to) {
+                rest.to = rest.source;
+            }
+            if (rest.to && rest.to !== rest.source) {
+                throw new 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
@@ -5290,6 +5560,112 @@ class RpcContractProvider extends Provider {
             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 = validateAddress((_a = params.source) !== null && _a !== void 0 ? _a : '');
+            if (params.source && sourceValidation !== ValidationResult.VALID) {
+                throw new InvalidAddressError(params.source, invalidDetail(sourceValidation));
+            }
+            if (!params.to) {
+                params.to = params.source;
+            }
+            if (params.to && params.to !== params.source) {
+                throw new InvalidStakingAddressError(params.to);
+            }
+            if (params.amount < 0) {
+                throw new 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 === 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 = validateAddress((_a = params.source) !== null && _a !== void 0 ? _a : '');
+            if (params.source && sourceValidation !== ValidationResult.VALID) {
+                throw new InvalidAddressError(params.source, invalidDetail(sourceValidation));
+            }
+            if (!params.to) {
+                params.to = params.source;
+            }
+            if (params.to && params.to !== params.source) {
+                throw new InvalidStakingAddressError(params.to);
+            }
+            if (params.amount < 0) {
+                throw new 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 === 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 = validateAddress((_a = params.source) !== null && _a !== void 0 ? _a : '');
+            if (params.source && sourceValidation !== ValidationResult.VALID) {
+                throw new InvalidAddressError(params.source, invalidDetail(sourceValidation));
+            }
+            if (!params.to) {
+                params.to = params.source;
+            }
+            if (params.to && params.to !== params.source) {
+                throw new InvalidStakingAddressError(params.to);
+            }
+            if (!params.amount) {
+                params.amount = 0;
+            }
+            if (params.amount !== undefined && params.amount > 0) {
+                throw new 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 === 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
@@ -5762,7 +6138,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
@@ -5950,6 +6326,13 @@ 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) });
+    }
 }
 
 /**
@@ -6414,8 +6797,8 @@ class Context {
 
 // 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"
 };
 
 /**
@@ -6774,6 +7157,13 @@ class TezosToolkit {
             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) {
+        Token.fieldNumberingStrategy = strategy;
+    }
     /**
      * @description Provide access to tezos account management
      */