Merge pull request #5614 from BitGo/add-missing-methods-for-tao

feat(abstract-substrate): add missing methods for TAO stake/unstake

Author: Vijay-Jagannathan

modules/abstract-substrate/src/lib/iface.ts

@@ -56,6 +56,7 @@ export interface TxData {
   eraPeriod?: number;
   payee?: string;
   keepAlive?: boolean;
+  netuid?: number;
 }
 
 /**

modules/abstract-substrate/src/lib/transaction.ts

@@ -151,8 +151,8 @@ export class Transaction extends BaseTransaction {
       tip: decodedTx.tip ? Number(decodedTx.tip) : 0,
     };
 
+    const txMethod = decodedTx.method.args;
     if (this.type === TransactionType.Send) {
-      const txMethod = decodedTx.method.args;
       if (utils.isTransfer(txMethod)) {
         const keypairDest = new KeyPair({
           pub: Buffer.from(decodeAddress(txMethod.dest.id)).toString('hex'),
@@ -168,6 +168,26 @@ export class Transaction extends BaseTransaction {
       } else {
         throw new ParseTransactionError(`Serializing unknown Transfer type parameters`);
       }
+    } else if (this.type === TransactionType.StakingActivate) {
+      if (utils.isAddStake(txMethod)) {
+        const keypairDest = new KeyPair({
+          pub: Buffer.from(decodeAddress(txMethod.hotkey)).toString('hex'),
+        });
+        // hotkey address of validator
+        result.to = keypairDest.getAddress(this.getAddressFormat());
+        result.amount = txMethod.amountStaked.toString();
+        result.netuid = txMethod.netuid;
+      }
+    } else if (this.type === TransactionType.StakingDeactivate) {
+      if (utils.isRemoveStake(txMethod)) {
+        const keypairDest = new KeyPair({
+          pub: Buffer.from(decodeAddress(txMethod.hotkey)).toString('hex'),
+        });
+        // hotkey address of validator
+        result.to = keypairDest.getAddress(this.getAddressFormat());
+        result.amount = txMethod.amountUnstaked.toString();
+        result.netuid = txMethod.netuid;
+      }
     }
 
     return result;
@@ -185,6 +205,30 @@ export class Transaction extends BaseTransaction {
     };
   }
 
+  explainStakeTransaction(json: TxData, explanationResult: TransactionExplanation): TransactionExplanation {
+    return {
+      ...explanationResult,
+      outputs: [
+        {
+          address: json.to?.toString() || '',
+          amount: json.amount?.toString() || '',
+        },
+      ],
+    };
+  }
+
+  explainUnstakeTransaction(json: TxData, explanationResult: TransactionExplanation): TransactionExplanation {
+    return {
+      ...explanationResult,
+      outputs: [
+        {
+          address: json.sender.toString() || '',
+          amount: json.amount?.toString() || '',
+        },
+      ],
+    };
+  }
+
   /** @inheritdoc */
   explainTransaction(): TransactionExplanation {
     const result = this.toJson();
@@ -205,6 +249,10 @@ export class Transaction extends BaseTransaction {
     switch (this.type) {
       case TransactionType.Send:
         return this.explainTransferTransaction(result, explanationResult);
+      case TransactionType.StakingActivate:
+        return this.explainStakeTransaction(result, explanationResult);
+      case TransactionType.StakingDeactivate:
+        return this.explainUnstakeTransaction(result, explanationResult);
       default:
         throw new InvalidTransactionError('Transaction type not supported');
     }
@@ -225,6 +273,10 @@ export class Transaction extends BaseTransaction {
 
     if (this.type === TransactionType.Send) {
       this.decodeInputsAndOutputsForSend(decodedTx);
+    } else if (this.type === TransactionType.StakingActivate) {
+      this.decodeInputsAndOutputsForStakingActivate(decodedTx);
+    } else if (this.type === TransactionType.StakingDeactivate) {
+      this.decodeInputsAndOutputsForStakingDeactivate(decodedTx);
     }
   }
 
@@ -267,6 +319,70 @@ export class Transaction extends BaseTransaction {
     ];
   }
 
+  private decodeInputsAndOutputsForStakingActivate(decodedTx: DecodedTx) {
+    const txMethod = decodedTx.method.args;
+    let to: string;
+    let value: string;
+    let from: string;
+    if (utils.isAddStake(txMethod)) {
+      const keypairDest = new KeyPair({
+        pub: Buffer.from(decodeAddress(txMethod.hotkey)).toString('hex'),
+      });
+      to = keypairDest.getAddress(this.getAddressFormat());
+      value = txMethod.amountStaked.toString();
+      from = decodedTx.address;
+    } else {
+      throw new ParseTransactionError(`Loading inputs of unknown StakingActivate type parameters`);
+    }
+    this._outputs = [
+      {
+        address: to,
+        value,
+        coin: this._coinConfig.name,
+      },
+    ];
+
+    this._inputs = [
+      {
+        address: from,
+        value,
+        coin: this._coinConfig.name,
+      },
+    ];
+  }
+
+  private decodeInputsAndOutputsForStakingDeactivate(decodedTx: DecodedTx) {
+    const txMethod = decodedTx.method.args;
+    let to: string;
+    let value: string;
+    let from: string;
+    if (utils.isRemoveStake(txMethod)) {
+      const keypairDest = new KeyPair({
+        pub: Buffer.from(decodeAddress(txMethod.hotkey)).toString('hex'),
+      });
+      to = keypairDest.getAddress(this.getAddressFormat());
+      value = txMethod.amountUnstaked.toString();
+      from = decodedTx.address;
+    } else {
+      throw new ParseTransactionError(`Loading inputs of unknown StakingDeactivate type parameters`);
+    }
+    this._outputs = [
+      {
+        address: from,
+        value,
+        coin: this._coinConfig.name,
+      },
+    ];
+
+    this._inputs = [
+      {
+        address: to,
+        value,
+        coin: this._coinConfig.name,
+      },
+    ];
+  }
+
   /**
    * Constructs a signed payload using construct.signTx
    * This method will be called during the build step if a TSS signature

modules/abstract-substrate/src/lib/utils.ts

@@ -13,7 +13,7 @@ import bs58 from 'bs58';
 import base32 from 'hi-base32';
 import nacl from 'tweetnacl';
 import { KeyPair } from '.';
-import { HexString, Material, TransferAllArgs, TransferArgs, TxMethod } from './iface';
+import { HexString, Material, TransferAllArgs, TransferArgs, TxMethod, AddStakeArgs, RemoveStakeArgs } from './iface';
 
 export class Utils implements BaseUtils {
   /** @inheritdoc */
@@ -195,6 +195,22 @@ export class Utils implements BaseUtils {
     return (arg as TransferAllArgs).dest?.id !== undefined && (arg as TransferAllArgs).keepAlive !== undefined;
   }
 
+  isAddStake(arg: TxMethod['args']): arg is AddStakeArgs {
+    return (
+      (arg as AddStakeArgs).amountStaked !== undefined &&
+      (arg as AddStakeArgs).hotkey !== undefined &&
+      (arg as AddStakeArgs).netuid !== undefined
+    );
+  }
+
+  isRemoveStake(arg: TxMethod['args']): arg is RemoveStakeArgs {
+    return (
+      (arg as RemoveStakeArgs).amountUnstaked !== undefined &&
+      (arg as RemoveStakeArgs).hotkey !== undefined &&
+      (arg as RemoveStakeArgs).netuid !== undefined
+    );
+  }
+
   /**
    * extracts and returns the signature in hex format given a raw signed transaction
    *