feat(sdk-coin-iota): implement key creation and validation

- Update Iota to use GasTankAccount
- Add core functionality for IOTA coin library including:
 - Key pair generation with optional seed support
 - Address and public key validation methods
 - TSS support configuration and algorithm specification
 - Audit functionality for decrypted private keys

Ticket: WIN-6869

Author: parasgarg-bitgo

modules/sdk-coin-iota/package.json

@@ -42,10 +42,12 @@
   "dependencies": {
     "@bitgo/sdk-core": "^36.5.0",
     "@bitgo/statics": "^57.5.0",
+    "@iota/iota-sdk": "^1.6.0",
     "bignumber.js": "^9.1.2"
   },
   "devDependencies": {
     "@bitgo/sdk-api": "^1.67.0",
+    "@bitgo/sdk-lib-mpc": "^10.7.0",
     "@bitgo/sdk-test": "^9.0.5"
   }
 }

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

@@ -2,16 +2,24 @@ import {
   AuditDecryptedKeyParams,
   BaseCoin,
   BitGoBase,
-  KeyPair as KeyPairInterface,
+  KeyPair,
   ParseTransactionOptions,
   ParsedTransaction,
   SignTransactionOptions,
   SignedTransaction,
-  VerifyAddressOptions,
   VerifyTransactionOptions,
+  MultisigType,
+  multisigTypes,
+  MPCAlgorithm,
+  InvalidAddressError,
+  EDDSAMethods,
+  TssVerifyAddressOptions,
+  MPCType,
 } from '@bitgo/sdk-core';
 import { BaseCoin as StaticsBaseCoin, CoinFamily } from '@bitgo/statics';
 import utils from './lib/utils';
+import { KeyPair as IotaKeyPair } from './lib';
+import { auditEddsaPrivateKey } from '@bitgo/sdk-lib-mpc';
 
 export class Iota extends BaseCoin {
   protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
@@ -46,6 +54,20 @@ export class Iota extends BaseCoin {
     return this._staticsCoin.fullName;
   }
 
+  /** @inheritDoc */
+  supportsTss(): boolean {
+    return true;
+  }
+
+  /** inherited doc */
+  getDefaultMultisigType(): MultisigType {
+    return multisigTypes.tss;
+  }
+
+  getMPCAlgorithm(): MPCAlgorithm {
+    return MPCType.EDDSA;
+  }
+
   /**
    * Check if an address is valid
    * @param address the address to be validated
@@ -69,8 +91,30 @@ export class Iota extends BaseCoin {
    * Check if an address belongs to a wallet
    * @param params
    */
-  async isWalletAddress(params: VerifyAddressOptions): Promise<boolean> {
-    return this.isValidAddress(params.address);
+  async isWalletAddress(params: TssVerifyAddressOptions): Promise<boolean> {
+    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;
   }
 
   /**
@@ -86,12 +130,15 @@ export class Iota extends BaseCoin {
    * Generate a key pair
    * @param seed Optional seed to generate key pair from
    */
-  generateKeyPair(seed?: Uint8Array): KeyPairInterface {
-    // For now we're just returning an empty implementation as the KeyPair class needs to be implemented
-    // In a real implementation, we would use the KeyPair class properly
+  generateKeyPair(seed?: Buffer): KeyPair {
+    const keyPair = seed ? new IotaKeyPair({ seed }) : new IotaKeyPair();
+    const keys = keyPair.getKeys();
+    if (!keys.prv) {
+      throw new Error('Missing prv in key generation.');
+    }
     return {
-      pub: '',
-      prv: '',
+      pub: keys.pub,
+      prv: keys.prv,
     };
   }
 
@@ -100,28 +147,25 @@ export class Iota extends BaseCoin {
    * @param pub Public key to check
    */
   isValidPub(pub: string): boolean {
-    // TODO: Implement proper IOTA public key validation
-    return pub.length > 0;
+    return utils.isValidPublicKey(pub);
   }
 
   /**
    * Sign a transaction
    * @param params
    */
   async signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {
-    // TODO: Add IOTA-specific transaction signing logic
-    return {
-      halfSigned: {
-        txHex: '',
-      },
-    };
+    throw new Error('Method not implemented.');
   }
 
   /**
    * Audit a decrypted private key to ensure it's valid
    * @param params
    */
-  auditDecryptedKey(params: AuditDecryptedKeyParams): void {
-    // TODO: Implement IOTA-specific key validation logic
+  auditDecryptedKey({ multiSigType, prv, publicKey }: AuditDecryptedKeyParams): void {
+    if (multiSigType !== multisigTypes.tss) {
+      throw new Error('Unsupported multiSigType');
+    }
+    auditEddsaPrivateKey(prv, publicKey ?? '');
   }
 }

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

@@ -5,7 +5,3 @@ export const IOTA_SIGNATURE_LENGTH = 128;
 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
-
-// Define IOTA specific function paths
-export const IOTA_TRANSFER_FUNCTION = '0x0::coin::transfer';
-export const IOTA_BATCH_TRANSFER_FUNCTION = '0x1::coin_batch::transfer';

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

@@ -1,23 +1,41 @@
-import { DefaultKeys, Ed25519KeyPair } from '@bitgo/sdk-core';
+import { DefaultKeys, Ed25519KeyPair, KeyPairOptions } from '@bitgo/sdk-core';
+import utils from './utils';
 
 export class KeyPair extends Ed25519KeyPair {
+  /**
+   * Public constructor. By default, creates a key pair with a random master seed.
+   *
+   * @param { KeyPairOptions } source Either a master seed, a private key, or a public key
+   */
+  constructor(source?: KeyPairOptions) {
+    super(source);
+  }
+
   /** @inheritdoc */
   getKeys(): DefaultKeys {
-    throw new Error('Method not implemented.');
+    const result: DefaultKeys = { pub: this.keyPair.pub };
+    if (this.keyPair.prv) {
+      result.prv = this.keyPair.prv;
+    }
+    return result;
   }
 
   /** @inheritdoc */
   recordKeysFromPrivateKeyInProtocolFormat(prv: string): DefaultKeys {
+    // We don't use private keys for IOTA since it's implemented for TSS.
     throw new Error('Method not implemented.');
   }
 
   /** @inheritdoc */
   recordKeysFromPublicKeyInProtocolFormat(pub: string): DefaultKeys {
-    throw new Error('Method not implemented.');
+    if (!utils.isValidPublicKey(pub)) {
+      throw new Error(`Invalid Public Key ${pub}`);
+    }
+    return { pub };
   }
 
   /** @inheritdoc */
   getAddress(): string {
-    throw new Error('Method not implemented.');
+    return utils.getAddressFromPublicKey(this.keyPair.pub);
   }
 }

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

@@ -1,34 +1,51 @@
-import { BaseUtils } from '@bitgo/sdk-core';
+import { BaseUtils, isValidEd25519PublicKey, isValidEd25519SecretKey } from '@bitgo/sdk-core';
+import {
+  IOTA_ADDRESS_LENGTH,
+  IOTA_BLOCK_ID_LENGTH,
+  IOTA_SIGNATURE_LENGTH,
+  IOTA_TRANSACTION_ID_LENGTH,
+} from './constants';
+import { Ed25519PublicKey } from '@iota/iota-sdk/keypairs/ed25519';
 
 export class Utils implements BaseUtils {
   /** @inheritdoc */
   isValidAddress(address: string): boolean {
-    throw new Error('Method not implemented.');
+    return this.isValidHex(address, IOTA_ADDRESS_LENGTH);
   }
 
   /** @inheritdoc */
   isValidBlockId(hash: string): boolean {
-    throw new Error('Method not implemented.');
+    return this.isValidHex(hash, IOTA_BLOCK_ID_LENGTH);
   }
 
   /** @inheritdoc */
   isValidPrivateKey(key: string): boolean {
-    throw new Error('Method not implemented.');
+    return isValidEd25519SecretKey(key);
   }
 
   /** @inheritdoc */
   isValidPublicKey(key: string): boolean {
-    throw new Error('Method not implemented.');
+    return isValidEd25519PublicKey(key);
   }
 
   /** @inheritdoc */
   isValidSignature(signature: string): boolean {
-    throw new Error('Method not implemented.');
+    return this.isValidHex(signature, IOTA_SIGNATURE_LENGTH);
   }
 
   /** @inheritdoc */
   isValidTransactionId(txId: string): boolean {
-    throw new Error('Method not implemented.');
+    return this.isValidHex(txId, IOTA_TRANSACTION_ID_LENGTH);
+  }
+
+  isValidHex(value: string, length: number): boolean {
+    const regex = new RegExp(`^(0x|0X)[a-fA-F0-9]{${length}}$`);
+    return regex.test(value);
+  }
+
+  getAddressFromPublicKey(publicKey: string): string {
+    const iotaPublicKey = new Ed25519PublicKey(Buffer.from(publicKey, 'hex'));
+    return iotaPublicKey.toIotaAddress();
   }
 }
 

modules/sdk-coin-iota/test/integration/index.ts

@@ -0,0 +1,11 @@
+export const addresses = {
+  validAddresses: [
+    '0xda97e166d40fa6a0c949b6aeb862e391c29139b563ae0430b2419c589a02a6e0',
+    '0x0502b39ec0b82c10c64a07e969ee1140e67d8e0c0fc0c0f6319fe7e47dbb0ab5',
+  ],
+  invalidAddresses: [
+    'randomString',
+    '0xc4173a804406a365e69dfb297ddfgsdcvf',
+    '5ne7phA48Jrvpn39AtupB8ZkCCAy8gLTfpGihZPuDqen',
+  ],
+};