feat(sdk-coin-ada): implement key pair and utils for ada sdk

Ticket: origin/BG-50795

Author: margueriteblair

modules/bitgo/package.json

@@ -50,7 +50,6 @@
     "@bitgo/account-lib": "^2.19.0",
     "@bitgo/blockapis": "^1.0.1",
     "@bitgo/sdk-api": "^1.0.1",
-    "@bitgo/sdk-coin-ada": "^1.0.0",
     "@bitgo/sdk-coin-algo": "^1.0.0",
     "@bitgo/sdk-coin-avaxc": "^1.0.0",
     "@bitgo/sdk-coin-avaxp": "^1.0.0",

modules/bitgo/src/v2/coinFactory.ts

@@ -5,7 +5,6 @@ import { CoinFactory } from '@bitgo/sdk-core';
 import { AlgoToken } from '@bitgo/sdk-coin-algo';
 import { Bcha, Tbcha } from '@bitgo/sdk-coin-bcha';
 import {
-  Ada,
   Algo,
   AvaxC,
   AvaxCToken,
@@ -39,7 +38,6 @@ import {
   StellarToken,
   Stx,
   Susd,
-  Tada,
   Talgo,
   TavaxC,
   TavaxP,
@@ -81,7 +79,6 @@ import { SolToken } from '@bitgo/sdk-coin-sol';
 import { HbarToken } from './coins/hbarToken';
 
 function registerCoinConstructors(globalCoinFactory: CoinFactory): void {
-  globalCoinFactory.register('ada', Ada.createInstance);
   globalCoinFactory.register('algo', Algo.createInstance);
   globalCoinFactory.register('avaxc', AvaxC.createInstance);
   globalCoinFactory.register('avaxp', AvaxP.createInstance);
@@ -111,7 +108,6 @@ function registerCoinConstructors(globalCoinFactory: CoinFactory): void {
   globalCoinFactory.register('sol', Sol.createInstance);
   globalCoinFactory.register('stx', Stx.createInstance);
   globalCoinFactory.register('susd', Susd.createInstance);
-  globalCoinFactory.register('tada', Tada.createInstance);
   globalCoinFactory.register('talgo', Talgo.createInstance);
   globalCoinFactory.register('tavaxc', TavaxC.createInstance);
   globalCoinFactory.register('tavaxp', TavaxP.createInstance);

modules/bitgo/src/v2/coins/index.ts

@@ -2,8 +2,6 @@ import { AbstractUtxoCoin } from '@bitgo/abstract-utxo';
 export { AbstractUtxoCoin };
 import { Algo, AlgoToken, Talgo } from '@bitgo/sdk-coin-algo';
 export { Algo, AlgoToken, Talgo };
-import { Ada, Tada } from '@bitgo/sdk-coin-ada';
-export { Ada, Tada };
 import { AvaxC, TavaxC, AvaxCToken } from '@bitgo/sdk-coin-avaxc';
 export { AvaxC, TavaxC, AvaxCToken };
 import { AvaxP, TavaxP } from '@bitgo/sdk-coin-avaxp';

modules/sdk-coin-ada/package.json

@@ -43,6 +43,8 @@
   "dependencies": {
     "@bitgo/sdk-core": "^1.0.1",
     "@bitgo/statics": "^6.17.0",
+    "@emurgo/cardano-serialization-lib-browser": "^10.2.0",
+    "@emurgo/cardano-serialization-lib-nodejs": "^10.2.0",
     "bignumber.js": "^9.0.2"
   },
   "devDependencies": {

modules/sdk-coin-ada/src/keyPair.ts

@@ -1,4 +1,11 @@
-import { DefaultKeys, KeyPairOptions, Ed25519KeyPair, AddressFormat } from '@bitgo/sdk-core';
+import { DefaultKeys, KeyPairOptions, Ed25519KeyPair, toHex, AddressFormat } from '@bitgo/sdk-core';
+import {
+  PublicKey,
+  PrivateKey,
+  EnterpriseAddress,
+  NetworkInfo,
+  StakeCredential,
+} from '@emurgo/cardano-serialization-lib-nodejs';
 
 export class KeyPair extends Ed25519KeyPair {
   /**
@@ -11,18 +18,42 @@ export class KeyPair extends Ed25519KeyPair {
     super(source);
   }
 
-  getAddress(format?: AddressFormat): string {
-    throw new Error('Method not implemented.');
+  /**
+   *  @returns { Address }
+   */
+  getAddress(format): string {
+    const bytesFromHex = new Uint8Array(Buffer.from(this.keyPair.pub, 'hex'));
+    const pubKey = PublicKey.from_bytes(bytesFromHex);
+    let enterpriseAddress;
+    if (format === AddressFormat.testnet) {
+      enterpriseAddress = EnterpriseAddress.new(
+        NetworkInfo.testnet().network_id(),
+        StakeCredential.from_keyhash(pubKey.hash())
+      );
+    } else if (format === AddressFormat.mainnet) {
+      enterpriseAddress = EnterpriseAddress.new(
+        NetworkInfo.mainnet().network_id(),
+        StakeCredential.from_keyhash(pubKey.hash())
+      );
+    }
+    return enterpriseAddress.to_address().to_bech32();
   }
 
   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;
   }
 
   recordKeysFromPrivateKeyInProtocolFormat(prv: string): DefaultKeys {
-    throw new Error('Method not implemented.');
+    const rawPrv = PrivateKey.from_bech32(prv).as_bytes();
+    return new KeyPair({ prv: toHex(rawPrv) }).keyPair;
   }
-  recordKeysFromPublicKeyInProtocolFormat(prv: string): DefaultKeys {
-    throw new Error('Method not implemented.');
+
+  recordKeysFromPublicKeyInProtocolFormat(pub: string): DefaultKeys {
+    const rawPub = PublicKey.from_bech32(pub).as_bytes();
+    return { pub: toHex(rawPub) };
   }
 }

modules/sdk-coin-ada/src/utils.ts

@@ -1,35 +1,68 @@
-import { BaseUtils, NotImplementedError } from '@bitgo/sdk-core';
+import { BaseUtils } from '@bitgo/sdk-core';
+import { Ed25519Signature, Address } from '@emurgo/cardano-serialization-lib-nodejs';
+import { KeyPair } from './keyPair';
 
 export class Utils implements BaseUtils {
-  /** @inheritdoc */
+  validateBlake2b(hash: string): boolean {
+    if (hash.length !== 64) {
+      return false;
+    }
+    return hash.match(/^[a-zA-Z0-9]+$/) !== null;
+  }
 
+  /** @inheritdoc */
   isValidAddress(address: string): boolean {
-    throw new NotImplementedError('method not implemented');
+    try {
+      Address.from_bech32(address);
+      return true;
+    } catch (err) {
+      return false;
+    }
   }
 
   /** @inheritdoc */
   isValidBlockId(hash: string): boolean {
-    throw new NotImplementedError('method not implemented');
+    return this.validateBlake2b(hash);
   }
 
   /** @inheritdoc */
   isValidPrivateKey(key: string): boolean {
-    throw new NotImplementedError('method not implemented');
+    // this will return true for both extended and non-extended ED25519 keys
+    return this.isValidKey(key);
+  }
+
+  isValidKey(key: string): boolean {
+    try {
+      new KeyPair({ prv: key });
+      return true;
+    } catch {
+      return false;
+    }
   }
 
   /** @inheritdoc */
-  isValidPublicKey(key: string): boolean {
-    throw new NotImplementedError('method not implemented');
+  isValidPublicKey(pubKey: string): boolean {
+    try {
+      new KeyPair({ pub: pubKey });
+      return true;
+    } catch {
+      return false;
+    }
   }
 
   /** @inheritdoc */
   isValidSignature(signature: string): boolean {
-    throw new NotImplementedError('method not implemented');
+    try {
+      Ed25519Signature.from_hex(signature);
+      return true;
+    } catch (err) {
+      return false;
+    }
   }
 
   /** @inheritdoc */
   isValidTransactionId(txId: string): boolean {
-    throw new NotImplementedError('method not implemented');
+    return this.validateBlake2b(txId);
   }
 }
 

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

@@ -0,0 +1,79 @@
+export const address = {
+  address1: 'stake1vpu5vlrf4xkxv2qpwngf6cjhtw542ayty80v8dyr49rf5egfu2p0u',
+  address2:
+    'addr_test1qzpu9dmeztx7sfrl4qqtw3rvcewt822wn8mnatv8uc5yzdmvvz7nw9gmznn65g4ksrrfvyzhz52knc3mqxdyya47gz2q83wks3',
+  address3:
+    '37btjrVyb4KDXBNC4haBVPCrro8AQPHwvCMp3RFhhSVWwfFmZ6wwzSK6JK1hY6wHNmtrpTf1kdbva8TCneM2YsiXT7mrzT21EacHnPpz5YyUdj64na',
+  address4: 'addr_test1vr8rakm66rcfv4fcxqykg5lf0yv7lsyk9mvapx369jpvtcgfcuk7f',
+};
+
+export const blockHash = {
+  hash1: '24bf2cf83bc3b1819a4395ef4d9d3b60d687bfa53a9bf4c6c55acbf11e85ea03',
+  hash2: '59548738f2096318ab745e8252b62ac24fd9ab38379777513977a2315af21580',
+};
+
+export const signatures = {
+  signature1:
+    'ed25519_sig14swpdlus75gyq6nsgagyq2dwwawzm463mddq2epmw98s4evq6cqc87sgzlfe2ks979kfuktwvqyveh38gl5f6mvxsl98tfpgksd6xzsrucym0',
+  signature2:
+    'ed25519_sig1cqhp5j32e8tt8w7jqgpdcppuhqlwntuwk8duyj4lvjj4t687ws2t5ckzhfegfez6zls3kd4we3f48kwvwx03v8uktjuceuyg98crvqcy7jd5x',
+};
+
+export const txIds = {
+  hash1: 'e2d6ef426b378626599c5723f685a8ecf28940a1d54aa4afd63d7a31fb8c7d31',
+  hash2: '5f325bb8c4225db5faa8de6297f427f489c9d39572ded0451b89f565a7cbd347',
+  hash3: 'a19e177ba871af621a5c8bb429e756c2aa982ade9d4ae169c66f718284dd16cf',
+};
+
+export const privateKeys = {
+  prvKeyExtended:
+    'ed25519e_sk13rv6afkern90kljwzqauj9p8s0qu4t29yjvm0u7q7exfq7yrp3xqyermevx7jg0xfjkg0sc5mdel0j46y8ym3fr6skygxxz7dm9zxygh5n244',
+  prvKey2: 'ed25519_sk1u79r9v3a4dccx9l9rn8d0wrrd49umyf5x5ft6txfc8lpc96syzaqjccnu6',
+  prvKey3WrongFormat:
+    'ed25519e_sk1qr4lgrte8t43m6ky2cjdcnle583y54ex9j7z85fshenq86g92d8u6a40tgkpl702gqrqdgcdlxa7wzkgm74pqyspck7wclawgeu3yjslnu7nz3sdlszl1ad',
+  prvKey4: '00cebbe7db664726835a451e2cb8c1eba596369318b3e158656f54f76d747b7b',
+  prvKey5WrongFormat: '3560s-vl.1axfsjfjt6sa-q23-dssddddagag',
+};
+
+export const publicKeys = {
+  pubKey1: '9937fd481a9887463a67c39bad141ead730bffe7ed2cea31d7a02759bc197d00',
+  pubKey2: 'ba0fe12d67c2e111aaabc809f8a3ee3168522371ffca360a459e4043dd91eb08',
+  pubKey3: 'ed25519_pk1eame4ge0x5yrwpuqs5eyw89kfmjpgfkfh02xzdx6c2k9k2swcr5sjq4kzj',
+  pubKey4: 'sdfghjkiu87y6t5r4e3w2sdxcfghjui654',
+};
+
+export const enterpriseAccounts = {
+  account1: {
+    secretKey: 'ed25519_sk1amwk5s3l4fh6l86u8v2yxftldlg6mh9efdce5xy4wusl2kftr4aqlcy535',
+    publicKey: 'ed25519_pk1zy8mkv3k0d2d04qqv0xpme54x8y6yywqpjwhgddw5huvlh6m8gusds3l67',
+    hexPublic: '110fbb32367b54d7d40063cc1de69531c9a211c00c9d7435aea5f8cfdf5b3a39',
+    baseAddress: 'addr_test1vztvlmj9ht3phzcfml02zejan534rwpsm23z8rmakt9wkxcc82u67',
+  },
+
+  account2: {
+    secretKey: 'ed25519_sk1t5yluzh50txlj3xq4rvg0sfaksy0qyavne57k6zae2575qz438nstqw5uq',
+    publicKey: 'ed25519_pk138a2jey48a9a7ejrjxsq3td8vg7jz4urtnqmjcnqvcyet8d7jtjsey474x',
+    hexPublic: '89faa964953f4bdf664391a008ada7623d2157835cc1b962606609959dbe92e5',
+    baseAddress: 'addr_test1vpunqlch9k25zzzc76h7k8lra7wqx48qkmq0wtvd055um3sm4rler',
+  },
+
+  account3: {
+    secretKey: 'ed25519_sk1f44nvnxr8d37th07v44eumdtqkhlp29ddhtqv08n3alkhv2al2mqp2ak73',
+    publicKey: 'ed25519_pk1gczdpplaq4ams4t9zt6t508pkygc364ltgkz9gnp4vxjz4m52maqdqpas9',
+    baseAddress: 'addr_test1vq9arfq9pugs57apr3535z470ma2tvg8pnjy54q6s60muzscgmuj4',
+  },
+
+  account4: {
+    publicKeyHex: '9937fd481a9887463a67c39bad141ead730bffe7ed2cea31d7a02759bc197d00',
+    baseAddress: 'addr_test1vpyzy3pkh0qwgyhnzz93v65t92p2gzwpswcysh94ffx30qqxke78c',
+  },
+
+  seedAccount: {
+    seed: '',
+    secretKey:
+      'xprv14zqmq4drmkvs76gxvqhg8dfdzcnf0hqer2ux0n2y8z09ulu5h4wegja87sygl77txhx7avkuefeq53ucq4m7e7wzx8n9wa603kk4hex3tvx0m2y3d2sjasnd7xh8tyy64mdksrv2v9xm8naf48xshtzlscwhqwcz',
+    publicKey:
+      'xpub196u3a0yqdke428lwmmq9k0wfuxw0npq45fr7yy99umykds0dcv3azkcvlk5fz64p9mpxmudwwkgf4tkmdqxc5c2dk086n2wdpwk9lpswvqje8',
+    enterpriseAddress: 'addr_test1vr9exkzjnh6898pjg632qv7tnqs6h073dhjg3qq9jp9tcsg8d6n35',
+  },
+};

modules/sdk-coin-ada/test/resources/index.ts

@@ -0,0 +1,111 @@
+import should from 'should';
+import { KeyPair } from '../../src/keyPair';
+import { enterpriseAccounts } from '../resources/';
+import { PrivateKey, PublicKey } from '@emurgo/cardano-serialization-lib-nodejs';
+import { AddressFormat, toHex } from '@bitgo/sdk-core';
+
+describe('Ada Keypair', () => {
+  const defaultSeed = { seed: Buffer.alloc(32) };
+
+  describe('Keypair creation', () => {
+    it('initial state', () => {
+      const keyPair = new KeyPair();
+      should.exists(keyPair.getKeys().prv);
+      should.exists(keyPair.getKeys().prv);
+    });
+
+    it('initialization from private key', () => {
+      let keyPair = new KeyPair({
+        prv: enterpriseAccounts.account1.secretKey,
+      });
+
+      should.equal(
+        keyPair.getKeys().prv,
+        toHex(PrivateKey.from_bech32(enterpriseAccounts.account1.secretKey).as_bytes())
+      );
+
+      should.equal(keyPair.getKeys().pub, enterpriseAccounts.account1.hexPublic);
+
+      keyPair = new KeyPair({
+        prv: enterpriseAccounts.account2.secretKey,
+      });
+
+      should.equal(
+        keyPair.getKeys().prv,
+        toHex(PrivateKey.from_bech32(enterpriseAccounts.account2.secretKey).as_bytes())
+      );
+      should.equal(keyPair.getKeys().pub, enterpriseAccounts.account2.hexPublic);
+    });
+
+    it('initialization from public key', () => {
+      let keyPair = new KeyPair({ pub: enterpriseAccounts.account1.publicKey });
+
+      should.equal(
+        keyPair.getKeys().pub,
+        toHex(PublicKey.from_bech32(enterpriseAccounts.account1.publicKey).as_bytes())
+      );
+
+      keyPair = new KeyPair({ pub: enterpriseAccounts.account2.publicKey });
+      should.equal(keyPair.getAddress(AddressFormat.testnet), enterpriseAccounts.account2.baseAddress);
+
+      keyPair = new KeyPair({ pub: enterpriseAccounts.account4.publicKeyHex });
+      should.equal(keyPair.getKeys().pub, enterpriseAccounts.account4.publicKeyHex);
+    });
+  });
+
+  describe('KeyPair validation', () => {
+    it('should fail to create from an invalid seed', () => {
+      const seed = { seed: Buffer.alloc(8) }; //  Seed should be 512 bits (64 bytes)
+      should.throws(() => new KeyPair(seed), 'bad seed size');
+    });
+
+    it('should fail to create from an invalid public key', () => {
+      const source = {
+        pub: '01D63D',
+      };
+      should.throws(() => new KeyPair(source), 'address seems to be malformed');
+    });
+
+    it('should fail to create from an invalid private key', () => {
+      const source = {
+        prv: '82A34',
+      };
+      should.throws(() => new KeyPair(source), 'Invalid base32 characters');
+    });
+  });
+
+  describe('getAddress', () => {
+    it('should get an address', () => {
+      let keyPair = new KeyPair({ prv: enterpriseAccounts.account1.secretKey });
+      let address = keyPair.getAddress(AddressFormat.testnet);
+      address.should.equal(enterpriseAccounts.account1.baseAddress);
+
+      keyPair = new KeyPair({ prv: enterpriseAccounts.account3.secretKey });
+      address = keyPair.getAddress(AddressFormat.testnet);
+      address.should.equal(enterpriseAccounts.account3.baseAddress);
+
+      keyPair = new KeyPair({ pub: enterpriseAccounts.account4.publicKeyHex });
+      address = keyPair.getAddress(AddressFormat.testnet);
+      address.should.equal(enterpriseAccounts.account4.baseAddress);
+    });
+  });
+
+  describe('getKeys', () => {
+    it('should get private and public keys in the protocol default format', () => {
+      const keyPair = new KeyPair(defaultSeed);
+      const { prv, pub } = keyPair.getKeys();
+
+      prv!.should.equal(prv);
+      pub.should.equal(pub);
+      const address = keyPair.getAddress(AddressFormat.testnet);
+      address.should.equal(enterpriseAccounts.seedAccount.enterpriseAddress);
+    });
+
+    it('should get private and public keys for a random seed', () => {
+      const keyPair = new KeyPair();
+      const { prv, pub } = keyPair.getKeys();
+      should.exist(prv);
+      should.exist(pub);
+    });
+  });
+});