feat(sdk-coin-ada): support vote delegation

support voting to DRep in Chang hardfork
Ticket: SC-660

Author: ryandengBG

modules/sdk-coin-ada/src/lib/index.ts

@@ -10,4 +10,5 @@ export { StakingClaimRewardsBuilder } from './stakingClaimRewardsBuilder';
 export { StakingDeactivateBuilder } from './stakingDeactivateBuilder';
 export { StakingWithdrawBuilder } from './stakingWithdrawBuilder';
 export { StakingPledgeBuilder } from './stakingPledgeBuilder';
+export { StakingVoteDelegationBuilder } from './stakingVoteDelegationBuilder';
 export { Utils };

modules/sdk-coin-ada/src/lib/stakingVoteDelegationBuilder.ts

@@ -0,0 +1,49 @@
+import { BaseKey, TransactionType } from '@bitgo/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { TransactionBuilder } from './transactionBuilder';
+import { Transaction } from './transaction';
+import * as CardanoWasm from '@emurgo/cardano-serialization-lib-nodejs';
+import { bech32 } from 'bech32';
+
+export class StakingVoteDelegationBuilder extends TransactionBuilder {
+  constructor(_coinConfig: Readonly<CoinConfig>) {
+    super(_coinConfig);
+    this._type = TransactionType.StakingVote;
+  }
+  protected get transactionType(): TransactionType {
+    return TransactionType.StakingVote;
+  }
+  /** @inheritdoc */
+  initBuilder(tx: Transaction): void {
+    super.initBuilder(tx);
+  }
+  /** @inheritdoc */
+  protected async buildImplementation(): Promise<Transaction> {
+    const tx = await super.buildImplementation();
+    tx.setTransactionType(TransactionType.StakingVote);
+    return tx;
+  }
+  /** @inheritdoc */
+  protected fromImplementation(rawTransaction: string): Transaction {
+    return super.fromImplementation(rawTransaction);
+  }
+  protected signImplementation(key: BaseKey): Transaction {
+    return super.signImplementation(key);
+  }
+
+  voteDelegationCredential(stakingPublicKey: string, dRepId: string): this {
+    const stakeCredential = CardanoWasm.Credential.from_keyhash(
+      CardanoWasm.PublicKey.from_bytes(Buffer.from(stakingPublicKey, 'hex')).hash()
+    );
+    const decoded = bech32.decode(dRepId);
+    const decodedKeyHash = Buffer.from(bech32.fromWords(decoded.words)).toString('hex');
+    const voteDelegationCert = CardanoWasm.Certificate.new_vote_delegation(
+      CardanoWasm.VoteDelegation.new(
+        stakeCredential,
+        CardanoWasm.DRep.new_key_hash(CardanoWasm.Ed25519KeyHash.from_hex(decodedKeyHash))
+      )
+    );
+    this._certs.push(voteDelegationCert);
+    return this;
+  }
+}

modules/sdk-coin-ada/src/lib/transaction.ts

@@ -36,12 +36,14 @@ enum CertType {
   StakeKeyDelegation,
   StakeKeyDeregistration,
   StakePoolRegistration,
+  StakeVoteDelegation,
 }
 
 export interface Cert {
   type: CertType;
   stakeCredentialHash?: string;
   poolKeyHash?: string;
+  dRepId?: string;
 }
 
 export interface Withdrawal {
@@ -183,6 +185,14 @@ export class Transaction extends BaseTransaction {
             poolKeyHash: Buffer.from(stakePoolRegistration.pool_params().operator().to_bytes()).toString('hex'),
           });
         }
+        if (cert.as_vote_delegation() !== undefined) {
+          const voteDelegation = cert.as_vote_delegation() as CardanoWasm.VoteDelegation;
+          result.certs.push({
+            type: CertType.StakeVoteDelegation,
+            stakeCredentialHash: Buffer.from(voteDelegation.stake_credential().to_bytes()).toString('hex'),
+            dRepId: Buffer.from(voteDelegation.drep().to_bytes()).toString('hex'),
+          });
+        }
       }
     }
 
@@ -263,8 +273,9 @@ export class Transaction extends BaseTransaction {
           const cert = this._transaction.body().certs()!.get(i);
           certs.push(cert);
         }
-
-        if (certs.some((c) => c.as_pool_registration() !== undefined)) {
+        if (certs.some((c) => c.as_vote_delegation() !== undefined)) {
+          this._type = TransactionType.StakingVote;
+        } else if (certs.some((c) => c.as_pool_registration() !== undefined)) {
           this._type = TransactionType.StakingPledge;
           const stakeKeyRegistration = certs.find((c) => c.as_stake_registration() !== undefined);
           const stakeKeyDelegation = certs.find((c) => c.as_stake_delegation() !== undefined);
@@ -394,6 +405,8 @@ export class Transaction extends BaseTransaction {
         ? 'StakingDeactivate'
         : this._type === TransactionType.StakingPledge
         ? 'StakingPledge'
+        : this._type === TransactionType.StakingVote
+        ? 'StakingVote'
         : 'undefined';
     return {
       displayOrder,

modules/sdk-coin-ada/src/lib/transactionBuilderFactory.ts

@@ -9,6 +9,7 @@ import { StakingDeactivateBuilder } from './stakingDeactivateBuilder';
 import { StakingWithdrawBuilder } from './stakingWithdrawBuilder';
 import { StakingPledgeBuilder } from './stakingPledgeBuilder';
 import { StakingClaimRewardsBuilder } from './stakingClaimRewardsBuilder';
+import { StakingVoteDelegationBuilder } from '..';
 
 export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
   constructor(_coinConfig: Readonly<CoinConfig>) {
@@ -38,6 +39,8 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
           return this.getWalletInitializationBuilder(tx);
         case TransactionType.StakingPledge:
           return this.getStakingPledgeBuilder(tx);
+        case TransactionType.StakingVote:
+          return this.getStakingVoteDelegationBuilder(tx);
         default:
           throw new InvalidTransactionError('unsupported transaction');
       }
@@ -76,6 +79,10 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
     return TransactionBuilderFactory.initializeBuilder(tx, new StakingPledgeBuilder(this._coinConfig));
   }
 
+  getStakingVoteDelegationBuilder(tx?: Transaction) {
+    return TransactionBuilderFactory.initializeBuilder(tx, new StakingVoteDelegationBuilder(this._coinConfig));
+  }
+
   /**
    * Initialize the builder with the given transaction
    *