From fd5fdfa721f9f0edc46a155d42984573a1cfbbd9 Mon Sep 17 00:00:00 2001 From: Alireza Haghshenas Date: Fri, 19 Apr 2024 09:07:39 -0700 Subject: [PATCH 1/7] docs: draft of documentation for staking --- docs/staking.md | 122 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 122 insertions(+) create mode 100644 docs/staking.md diff --git a/docs/staking.md b/docs/staking.md new file mode 100644 index 0000000000..77f3b96c5f --- /dev/null +++ b/docs/staking.md @@ -0,0 +1,122 @@ +--- +title: Staking and Adaptive Issuance +author: Alireza Haghshenas +--- + +# Staking and Adaptive Issuance + +Staking is an update to the "Proof of Stake" Mechanism in Tezos. + +Before Staking, the only way for Tez holders to participate in the network was by delegating their tokens to a baker. Delegated funds contributed to a delegate's voting and baking power, but were not subject to staking: they could not be slashed in case the baker misbehaved. This is a useful feature for many users, but limits the total amount ot staked tez to the amount of tez that bakers themselves hold. In other words, if participating in the "Proof of Stake" mechanism required setting up and maintaining a baker, which is a significant barrier to entry for many users. + +Staking changes this by allowing any user to participate in the "Proof of Stake" mechanism without setting up a baker. Users can now stake their tokens directly, and their staked tokens will be subject to slashing in case of misbehavior. This allows the total amount of staked tez to be much higher than the amount of tez that bakers themselves hold, which in turn increases the security of the network. + +Users can control their staked funds using the `stake`, `unstake`, and `finalize_unstake` operations. These are implemented as pseudo-entrypoints, and the parameters are passed to a transfer operation with the same destination as the sender. + +To accept staked funds, a delegate needs to have opted in to staking. This is done by `set_delegate_parameters`. This part is not supported by Taquito, as it is not a dApp operation. More information [here](https://tezos.gitlab.io/paris/adaptive_issuance.html#staking-policy-configuration). + +# Staking Funds +To stake your funds, you need to call the `stake` operation. +You need yo have delegated your funds to a baker before you can stake them. + +```javascript + +// TODO: Add code after the implementation is done + +``` + +# Unstaking Funds + +To unstake your funds, you need to call the `unstake` operation. This will change your fund's status to "Unstaked + Frozen" +The unstaked funds will still be frozen (and subject to slashing for 4 cycles). After that, your funds will be in "Unstaked + Finalizable" state. + +```javascript + +``` + +# Finalizing Unstake + +To finalize your unstaked funds, you need to call the `finalize_unstake` operation. This will change your fund's status to "spendable". + +```javascript + +``` + +# Additional Info and Some Notes + +## Cycle +At the time of this writing, a cycle is 16384 blocks, and 15 seconds per block. This means a cycle is about 2.8 days. This changes with the activation of newer protocols. + +## Overstaking +A delegate can set the maximum amount of staking they can accept, as a multiply of their own balance. If a delegate's limit is exceeded, the exceeding stake is automatically considered as delegation for the delegate's baking and voting power calculation, but it does remain slashable. That means it's your responsibility to make sure you're not overstaking. + +```javascript +// Todo: check for overstaking +``` + +## Changing Delegate +When you change your delegate, your funds will be automatically unstaked. You will have to wait for 4 cycles before you can stake them again. + +## No need to finalize_unstake in some cases +The `stake` and `unstake` operations will automatically finalize all currently finalizable funds. + +## Adaptive Issuance +A concept related to staking is adaptive issuance. Adaptive issuance is a mechanism that adjusts the block reward based on the total amount of staked tez. In short, the reward will be adjusted to keep the staked funds about 50% of the total supply. To read more about the mechanism you can check [this document](https://tezos.gitlab.io/paris/adaptive_issuance.html#adaptive-issuance). + +## Staking Rewards +In delegation, rewards were given to the baker, and it was the baker's responsibility to distribute the rewards to the delegators. In staking, the rewards are given directly to the staker. However, rewards are not given immediately. // TODO: how long does it take for rewards to be given? + +## Feature activation +Voting for Staking is being done differently from other protocol updates. It is included in the "Oxford" protocol, and after "Paris" is activated, this feature can be voted on separately. + +# Exclude + +## Lifetime of Staked Funds + +Before you stake some of your Tez, it is in "Spendable" state. When you stake it, it will be in "Staked" state. When you unstake it, it will be in "Unstaked + Frozen" state, this fund is still subject to slashing. After 4 cycles, it will be in "Unstaked + Finalizable" state. You can finalize it to make it "Spendable" again. + +```mermaid +graph LR +A[Spendable] --stake(amount)--> B[Staked] +B --unstake(amount)--> C[Unstaked + Frozen] +C --wait 4 cycles--> D[Unstaked + Finalizable] +D --finalize_unstake--> A +``` + +## Staking Rewards + +The static and dynamic rewards, how these are adjusted based on the staking ratio, and how the rewards are distributed regarding the `edge_of_baking_over_staking` parameter. + +Comparison of the rewards in delegation and staking. + +## staking using octez-client + +- set_delegate_params: + - longer: `octez-client transfer 0 from to --entrypoint set_delegate_parameters --arg "Pair (Pair Unit)"` + - shorter: `octez-client set delegate parameters for --limit-of-staking-over-baking --edge-of-baking-over-staking ` +- stake: + - longer: `octez-client transfer from to --entrypoint stake` + - shorter: `octez-client stake for ` +- unstake: + - longer: `octez-client transfer from to --entrypoint unstake` + - shorter: `octez-client unstake for ` +- `octez-client transfer 0 from to --entrypoint finalize_unstake` + - `octez-client finalize unstake for ` + +## Details of the feature voting process + +- voting phase: + - block producing delegates can vote in each block, or pass (default) + - Exponential moving average with half life of 2 weeks + - target: 80% supermajority of on over on+off votes + - No time limit + - will complete at the end of the cycle +- adoption phase: + - 5 cycles + - no returning back implemented + +## Details of set_delegate_parameters + - edge_of_baking_over_staking + - limit_of_staking_over_baking + +## Showing the different balances before and after each operation (and after the 4 cycle wait period) From b7feb14f1f22d4c7a6d7014f0c405fb4636c05e2 Mon Sep 17 00:00:00 2001 From: Alireza Haghshenas Date: Wed, 24 Apr 2024 14:16:31 -0700 Subject: [PATCH 2/7] docs: modifications in response to An's comments --- docs/staking.md | 55 ++++++--------------------------------------- website/sidebars.js | 1 + 2 files changed, 8 insertions(+), 48 deletions(-) diff --git a/docs/staking.md b/docs/staking.md index 77f3b96c5f..dc0087e6e1 100644 --- a/docs/staking.md +++ b/docs/staking.md @@ -9,7 +9,7 @@ Staking is an update to the "Proof of Stake" Mechanism in Tezos. Before Staking, the only way for Tez holders to participate in the network was by delegating their tokens to a baker. Delegated funds contributed to a delegate's voting and baking power, but were not subject to staking: they could not be slashed in case the baker misbehaved. This is a useful feature for many users, but limits the total amount ot staked tez to the amount of tez that bakers themselves hold. In other words, if participating in the "Proof of Stake" mechanism required setting up and maintaining a baker, which is a significant barrier to entry for many users. -Staking changes this by allowing any user to participate in the "Proof of Stake" mechanism without setting up a baker. Users can now stake their tokens directly, and their staked tokens will be subject to slashing in case of misbehavior. This allows the total amount of staked tez to be much higher than the amount of tez that bakers themselves hold, which in turn increases the security of the network. +Staking changes this by allowing any user to participate in the "Proof of Stake" mechanism without setting up a baker. Users can now stake their tokens to their delegates, and their staked tokens will be subject to slashing in case of deleate/baker's misbehavior. This allows the total amount of staked tez to be much higher than the amount of tez that bakers themselves hold, which in turn increases the security of the network. Users can control their staked funds using the `stake`, `unstake`, and `finalize_unstake` operations. These are implemented as pseudo-entrypoints, and the parameters are passed to a transfer operation with the same destination as the sender. @@ -17,7 +17,9 @@ To accept staked funds, a delegate needs to have opted in to staking. This is do # Staking Funds To stake your funds, you need to call the `stake` operation. -You need yo have delegated your funds to a baker before you can stake them. +Before you can stake your funds, two conditions should be met: +1. You need yo have delegated your funds to a delegate before you can stake them (by calling [`setDelegate`](#set_delegate)) +1. Your delegate should accept staking by calling `set_delegate_parameters` ```javascript @@ -45,10 +47,10 @@ To finalize your unstaked funds, you need to call the `finalize_unstake` operati # Additional Info and Some Notes ## Cycle -At the time of this writing, a cycle is 16384 blocks, and 15 seconds per block. This means a cycle is about 2.8 days. This changes with the activation of newer protocols. +At the time of this writing, a cycle is ~~16384~~ blocks (with Paris protocol will be 24576), and ~~15~~ (10) seconds per block. This means a cycle is about 2.8 days (and will stay the same after Paris). This might change with the activation of newer protocols. ## Overstaking -A delegate can set the maximum amount of staking they can accept, as a multiply of their own balance. If a delegate's limit is exceeded, the exceeding stake is automatically considered as delegation for the delegate's baking and voting power calculation, but it does remain slashable. That means it's your responsibility to make sure you're not overstaking. +A delegate can set the maximum amount of staking they can accept, as a multiply of their own balance. If a delegate's limit is exceeded, the exceeding stake is automatically considered as delegation for the delegate's baking and voting power calculation, but it does remain slashable. That means it's your responsibility to make sure you're not ```javascript // Todo: check for overstaking @@ -64,12 +66,7 @@ The `stake` and `unstake` operations will automatically finalize all currently f A concept related to staking is adaptive issuance. Adaptive issuance is a mechanism that adjusts the block reward based on the total amount of staked tez. In short, the reward will be adjusted to keep the staked funds about 50% of the total supply. To read more about the mechanism you can check [this document](https://tezos.gitlab.io/paris/adaptive_issuance.html#adaptive-issuance). ## Staking Rewards -In delegation, rewards were given to the baker, and it was the baker's responsibility to distribute the rewards to the delegators. In staking, the rewards are given directly to the staker. However, rewards are not given immediately. // TODO: how long does it take for rewards to be given? - -## Feature activation -Voting for Staking is being done differently from other protocol updates. It is included in the "Oxford" protocol, and after "Paris" is activated, this feature can be voted on separately. - -# Exclude +In delegation, rewards were given to the baker, and it was the baker's responsibility to distribute the rewards to the delegators. In staking, the rewards are given directly to the staker. However, rewards are not given immediately, but are distributed through staked(frozen) balance, and the user can spend the reward along with their initial stake when they `unstake` and `finalize_unstake`. ## Lifetime of Staked Funds @@ -82,41 +79,3 @@ B --unstake(amount)--> C[Unstaked + Frozen] C --wait 4 cycles--> D[Unstaked + Finalizable] D --finalize_unstake--> A ``` - -## Staking Rewards - -The static and dynamic rewards, how these are adjusted based on the staking ratio, and how the rewards are distributed regarding the `edge_of_baking_over_staking` parameter. - -Comparison of the rewards in delegation and staking. - -## staking using octez-client - -- set_delegate_params: - - longer: `octez-client transfer 0 from to --entrypoint set_delegate_parameters --arg "Pair (Pair Unit)"` - - shorter: `octez-client set delegate parameters for --limit-of-staking-over-baking --edge-of-baking-over-staking ` -- stake: - - longer: `octez-client transfer from to --entrypoint stake` - - shorter: `octez-client stake for ` -- unstake: - - longer: `octez-client transfer from to --entrypoint unstake` - - shorter: `octez-client unstake for ` -- `octez-client transfer 0 from to --entrypoint finalize_unstake` - - `octez-client finalize unstake for ` - -## Details of the feature voting process - -- voting phase: - - block producing delegates can vote in each block, or pass (default) - - Exponential moving average with half life of 2 weeks - - target: 80% supermajority of on over on+off votes - - No time limit - - will complete at the end of the cycle -- adoption phase: - - 5 cycles - - no returning back implemented - -## Details of set_delegate_parameters - - edge_of_baking_over_staking - - limit_of_staking_over_baking - -## Showing the different balances before and after each operation (and after the 4 cycle wait period) diff --git a/website/sidebars.js b/website/sidebars.js index 164d24d0d1..62419a44b6 100644 --- a/website/sidebars.js +++ b/website/sidebars.js @@ -58,6 +58,7 @@ const sidebars = { 'smart_rollups', 'proposal_and_ballot', 'failing_noop', + 'staking', ] }, { From 25353750e1f611438cff83fc58b57aeb409b7091 Mon Sep 17 00:00:00 2001 From: Alireza Haghshenas Date: Wed, 24 Apr 2024 14:28:22 -0700 Subject: [PATCH 3/7] docs: fix spelling errors --- docs/staking.md | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/docs/staking.md b/docs/staking.md index dc0087e6e1..8fe4ab601c 100644 --- a/docs/staking.md +++ b/docs/staking.md @@ -7,9 +7,9 @@ author: Alireza Haghshenas Staking is an update to the "Proof of Stake" Mechanism in Tezos. -Before Staking, the only way for Tez holders to participate in the network was by delegating their tokens to a baker. Delegated funds contributed to a delegate's voting and baking power, but were not subject to staking: they could not be slashed in case the baker misbehaved. This is a useful feature for many users, but limits the total amount ot staked tez to the amount of tez that bakers themselves hold. In other words, if participating in the "Proof of Stake" mechanism required setting up and maintaining a baker, which is a significant barrier to entry for many users. +Before Staking, the only way for Tez holders to participate in the network was by delegating their tokens to a baker. Delegated funds contributed to a delegate's voting and baking power, but were not subject to staking: they could not be slashed in case the baker misbehaved. This is a useful feature for many users, but limits the total amount of staked tez to the amount of tez that bakers themselves hold. In other words, participating in the "Proof of Stake" mechanism required setting up and maintaining a baker, which is a significant barrier to entry for many users. -Staking changes this by allowing any user to participate in the "Proof of Stake" mechanism without setting up a baker. Users can now stake their tokens to their delegates, and their staked tokens will be subject to slashing in case of deleate/baker's misbehavior. This allows the total amount of staked tez to be much higher than the amount of tez that bakers themselves hold, which in turn increases the security of the network. +Staking changes this by allowing any user to participate in the "Proof of Stake" mechanism without setting up a baker. Users can now stake their tokens to their delegates, and their staked tokens will be subject to slashing in case of delegate/baker's misbehaviour. This allows the total amount of staked Tez to be much higher than the amount of tez that bakers themselves hold, which in turn increases the security of the network. Users can control their staked funds using the `stake`, `unstake`, and `finalize_unstake` operations. These are implemented as pseudo-entrypoints, and the parameters are passed to a transfer operation with the same destination as the sender. @@ -18,7 +18,7 @@ To accept staked funds, a delegate needs to have opted in to staking. This is do # Staking Funds To stake your funds, you need to call the `stake` operation. Before you can stake your funds, two conditions should be met: -1. You need yo have delegated your funds to a delegate before you can stake them (by calling [`setDelegate`](#set_delegate)) +1. You need yor have delegated your funds to a delegate before you can stake them (by calling [`setDelegate`](#set_delegate)) 1. Your delegate should accept staking by calling `set_delegate_parameters` ```javascript @@ -29,7 +29,7 @@ Before you can stake your funds, two conditions should be met: # Unstaking Funds -To unstake your funds, you need to call the `unstake` operation. This will change your fund's status to "Unstaked + Frozen" +To unstake your funds, you need to call the `unstake` operation. This will change your fund's status to "Unstaked + Frozen" The unstaked funds will still be frozen (and subject to slashing for 4 cycles). After that, your funds will be in "Unstaked + Finalizable" state. ```javascript @@ -38,7 +38,7 @@ The unstaked funds will still be frozen (and subject to slashing for 4 cycles). # Finalizing Unstake -To finalize your unstaked funds, you need to call the `finalize_unstake` operation. This will change your fund's status to "spendable". +To finalize your unstaked funds, you need to call the `finalize_unstake` operation. This will change your fund's status back to "spendable". ```javascript @@ -63,10 +63,10 @@ When you change your delegate, your funds will be automatically unstaked. You wi The `stake` and `unstake` operations will automatically finalize all currently finalizable funds. ## Adaptive Issuance -A concept related to staking is adaptive issuance. Adaptive issuance is a mechanism that adjusts the block reward based on the total amount of staked tez. In short, the reward will be adjusted to keep the staked funds about 50% of the total supply. To read more about the mechanism you can check [this document](https://tezos.gitlab.io/paris/adaptive_issuance.html#adaptive-issuance). +A concept related to staking is adaptive issuance. Adaptive issuance is a mechanism that adjusts the block reward based on the total amount of staked tez. In short, the reward will be adjusted to keep the staked funds about 50% of the total supply. To read more about the mechanism, you can check [this document](https://tezos.gitlab.io/paris/adaptive_issuance.html#adaptive-issuance). ## Staking Rewards -In delegation, rewards were given to the baker, and it was the baker's responsibility to distribute the rewards to the delegators. In staking, the rewards are given directly to the staker. However, rewards are not given immediately, but are distributed through staked(frozen) balance, and the user can spend the reward along with their initial stake when they `unstake` and `finalize_unstake`. +In delegation, rewards were given to the baker, and it was the baker's responsibility to distribute the rewards to the delegators. In staking, the rewards are given directly to the staker. However, rewards are not given immediately, but are distributed through staked (frozen) balance, and the user can spend the reward along with their initial stake when they `unstake` and `finalize_unstake`. ## Lifetime of Staked Funds From de7ef3c643bb391af2e69a5ba340126bf1577658 Mon Sep 17 00:00:00 2001 From: Alireza Haghshenas Date: Wed, 24 Apr 2024 14:39:07 -0700 Subject: [PATCH 4/7] docs: added code samples --- docs/staking.md | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/docs/staking.md b/docs/staking.md index 8fe4ab601c..cfc2e056c8 100644 --- a/docs/staking.md +++ b/docs/staking.md @@ -23,17 +23,24 @@ Before you can stake your funds, two conditions should be met: ```javascript -// TODO: Add code after the implementation is done +const op = await Tezos.contract.stake({ + amount: 100 + }); + await op.confirmation(); ``` + # Unstaking Funds To unstake your funds, you need to call the `unstake` operation. This will change your fund's status to "Unstaked + Frozen" The unstaked funds will still be frozen (and subject to slashing for 4 cycles). After that, your funds will be in "Unstaked + Finalizable" state. ```javascript - +const op = await Tezos.contract.unstake({ + amount: 50 + }); + await op.confirmation(); ``` # Finalizing Unstake @@ -41,6 +48,8 @@ The unstaked funds will still be frozen (and subject to slashing for 4 cycles). To finalize your unstaked funds, you need to call the `finalize_unstake` operation. This will change your fund's status back to "spendable". ```javascript +const op = await Tezos.contract.finalizeUnstake({}); + await op.confirmation(); ``` @@ -50,11 +59,8 @@ To finalize your unstaked funds, you need to call the `finalize_unstake` operati At the time of this writing, a cycle is ~~16384~~ blocks (with Paris protocol will be 24576), and ~~15~~ (10) seconds per block. This means a cycle is about 2.8 days (and will stay the same after Paris). This might change with the activation of newer protocols. ## Overstaking -A delegate can set the maximum amount of staking they can accept, as a multiply of their own balance. If a delegate's limit is exceeded, the exceeding stake is automatically considered as delegation for the delegate's baking and voting power calculation, but it does remain slashable. That means it's your responsibility to make sure you're not +A delegate can set the maximum amount of staking they can accept, as a multiply of their own balance. If a delegate's limit is exceeded, the exceeding stake is automatically considered as delegation for the delegate's baking and voting power calculation, but it does remain slashable. That means it's your responsibility to make sure you're not overstaking. Remember that overstaking can even happen after you have staked successfully, because your delegate changes their own balance, or their staking parameter. -```javascript -// Todo: check for overstaking -``` ## Changing Delegate When you change your delegate, your funds will be automatically unstaked. You will have to wait for 4 cycles before you can stake them again. From da983f34fc1eb7366c95911f9262671cb8b91d4e Mon Sep 17 00:00:00 2001 From: Alireza Haghshenas Date: Wed, 24 Apr 2024 15:21:44 -0700 Subject: [PATCH 5/7] docs: fixed mermaid error --- docs/staking.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/docs/staking.md b/docs/staking.md index cfc2e056c8..56da5aea59 100644 --- a/docs/staking.md +++ b/docs/staking.md @@ -80,8 +80,8 @@ Before you stake some of your Tez, it is in "Spendable" state. When you stake it ```mermaid graph LR -A[Spendable] --stake(amount)--> B[Staked] -B --unstake(amount)--> C[Unstaked + Frozen] -C --wait 4 cycles--> D[Unstaked + Finalizable] -D --finalize_unstake--> A +A[Spendable] -- "stake(amount)" --> B[Staked] +B -- "unstake(amount)" --> C[Unstaked + Frozen] +C -- wait 4 cycles --> D[Unstaked + Finalizable] +D -- finalize_unstake --> A ``` From e76112e7cdc371f183b15c7f6e389f0fc3f62a92 Mon Sep 17 00:00:00 2001 From: Alireza Haghshenas Date: Wed, 24 Apr 2024 16:14:35 -0700 Subject: [PATCH 6/7] docs: add a note to doc that staking will be disabled for about two weeks after protocol activation --- docs/staking.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docs/staking.md b/docs/staking.md index 56da5aea59..3ea2e866e3 100644 --- a/docs/staking.md +++ b/docs/staking.md @@ -15,6 +15,10 @@ Users can control their staked funds using the `stake`, `unstake`, and `finalize To accept staked funds, a delegate needs to have opted in to staking. This is done by `set_delegate_parameters`. This part is not supported by Taquito, as it is not a dApp operation. More information [here](https://tezos.gitlab.io/paris/adaptive_issuance.html#staking-policy-configuration). +:::info +After protocol Paris is activated, the adaptive issuance will still be disabled for about two weeks. During this period, staking operations will result in this error: `proto.019-PtParisB.operation.manual_staking_forbidden`. +::: + # Staking Funds To stake your funds, you need to call the `stake` operation. Before you can stake your funds, two conditions should be met: From 79b0068fb3b808cd75ded6d6c2a8b903aacad4d2 Mon Sep 17 00:00:00 2001 From: Alireza Haghshenas Date: Wed, 1 May 2024 15:40:21 -0700 Subject: [PATCH 7/7] docs: add wallet api code --- docs/staking.md | 83 +++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 80 insertions(+), 3 deletions(-) diff --git a/docs/staking.md b/docs/staking.md index 3ea2e866e3..64343e3940 100644 --- a/docs/staking.md +++ b/docs/staking.md @@ -3,6 +3,9 @@ title: Staking and Adaptive Issuance author: Alireza Haghshenas --- +import Tabs from '@theme/Tabs'; +import TabItem from '@theme/TabItem'; + # Staking and Adaptive Issuance Staking is an update to the "Proof of Stake" Mechanism in Tezos. @@ -25,38 +28,112 @@ Before you can stake your funds, two conditions should be met: 1. You need yor have delegated your funds to a delegate before you can stake them (by calling [`setDelegate`](#set_delegate)) 1. Your delegate should accept staking by calling `set_delegate_parameters` + + + + ```javascript const op = await Tezos.contract.stake({ - amount: 100 + amount: 100, + mutez: false }); await op.confirmation(); ``` + + + +```javascript + +const op = await Tezos.wallet.stake({ + amount: 100, + mutez: false + }).send(); + await op.confirmation(); + +``` + + + # Unstaking Funds To unstake your funds, you need to call the `unstake` operation. This will change your fund's status to "Unstaked + Frozen" The unstaked funds will still be frozen (and subject to slashing for 4 cycles). After that, your funds will be in "Unstaked + Finalizable" state. + + + ```javascript + const op = await Tezos.contract.unstake({ - amount: 50 + amount: 50, + mutez: false }); await op.confirmation(); + ``` + + + +```javascript + +const op = await Tezos.wallet.unstake({ + amount: 50, + mutez: false + }).send(); + await op.confirmation(); + +``` + + + + # Finalizing Unstake To finalize your unstaked funds, you need to call the `finalize_unstake` operation. This will change your fund's status back to "spendable". + + + ```javascript -const op = await Tezos.contract.finalizeUnstake({}); + +const op = await Tezos.contract.finalizeUnstake(); await op.confirmation(); ``` + + + +```javascript + +const op = await Tezos.wallet.finalizeUnstake().send(); + await op.confirmation(); + +``` + + + + # Additional Info and Some Notes ## Cycle