updated ux to not require destination (for stake/unstake) and not req…

…uire a param for finalize unstake
ecadlabs · Apr 23, 2024 · 3655961 · 3655961
1 parent fba1fe3
commit 3655961
Show file tree

Hide file tree

Showing 9 changed files with 161 additions and 90 deletions.
diff --git a/integration-tests/__tests__/contract/operations/staking.spec.ts b/integration-tests/__tests__/contract/operations/staking.spec.ts
@@ -2,27 +2,31 @@ import { CONFIGS } from "../../../config";
 
 CONFIGS().forEach(({ lib, rpc, setup }) => {
   const Tezos = lib;
-  let myPkh: string;
 
   describe(`Staking pseudo operations: ${rpc}`, () => {
 
     beforeAll(async () => {
       await setup(true);
 
-      myPkh = await Tezos.signer.publicKeyHash();
-      console.log(myPkh);
-
       const delegateOp = await Tezos.contract.setDelegate({
         delegate: 'tz1PZY3tEWmXGasYeehXYqwXuw2Z3iZ6QDnA',
-        source: myPkh,
+        source: await Tezos.signer.publicKeyHash()
       });
 
       await delegateOp.confirmation();
     });
 
-    it('should be able to inject the stake pseudo operation to a designated delegate', async () => {
+    it('should throw an error when the destination specified is not the same as source', async () => {
+      expect(async () => {
+        const op = await Tezos.contract.stake({
+          amount: 0.1,
+          to: 'tz1PZY3tEWmXGasYeehXYqwXuw2Z3iZ6QDnA'
+        });
+      }).rejects.toThrow();
+    });
+
+    it('should be able to stake funds to a designated delegate', async () => {
       const op = await Tezos.contract.stake({
-        to: myPkh,
         amount: 0.1
       });
       await op.confirmation();
@@ -33,7 +37,6 @@ CONFIGS().forEach(({ lib, rpc, setup }) => {
 
     it('should be able to unstake funds from a designated delegate', async () => {
       const op = await Tezos.contract.unstake({
-        to: myPkh,
         amount: 0.1
       });
       await op.confirmation();
@@ -43,10 +46,7 @@ CONFIGS().forEach(({ lib, rpc, setup }) => {
     });
 
     it('should be able to finalize_unstake funds from a designated delegate', async () => {
-      const op = await Tezos.contract.finalizeUnstake({
-        to: myPkh,
-        amount: 0
-      });
+      const op = await Tezos.contract.finalizeUnstake({});
       await op.confirmation();
 
       expect(op.hash).toBeDefined();

diff --git a/packages/taquito-core/src/errors.ts b/packages/taquito-core/src/errors.ts
@@ -62,6 +62,28 @@ export class InvalidAddressError extends ParameterValidationError {
   }
 }
 
+export class InvalidStakingAddressError extends ParameterValidationError {
+  constructor(
+    public readonly address: string,
+    public readonly errorDetail?: string
+  ) {
+    super();
+    this.name = 'InvalidStakingAddressError';
+    this.message = `Invalid staking address "${address}", you can only stake to your own address`;
+  }
+}
+
+export class InvalidFinalizeUnstakeAmountError extends ParameterValidationError {
+  constructor(
+    public readonly address: string,
+    public readonly errorDetail?: string
+  ) {
+    super();
+    this.name = 'InvalidFinalizeUnstakeAmountError';
+    this.message = `The amount can only be 0 when finalizing an unstake`;
+  }
+}
+
 /**
  *  @category Error
  *  @description Error that indicates an invalid block hash being passed or used

diff --git a/packages/taquito/src/contract/rpc-contract-provider.ts b/packages/taquito/src/contract/rpc-contract-provider.ts
@@ -30,6 +30,8 @@ import {
   InvalidAddressError,
   InvalidContractAddressError,
   InvalidAmountError,
+  InvalidFinalizeUnstakeAmountError,
+  InvalidStakingAddressError,
 } from '@taquito/core';
 import { OperationBatch } from '../batch/rpc-batch-provider';
 import { Context } from '../context';
@@ -407,10 +409,13 @@ export class RpcContractProvider extends Provider implements ContractProvider, S
    * @param Stake pseudo-operation parameter
    */
   async stake(params: StakeParams) {
-    const toValidation = validateAddress(params.to);
-    if (toValidation !== ValidationResult.VALID) {
-      throw new InvalidAddressError(params.to, invalidDetail(toValidation));
+    if (params.to === undefined) {
+      params.to = params.source;
     }
+    if (params.to !== undefined && params.to !== params.source) {
+      throw new InvalidStakingAddressError(params.to);
+    }
+
     const sourceValidation = validateAddress(params.source ?? '');
     if (params.source && sourceValidation !== ValidationResult.VALID) {
       throw new InvalidAddressError(params.source, invalidDetail(sourceValidation));
@@ -442,10 +447,13 @@ export class RpcContractProvider extends Provider implements ContractProvider, S
    * @param Unstake pseudo-operation parameter
    */
   async unstake(params: UnstakeParams) {
-    const toValidation = validateAddress(params.to);
-    if (toValidation !== ValidationResult.VALID) {
-      throw new InvalidAddressError(params.to, invalidDetail(toValidation));
+    if (params.to === undefined) {
+      params.to = params.source;
     }
+    if (params.to !== undefined && params.to !== params.source) {
+      throw new InvalidStakingAddressError(params.to);
+    }
+
     const sourceValidation = validateAddress(params.source ?? '');
     if (params.source && sourceValidation !== ValidationResult.VALID) {
       throw new InvalidAddressError(params.source, invalidDetail(sourceValidation));
@@ -477,18 +485,25 @@ export class RpcContractProvider extends Provider implements ContractProvider, S
    * @param Finalize_unstake pseudo-operation parameter
    */
   async finalizeUnstake(params: FinalizeUnstakeParams) {
-    const toValidation = validateAddress(params.to);
-    if (toValidation !== ValidationResult.VALID) {
-      throw new InvalidAddressError(params.to, invalidDetail(toValidation));
+    if (params.to === undefined) {
+      params.to = params.source;
     }
+    if (params.to !== undefined && params.to !== params.source) {
+      throw new InvalidStakingAddressError(params.to);
+    }
+
     const sourceValidation = validateAddress(params.source ?? '');
     if (params.source && sourceValidation !== ValidationResult.VALID) {
       throw new InvalidAddressError(params.source, invalidDetail(sourceValidation));
     }
 
-    if (params.amount < 0) {
-      throw new InvalidAmountError(params.amount.toString());
+    if (params.amount === undefined) {
+      params.amount = 0;
     }
+    if (params.amount !== undefined && params.amount > 0) {
+      throw new InvalidFinalizeUnstakeAmountError('Amount must be 0 to finalize unstake.');
+    }
+
     const publicKeyHash = await this.signer.publicKeyHash();
     const estimate = await this.estimate(
       params,

diff --git a/packages/taquito/src/estimate/rpc-estimate-provider.ts b/packages/taquito/src/estimate/rpc-estimate-provider.ts
@@ -29,7 +29,7 @@ import { ContractMethod, ContractMethodObject, ContractProvider } from '../contr
 import { Provider } from '../provider';
 import { PrepareProvider } from '../prepare/prepare-provider';
 import { PreparedOperation } from '../prepare';
-import { InvalidAddressError, InvalidAmountError } from '@taquito/core';
+import { InvalidAddressError, InvalidAmountError, InvalidStakingAddressError } from '@taquito/core';
 
 // stub signature that won't be verified by tezos rpc simulate_operation
 const STUB_SIGNATURE =
@@ -215,10 +215,13 @@ export class RPCEstimateProvider extends Provider implements EstimationProvider
    * @param Stake pseudo-operation parameter
    */
   async stake({ fee, storageLimit, gasLimit, ...rest }: StakeParams) {
-    const toValidation = validateAddress(rest.to);
-    if (toValidation !== ValidationResult.VALID) {
-      throw new InvalidAddressError(rest.to, invalidDetail(toValidation));
+    if (rest.to === undefined) {
+      rest.to = rest.source;
     }
+    if (rest.to !== undefined && rest.to !== rest.source) {
+      throw new InvalidStakingAddressError(rest.to);
+    }
+
     const sourceValidation = validateAddress(rest.source ?? '');
     if (rest.source && sourceValidation !== ValidationResult.VALID) {
       throw new InvalidAddressError(rest.source, invalidDetail(sourceValidation));
@@ -251,10 +254,13 @@ export class RPCEstimateProvider extends Provider implements EstimationProvider
    * @param Unstake pseudo-operation parameter
    */
   async unstake({ fee, storageLimit, gasLimit, ...rest }: UnstakeParams) {
-    const toValidation = validateAddress(rest.to);
-    if (toValidation !== ValidationResult.VALID) {
-      throw new InvalidAddressError(rest.to, invalidDetail(toValidation));
+    if (rest.to === undefined) {
+      rest.to = rest.source;
+    }
+    if (rest.to !== undefined && rest.to !== rest.source) {
+      throw new InvalidStakingAddressError(rest.to);
     }
+
     const sourceValidation = validateAddress(rest.source ?? '');
     if (rest.source && sourceValidation !== ValidationResult.VALID) {
       throw new InvalidAddressError(rest.source, invalidDetail(sourceValidation));
@@ -287,17 +293,23 @@ export class RPCEstimateProvider extends Provider implements EstimationProvider
    * @param finalize_unstake pseudo-operation parameter
    */
   async finalizeUnstake({ fee, storageLimit, gasLimit, ...rest }: FinalizeUnstakeParams) {
-    const toValidation = validateAddress(rest.to);
-    if (toValidation !== ValidationResult.VALID) {
-      throw new InvalidAddressError(rest.to, invalidDetail(toValidation));
+    if (rest.to === undefined) {
+      rest.to = rest.source;
+    }
+    if (rest.to !== undefined && rest.to !== rest.source) {
+      throw new InvalidStakingAddressError(rest.to);
     }
     const sourceValidation = validateAddress(rest.source ?? '');
     if (rest.source && sourceValidation !== ValidationResult.VALID) {
       throw new InvalidAddressError(rest.source, invalidDetail(sourceValidation));
     }
-    if (rest.amount < 0) {
-      throw new InvalidAmountError(rest.amount.toString());
+    if (rest.amount === undefined) {
+      rest.amount = 0;
     }
+    if (rest.amount !== undefined && rest.amount !== 0) {
+      throw new Error('Amount must be 0 for finalize_unstake operation');
+    }
+
     const preparedOperation = await this.prepare.finalizeUnstake({
       fee,
       storageLimit,

diff --git a/packages/taquito/src/operations/types.ts b/packages/taquito/src/operations/types.ts
@@ -313,17 +313,44 @@ export interface TransferParams {
 /**
  * @description RPC Stake pseudo operation params
  */
-export interface StakeParams extends TransferParams {}
+export interface StakeParams {
+  to?: string;
+  source?: string;
+  amount: number;
+  fee?: number;
+  parameter?: TransactionOperationParameter;
+  gasLimit?: number;
+  storageLimit?: number;
+  mutez?: boolean;
+}
 
 /**
  * @description RPC unstake pseudo operation params
  */
-export interface UnstakeParams extends TransferParams {}
+export interface UnstakeParams {
+  to?: string;
+  source?: string;
+  amount: number;
+  fee?: number;
+  parameter?: TransactionOperationParameter;
+  gasLimit?: number;
+  storageLimit?: number;
+  mutez?: boolean;
+}
 
 /**
  * @description RPC finalize_unstake pseudo operation params
  */
-export interface FinalizeUnstakeParams extends TransferParams {}
+export interface FinalizeUnstakeParams {
+  to?: string;
+  source?: string;
+  amount?: number;
+  fee?: number;
+  parameter?: TransactionOperationParameter;
+  gasLimit?: number;
+  storageLimit?: number;
+  mutez?: boolean;
+}
 
 /**
  * @description RPC register global constant operation

diff --git a/packages/taquito/src/prepare/prepare-provider.ts b/packages/taquito/src/prepare/prepare-provider.ts
@@ -470,6 +470,7 @@ export class PrepareProvider extends Provider implements PreparationProvider {
     const DEFAULT_PARAMS = await this.getOperationLimits(protocolConstants);
     const op = await createTransferOperation({
       ...rest,
+      to: pkh,
       ...mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS),
       parameter: {
         entrypoint: 'stake',
@@ -518,6 +519,7 @@ export class PrepareProvider extends Provider implements PreparationProvider {
     const DEFAULT_PARAMS = await this.getOperationLimits(protocolConstants);
     const op = await createTransferOperation({
       ...rest,
+      to: pkh,
       ...mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS),
       parameter: {
         entrypoint: 'unstake',
@@ -564,6 +566,8 @@ export class PrepareProvider extends Provider implements PreparationProvider {
     const DEFAULT_PARAMS = await this.getOperationLimits(protocolConstants);
     const op = await createTransferOperation({
       ...rest,
+      to: pkh,
+      amount: 0,
       ...mergeLimits({ fee, storageLimit, gasLimit }, DEFAULT_PARAMS),
       parameter: {
         entrypoint: 'finalize_unstake',