feat(sdk-coin-iota): transaction builder for iota

TICKET: WIN-6890

Author: parasgarg-bitgo

modules/sdk-coin-iota/src/iota.ts

@@ -3,22 +3,33 @@ import {
   BaseCoin,
   BitGoBase,
   KeyPair,
-  ParseTransactionOptions,
   ParsedTransaction,
   SignTransactionOptions,
   SignedTransaction,
   VerifyTransactionOptions,
   MultisigType,
   multisigTypes,
   MPCAlgorithm,
+  InvalidAddressError,
+  EDDSAMethods,
   TssVerifyAddressOptions,
   MPCType,
-  verifyEddsaTssWalletAddress,
+  PopulatedIntent,
+  PrebuildTransactionWithIntentOptions,
 } from '@bitgo/sdk-core';
-import { BaseCoin as StaticsBaseCoin, CoinFamily } from '@bitgo/statics';
+import { BaseCoin as StaticsBaseCoin, CoinFamily, coins } from '@bitgo/statics';
 import utils from './lib/utils';
-import { KeyPair as IotaKeyPair } from './lib';
+import { KeyPair as IotaKeyPair, Transaction, TransactionBuilderFactory } from './lib';
 import { auditEddsaPrivateKey } from '@bitgo/sdk-lib-mpc';
+import BigNumber from 'bignumber.js';
+import * as _ from 'lodash';
+import {
+  ExplainTransactionOptions,
+  IotaParseTransactionOptions,
+  TransactionExplanation,
+  TransferTxData,
+} from './lib/iface';
+import { TransferTransaction } from './lib/transferTransaction';
 
 export class Iota extends BaseCoin {
   protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
@@ -77,12 +88,44 @@ export class Iota extends BaseCoin {
     return utils.isValidAddress(address);
   }
 
+  /**
+   * @inheritDoc
+   */
+  async explainTransaction(params: ExplainTransactionOptions): Promise<TransactionExplanation> {
+    const rawTx = params.txBase64;
+    if (!rawTx) {
+      throw new Error('missing required tx prebuild property txBase64');
+    }
+    const transaction = await this.rebuildTransaction(rawTx);
+    if (!transaction) {
+      throw new Error('failed to explain transaction');
+    }
+    return transaction.explainTransaction();
+  }
+
   /**
    * Verifies that a transaction prebuild complies with the original intention
    * @param params
    */
   async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {
-    // TODO: Add IOTA-specific transaction verification logic
+    const { txPrebuild: txPrebuild, txParams: txParams } = params;
+    const rawTx = txPrebuild.txBase64;
+    if (!rawTx) {
+      throw new Error('missing required tx prebuild property txBase64');
+    }
+    const transaction = await this.rebuildTransaction(rawTx);
+    if (!transaction) {
+      throw new Error('failed to verify transaction');
+    }
+    if (txParams.recipients !== undefined) {
+      if (!(transaction instanceof TransferTransaction)) {
+        throw new Error('Tx not a transfer transaction');
+      }
+      const txData = transaction.toJson() as TransferTxData;
+      if (!txData.recipients || !_.isEqual(txParams.recipients, txData.recipients)) {
+        throw new Error('Tx recipients does not match with expected txParams recipients');
+      }
+    }
     return true;
   }
 
@@ -91,20 +134,80 @@ export class Iota extends BaseCoin {
    * @param params
    */
   async isWalletAddress(params: TssVerifyAddressOptions): Promise<boolean> {
-    return verifyEddsaTssWalletAddress(
-      params,
-      (address) => this.isValidAddress(address),
-      (publicKey) => utils.getAddressFromPublicKey(publicKey)
-    );
+    const { keychains, address, index } = params;
+
+    if (!this.isValidAddress(address)) {
+      throw new InvalidAddressError(`invalid address: ${address}`);
+    }
+
+    if (!keychains) {
+      throw new Error('missing required param keychains');
+    }
+
+    for (const keychain of keychains) {
+      const MPC = await EDDSAMethods.getInitializedMpcInstance();
+      const commonKeychain = keychain.commonKeychain as string;
+
+      const derivationPath = 'm/' + index;
+      const derivedPublicKey = MPC.deriveUnhardened(commonKeychain, derivationPath).slice(0, 64);
+      const expectedAddress = utils.getAddressFromPublicKey(derivedPublicKey);
+
+      if (address !== expectedAddress) {
+        return false;
+      }
+    }
+    return true;
   }
 
   /**
    * Parse a transaction
    * @param params
    */
-  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {
-    // TODO: Add IOTA-specific transaction parsing logic
-    return {};
+  async parseTransaction(params: IotaParseTransactionOptions): Promise<ParsedTransaction> {
+    const transactionExplanation = await this.explainTransaction({ txBase64: params.txBase64 });
+
+    if (!transactionExplanation) {
+      throw new Error('Invalid transaction');
+    }
+
+    let fee = new BigNumber(0);
+
+    if (transactionExplanation.outputs.length <= 0) {
+      return {
+        inputs: [],
+        outputs: [],
+        fee,
+      };
+    }
+
+    const senderAddress = transactionExplanation.outputs[0].address;
+    if (transactionExplanation.fee.fee !== '') {
+      fee = new BigNumber(transactionExplanation.fee.fee);
+    }
+
+    // assume 1 sender, who is also the fee payer
+    const inputs = [
+      {
+        address: senderAddress,
+        amount: new BigNumber(transactionExplanation.outputAmount).plus(fee).toFixed(),
+      },
+    ];
+
+    const outputs: {
+      address: string;
+      amount: string;
+    }[] = transactionExplanation.outputs.map((output) => {
+      return {
+        address: output.address,
+        amount: new BigNumber(output.amount).toFixed(),
+      };
+    });
+
+    return {
+      inputs,
+      outputs,
+      fee,
+    };
   }
 
   /**
@@ -149,4 +252,30 @@ export class Iota extends BaseCoin {
     }
     auditEddsaPrivateKey(prv, publicKey ?? '');
   }
+
+  /** @inheritDoc */
+  async getSignablePayload(serializedTx: string): Promise<Buffer> {
+    const rebuiltTransaction = await this.rebuildTransaction(serializedTx);
+    return rebuiltTransaction.signablePayload;
+  }
+
+  /** inherited doc */
+  setCoinSpecificFieldsInIntent(intent: PopulatedIntent, params: PrebuildTransactionWithIntentOptions): void {
+    intent.unspents = params.unspents;
+  }
+
+  private getTxBuilderFactory(): TransactionBuilderFactory {
+    return new TransactionBuilderFactory(coins.get(this.getChain()));
+  }
+
+  private async rebuildTransaction(txHex: string): Promise<Transaction> {
+    const txBuilderFactory = this.getTxBuilderFactory();
+    try {
+      const txBuilder = txBuilderFactory.from(txHex);
+      txBuilder.transaction.isSimulateTx = false;
+      return (await txBuilder.build()) as Transaction;
+    } catch {
+      throw new Error('Failed to rebuild transaction');
+    }
+  }
 }

modules/sdk-coin-iota/src/lib/constants.ts

@@ -2,6 +2,11 @@ export const IOTA_ADDRESS_LENGTH = 64;
 export const IOTA_TRANSACTION_DIGEST_LENGTH = 32;
 export const IOTA_BLOCK_DIGEST_LENGTH = 32;
 export const IOTA_SIGNATURE_LENGTH = 64;
-export const ADDRESS_BYTES_LENGTH = 32;
-export const AMOUNT_BYTES_LENGTH = 8;
-export const SECONDS_PER_WEEK = 7 * 24 * 60 * 60; // 1 week in seconds
+export const IOTA_KEY_LENGTH = 64; // Ed25519 private key is 32 bytes = 64 hex characters
+export const IOTA_KEY_BYTES_LENGTH = 32; // Ed25519 public key is 32 bytes
+export const MAX_INPUT_OBJECTS = 2048;
+export const MAX_GAS_PAYMENT_OBJECTS = 256;
+export const MAX_GAS_BUDGET = 50000000000;
+export const MAX_GAS_PRICE = 100000;
+export const MAX_RECIPIENTS = 256; // Maximum number of recipients in a transfer transaction
+export const TRANSFER_TRANSACTION_COMMANDS = ['SplitCoins', 'MergeCoins', 'TransferObjects'];

modules/sdk-coin-iota/src/lib/iface.ts

@@ -1,6 +1,49 @@
+import {
+  ParseTransactionOptions as BaseParseTransactionOptions,
+  TransactionExplanation as BaseTransactionExplanation,
+  TransactionRecipient,
+  TransactionType as BitGoTransactionType,
+  TransactionType,
+} from '@bitgo/sdk-core';
+
+export interface TransactionExplanation extends BaseTransactionExplanation {
+  type: BitGoTransactionType;
+}
+
+export type TransactionObjectInput = {
+  objectId: string;
+  version: string;
+  digest: string;
+};
+
+export type GasData = {
+  gasBudget?: number;
+  gasPrice?: number;
+  gasPaymentObjects?: TransactionObjectInput[];
+};
+
 /**
  * The transaction data returned from the toJson() function of a transaction
  */
 export interface TxData {
-  id: string;
+  id?: string;
+  sender: string;
+  gasBudget?: number;
+  gasPrice?: number;
+  gasPaymentObjects?: TransactionObjectInput[];
+  gasSponsor?: string;
+  type: TransactionType;
+}
+
+export interface TransferTxData extends TxData {
+  recipients: TransactionRecipient[];
+  paymentObjects?: TransactionObjectInput[];
+}
+
+export interface ExplainTransactionOptions {
+  txBase64: string;
+}
+
+export interface IotaParseTransactionOptions extends BaseParseTransactionOptions {
+  txBase64: string;
 }

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

@@ -5,5 +5,6 @@ export { KeyPair } from './keyPair';
 export { Transaction } from './transaction';
 export { TransactionBuilder } from './transactionBuilder';
 export { TransferBuilder } from './transferBuilder';
+export { TransferTransaction } from './transferTransaction';
 export { TransactionBuilderFactory } from './transactionBuilderFactory';
 export { Interface, Utils };