feat: implement abstract substrate functions

modules/abstract-substrate/package.json

@@ -16,7 +16,7 @@
   "author": "BitGo SDK Team <[email protected]>",
   "license": "MIT",
   "engines": {
-    "node": ">=18 <21"
+    "node": ">=14 <21"
   },
   "repository": {
     "type": "git",
@@ -39,6 +39,16 @@
   },
   "dependencies": {
     "@bitgo/sdk-core": "^28.20.0",
-    "@bitgo/statics": "^50.20.0"
+    "@bitgo/statics": "^50.20.0",
+    "@polkadot/keyring": "13.2.3",
+    "@polkadot/types": "14.1.1",
+    "@polkadot/util": "13.2.3",
+    "@polkadot/util-crypto": "13.2.3",
+    "@substrate/txwrapper-core": "7.5.2",
+    "@substrate/txwrapper-polkadot": "7.5.2",
+    "bs58": "^4.0.1",
+    "hi-base32": "^0.5.1",
+    "lodash": "^4.17.15",
+    "tweetnacl": "^1.0.3"
   }
 }

modules/abstract-substrate/src/abstractSubstrateCoin.ts

@@ -1,3 +1,4 @@
+import * as _ from 'lodash';
 import {
   BaseCoin,
   BitGoBase,
@@ -6,14 +7,44 @@ import {
   ParsedTransaction,
   ParseTransactionOptions,
   SignedTransaction,
-  SignTransactionOptions,
+  SignTransactionOptions as BaseSignTransactionOptions,
   VerifyAddressOptions,
   VerifyTransactionOptions,
 } from '@bitgo/sdk-core';
 import { BaseCoin as StaticsBaseCoin, CoinFamily } from '@bitgo/statics';
+import { Interface, KeyPair as SubstrateKeyPair, Utils } from './lib';
+
+const utils = Utils.default;
+
+export const DEFAULT_SCAN_FACTOR = 20; // default number of receive addresses to scan for funds
+
+export interface SignTransactionOptions extends BaseSignTransactionOptions {
+  txPrebuild: TransactionPrebuild;
+  prv: string;
+}
+
+export interface TransactionPrebuild {
+  txHex: string;
+  transaction: Interface.TxData;
+}
+
+export interface ExplainTransactionOptions {
+  txPrebuild: TransactionPrebuild;
+  publicKey: string;
+  feeInfo: {
+    fee: string;
+  };
+}
+
+export interface VerifiedTransactionParameters {
+  txHex: string;
+  prv: string;
+}
 
 export class SubstrateCoin extends BaseCoin {
   protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
+  readonly MAX_VALIDITY_DURATION = 2400;
+
   protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {
     super(bitgo);
 
@@ -37,7 +68,7 @@ export class SubstrateCoin extends BaseCoin {
 
   /** @inheritDoc **/
   getBaseFactor(): string | number {
-    throw new Error('Method not implemented');
+    return Math.pow(10, this._staticsCoin.decimalPlaces);
   }
 
   /** @inheritDoc **/
@@ -67,12 +98,20 @@ export class SubstrateCoin extends BaseCoin {
 
   /** @inheritDoc **/
   generateKeyPair(seed?: Buffer): KeyPair {
-    throw new Error('Method not implemented');
+    const keyPair = seed ? utils.keyPairFromSeed(new Uint8Array(seed)) : new SubstrateKeyPair();
+    const keys = keyPair.getKeys();
+    if (!keys.prv) {
+      throw new Error('Missing prv in key generation.');
+    }
+    return {
+      pub: keys.pub,
+      prv: keys.prv,
+    };
   }
 
   /** @inheritDoc **/
   isValidPub(pub: string): boolean {
-    throw new Error('Method not implemented');
+    return utils.isValidPublicKey(pub);
   }
 
   /** @inheritDoc **/
@@ -86,17 +125,68 @@ export class SubstrateCoin extends BaseCoin {
   }
 
   /** @inheritDoc **/
-  verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {
-    throw new Error('Method not implemented');
+  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {
+    const { txParams } = params;
+    if (Array.isArray(txParams.recipients) && txParams.recipients.length > 1) {
+      throw new Error(
+        `${this.getChain()} doesn't support sending to more than 1 destination address within a single transaction. Try again, using only a single recipient.`
+      );
+    }
+    return true;
   }
 
   /** @inheritDoc **/
   isValidAddress(address: string): boolean {
-    throw new Error('Method not implemented.');
+    return utils.isValidAddress(address);
+  }
+
+  verifySignTransactionParams(params: SignTransactionOptions): VerifiedTransactionParameters {
+    const prv = params.prv;
+
+    const txHex = params.txPrebuild.txHex;
+
+    if (!txHex) {
+      throw new Error('missing txPrebuild parameter');
+    }
+
+    if (!_.isString(txHex)) {
+      throw new Error(`txPrebuild must be an object, got type ${typeof txHex}`);
+    }
+
+    if (!prv) {
+      throw new Error('missing prv parameter to sign transaction');
+    }
+
+    if (!_.isString(prv)) {
+      throw new Error(`prv must be a string, got type ${typeof prv}`);
+    }
+
+    if (!_.has(params, 'pubs')) {
+      throw new Error('missing public key parameter to sign transaction');
+    }
+
+    return { txHex, prv };
   }
 
   /** @inheritDoc **/
-  signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {
-    throw new Error('Method not implemented.');
+  async signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {
+    const { txHex, prv } = this.verifySignTransactionParams(params);
+    const factory = this.getBuilder();
+    const txBuilder = factory.from(txHex);
+    const keyPair = new SubstrateKeyPair({ prv: prv });
+    const { referenceBlock, blockNumber, transactionVersion, sender } = params.txPrebuild.transaction;
+
+    txBuilder
+      .validity({ firstValid: blockNumber, maxDuration: this.MAX_VALIDITY_DURATION })
+      .referenceBlock(referenceBlock)
+      .version(transactionVersion)
+      .sender({ address: sender })
+      .sign({ key: keyPair.getKeys().prv });
+    const transaction = await txBuilder.build();
+    if (!transaction) {
+      throw new Error('Invalid transaction');
+    }
+    const signedTxHex = transaction.toBroadcastFormat();
+    return { txHex: signedTxHex };
   }
 }

modules/abstract-substrate/src/index.ts

@@ -1 +1,2 @@
+export * from './lib';
 export { SubstrateCoin } from './abstractSubstrateCoin';