feat(sdk-coin-apt): add wallet and address support

TICKET: COIN-2362

Author: baltiyal

modules/sdk-coin-apt/package.json

@@ -42,6 +42,7 @@
   "dependencies": {
     "@bitgo/sdk-core": "^28.14.1",
     "@bitgo/statics": "^50.9.0",
+    "@aptos-labs/ts-sdk": "^1.32.0",
     "bignumber.js": "^9.1.2"
   },
   "devDependencies": {

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

@@ -1,7 +1,9 @@
 import {
   BaseCoin,
   BitGoBase,
+  InvalidAddressError,
   KeyPair,
+  MPCAlgorithm,
   ParsedTransaction,
   ParseTransactionOptions,
   SignedTransaction,
@@ -10,6 +12,8 @@ import {
   VerifyTransactionOptions,
 } from '@bitgo/sdk-core';
 import { BaseCoin as StaticsBaseCoin } from '@bitgo/statics';
+import { KeyPair as AptKeyPair } from './lib';
+import utils from './lib/utils';
 
 export class Apt extends BaseCoin {
   protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
@@ -46,28 +50,54 @@ export class Apt extends BaseCoin {
     return 'Aptos';
   }
 
-  verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {
-    throw new Error('Method not implemented.');
+  /** @inheritDoc */
+  supportsTss(): boolean {
+    return true;
+  }
+
+  getMPCAlgorithm(): MPCAlgorithm {
+    return 'eddsa';
   }
 
-  isWalletAddress(params: VerifyAddressOptions): Promise<boolean> {
+  allowsAccountConsolidations(): boolean {
+    return true;
+  }
+
+  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {
     throw new Error('Method not implemented.');
   }
 
+  async isWalletAddress(params: VerifyAddressOptions): Promise<boolean> {
+    const { address: newAddress } = params;
+
+    if (!this.isValidAddress(newAddress)) {
+      throw new InvalidAddressError(`invalid address: ${newAddress}`);
+    }
+    return true;
+  }
+
   parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {
     throw new Error('Method not implemented.');
   }
 
   generateKeyPair(seed?: Buffer): KeyPair {
-    throw new Error('Method not implemented.');
+    const keyPair = seed ? new AptKeyPair({ seed }) : new AptKeyPair();
+    const keys = keyPair.getKeys();
+    if (!keys.prv) {
+      throw new Error('Missing prv in key generation.');
+    }
+    return {
+      pub: keys.pub,
+      prv: keys.prv,
+    };
   }
 
   isValidPub(pub: string): boolean {
-    throw new Error('Method not implemented.');
+    return utils.isValidPublicKey(pub);
   }
 
   isValidAddress(address: string): boolean {
-    throw new Error('Method not implemented.');
+    return utils.isValidAddress(address);
   }
 
   signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {

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

@@ -0,0 +1,4 @@
+export const APT_ADDRESS_LENGTH = 64;
+export const APT_TRANSACTION_ID_LENGTH = 64;
+export const APT_BLOCK_ID_LENGTH = 64;
+export const APT_SIGNATURE_LENGTH = 128;

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

@@ -1,23 +1,42 @@
-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 APT 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-apt/src/lib/utils.ts

@@ -1,34 +1,48 @@
-import { BaseUtils } from '@bitgo/sdk-core';
+import { AuthenticationKey, Ed25519PublicKey } from '@aptos-labs/ts-sdk';
+import { BaseUtils, isValidEd25519PublicKey, isValidEd25519SecretKey } from '@bitgo/sdk-core';
+import { APT_ADDRESS_LENGTH, APT_BLOCK_ID_LENGTH, APT_SIGNATURE_LENGTH, APT_TRANSACTION_ID_LENGTH } from './constants';
 
 export class Utils implements BaseUtils {
   /** @inheritdoc */
   isValidAddress(address: string): boolean {
-    throw new Error('Method not implemented.');
+    return this.isValidHex(address, APT_ADDRESS_LENGTH);
   }
 
   /** @inheritdoc */
   isValidBlockId(hash: string): boolean {
-    throw new Error('Method not implemented.');
+    return this.isValidHex(hash, APT_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, APT_SIGNATURE_LENGTH);
   }
 
   /** @inheritdoc */
   isValidTransactionId(txId: string): boolean {
-    throw new Error('Method not implemented.');
+    return this.isValidHex(txId, APT_TRANSACTION_ID_LENGTH);
+  }
+
+  isValidHex(value: string, length: number) {
+    const regex = new RegExp(`^(0x|0X)[a-fA-F0-9]{${length}}$`);
+    return regex.test(value);
+  }
+
+  getAddressFromPublicKey(publicKey: string): string {
+    const aptosPublicKey = new Ed25519PublicKey(Buffer.from(publicKey, 'hex'));
+    const authKey = AuthenticationKey.fromPublicKey({ publicKey: aptosPublicKey });
+    const accountAddress = authKey.derivedAddress();
+    return accountAddress.toString();
   }
 }