@bitgo-beta/key-card 0.0.1-beta.9 → 0.1.2-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitgo-beta/key-card",
-  "version": "0.0.1-beta.9",
+  "version": "0.1.2-alpha.0",
   "description": "key card generator for BitGo wallets",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
@@ -32,10 +32,5 @@
       ".ts"
     ]
   },
-  "dependencies": {
-    "@bitgo-beta/sdk-api": "1.1.1-beta.134",
-    "@bitgo-beta/sdk-core": "1.1.1-beta.134",
-    "@bitgo-beta/statics": "7.0.1-beta.134"
-  },
-  "gitHead": "2a8f20b3ca0aa4498def41930539fce61847f764"
+  "gitHead": "54b088879459721d54764501dcd2376c59b8450f"
 }

package/tsconfig.json

@@ -5,16 +5,5 @@
     "rootDir": "./"
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules"],
-  "references": [
-    {
-      "path": "../statics"
-    },
-    {
-      "path": "../sdk-api"
-    },
-    {
-      "path": "../sdk-core"
-    }
-  ]
+  "exclude": ["node_modules"]
 }

package/src/generateQrData.ts

@@ -1,197 +0,0 @@
-import { BaseCoin } from '@bitgo-beta/statics';
-import { Keychain } from '@bitgo-beta/sdk-core';
-import { encrypt } from '@bitgo-beta/sdk-api';
-import * as assert from 'assert';
-
-export interface GenerateQrDataParams {
-  // The backup keychain as it is returned from the BitGo API upon creation
-  backupKeychain: Keychain,
-  // The 3rd party provider of the backup key if neither the user nor BitGo stores it
-  backupKeyProvider?: string;
-  // The key id of the backup key, only used for cold keys
-  backupMasterKey?: string;
-  // The BitGo keychain as it is returned from the BitGo API upon creation
-  bitgoKeychain: Keychain,
-  // The coin of the wallet that was/ is about to be created
-  coin: Readonly<BaseCoin>;
-  // A code that can be used to encrypt the wallet password to.
-  // If both the passphrase and passcodeEncryptionCode are passed, then this code encrypts the passphrase with the
-  // passcodeEncryptionCode and puts the result into Box D. Allows recoveries of the wallet password.
-  passcodeEncryptionCode?: string;
-  // The wallet password
-  // If both the passphrase and passcodeEncryptionCode are passed, then this code encrypts the passphrase with the
-  // passcodeEncryptionCode and puts the result into Box D. Allows recoveries of the wallet password.
-  passphrase?: string;
-  // The user keychain as it is returned from the BitGo API upon creation
-  userKeychain: Keychain;
-  // The key id of the user key, only used for cold keys
-  userMasterKey?: string;
-}
-
-interface QrDataEntry {
-  data: string;
-  description: string;
-  image: string;
-  title: string;
-  publicMasterKey?: string;
-}
-
-export interface QrData {
-  backup?: QrDataEntry;
-  bitgo?: QrDataEntry;
-  passcode?: QrDataEntry;
-  user: QrDataEntry;
-}
-
-function getPubFromKey(key: Keychain): string | undefined {
-  switch (key.type) {
-    case 'blsdkg':
-      return key.commonPub;
-    case 'tss':
-      return key.commonKeychain;
-    case 'independent':
-      return key.pub;
-  }
-}
-
-function generateUserQrData(userKeychain: Keychain, userMasterKey?: string): QrDataEntry {
-  if (userKeychain.encryptedPrv) {
-    return {
-      title: 'A: User Key',
-      image: '.qrEncryptedUserKey',
-      description: 'This is your private key, encrypted with your wallet password.',
-      data: userKeychain.encryptedPrv,
-    };
-  }
-
-  const pub = getPubFromKey(userKeychain);
-  assert(pub);
-
-  return {
-    title: 'A: Provided User Key',
-    image: '.qrPublicUserKey',
-    description: 'This is the public key you provided for your wallet.',
-    data: pub,
-    publicMasterKey: userMasterKey,
-  };
-}
-
-function generateBackupQrData(coin: Readonly<BaseCoin>, backupKeychain: Keychain, {
-  backupKeyProvider,
-  backupMasterKey,
-}: {
-  backupKeyProvider?: string;
-  backupMasterKey?: string;
-} = {}): QrDataEntry {
-  const title = 'B: Backup Key';
-  if (backupKeychain.encryptedPrv) {
-    return {
-      title,
-      image: '.qrEncryptedBackupKey',
-      description: 'This is your backup private key, encrypted with your wallet password.',
-      data: backupKeychain.encryptedPrv,
-    };
-  }
-
-  if (backupKeyProvider === 'BitGo Trust' && backupKeychain.type === 'tss') {
-    const userToBackupShare = backupKeychain.keyShares?.find((keyShare) => keyShare.from === 'user' && keyShare.to === 'backup');
-    assert(userToBackupShare);
-    return {
-      title: 'B: User To Backup Key Share',
-      image: '.qrUserToBackupKeyShare',
-      description: `This is the key share from you for ${backupKeyProvider}. If BitGo Inc goes out of business,` +
-        `\r\ncontact ${backupKeyProvider} and they will help you recover your funds.`,
-      data: JSON.stringify(userToBackupShare),
-    };
-  }
-
-  const pub = getPubFromKey(backupKeychain);
-  assert(pub);
-
-  if (backupKeyProvider) {
-    return {
-      title: 'B: Backup Key',
-      image: '.qrPublicBackupKey',
-      description: `This is the public key held at ${backupKeyProvider}, an ${coin.name} recovery service. ` +
-        `If you lose\r\nyour key, ${backupKeyProvider} will be able to sign transactions to recover funds.`,
-      data: pub,
-    };
-  }
-
-  return {
-    title: 'B: Provided Backup Key',
-    image: '.qrEncryptedUserProvidedXpub',
-    description: 'This is the public key you provided for your wallet.',
-    data: pub,
-    publicMasterKey: backupMasterKey,
-  };
-}
-
-function generateBitGoQrData(bitgoKeychain: Keychain, {
-  backupKeychain,
-  backupKeyProvider,
-}: {
-  backupKeychain?: Keychain,
-  backupKeyProvider?: string;
-}): QrDataEntry {
-  if (backupKeyProvider === 'BitGo Trust' && backupKeychain?.type === 'tss') {
-    const bitgoToBackupShare = backupKeychain.keyShares?.find((keyShare) => keyShare.from === 'bitgo' && keyShare.to === 'backup');
-    assert(bitgoToBackupShare);
-    return {
-      title: 'C: BitGo To Backup Key Share',
-      image: '.qrBitGoToBackupKeyShare',
-      description: `This is the key share from BitGo Inc for ${backupKeyProvider}. If BitGo Inc goes out of business,` +
-        `\r\ncontact ${backupKeyProvider} and they will help you recover your funds.`,
-      data: JSON.stringify(bitgoToBackupShare),
-    };
-  }
-
-  const bitgoData = getPubFromKey(bitgoKeychain);
-  assert(bitgoData);
-
-  return {
-    title: 'C: BitGo Public Key',
-    image: '.qrBitgoKey',
-    description:
-      'This is the public part of the key that BitGo will use to ' +
-      'co-sign transactions\r\nwith you on your wallet.',
-    data: bitgoData,
-  };
-}
-
-export function generateQrData({
-  backupKeychain,
-  backupKeyProvider,
-  backupMasterKey,
-  bitgoKeychain,
-  coin,
-  passcodeEncryptionCode,
-  passphrase,
-  userKeychain,
-  userMasterKey,
-}: GenerateQrDataParams): QrData {
-  const qrData: QrData = {
-    user: generateUserQrData(userKeychain, userMasterKey),
-    backup: generateBackupQrData(coin, backupKeychain, {
-      backupKeyProvider,
-      backupMasterKey,
-    }),
-    bitgo: generateBitGoQrData(bitgoKeychain, {
-      backupKeychain,
-      backupKeyProvider,
-    }),
-  };
-
-  if (passphrase && passcodeEncryptionCode) {
-    const encryptedWalletPasscode = encrypt(passcodeEncryptionCode, passphrase);
-
-    qrData.passcode = {
-      title: 'D: Encrypted wallet Password',
-      image: '.qrEncryptedWalletPasscode',
-      description: 'This is the wallet password, encrypted client-side with a key held by\r\nBitGo.',
-      data: encryptedWalletPasscode,
-    };
-  }
-
-  return qrData;
-}

package/test/unit/generateQrData.ts

@@ -1,220 +0,0 @@
-import * as assert from 'assert';
-import * as should from 'should';
-import { generateQrData } from '../../src/generateQrData';
-import { decrypt } from '@bitgo-beta/sdk-api';
-import { ApiKeyShare, Keychain, KeyType } from '@bitgo-beta/sdk-core';
-import { coins } from '@bitgo-beta/statics';
-
-function createKeychain({
-  commonKeychain,
-  commonPub,
-  encryptedPrv,
-  keyShares,
-  provider,
-  pub,
-  type,
-}: {
-  commonKeychain?: string;
-  commonPub?: string;
-  encryptedPrv?: string;
-  keyShares?: ApiKeyShare[];
-  provider?: string;
-  pub?: string;
-  type?: KeyType;
-}): Keychain {
-  return {
-    commonKeychain,
-    commonPub,
-    encryptedPrv,
-    id: 'id',
-    keyShares,
-    provider,
-    pub: pub ?? 'pub',
-    type: type ?? 'independent',
-  };
-}
-
-describe('generateQrData', function () {
-  it('hot wallet, backup key provided by user with encryptedPrv', function () {
-    const userEncryptedPrv = 'prv123encrypted';
-    const backupEncryptedPrv = 'prv456encrypted';
-    const bitgoPub = 'pub789bitgo';
-    const passphrase = 'testingIsFun';
-    const passcodeEncryptionCode = '123456';
-    const qrData = generateQrData({
-      backupKeychain: createKeychain({
-        encryptedPrv: backupEncryptedPrv,
-      }),
-      bitgoKeychain: createKeychain({
-        pub: bitgoPub,
-      }),
-      coin: coins.get('btc'),
-      passcodeEncryptionCode,
-      passphrase,
-      userKeychain: createKeychain({
-        encryptedPrv: userEncryptedPrv,
-      }),
-    });
-
-    qrData.user.title.should.equal('A: User Key');
-    qrData.user.image.should.equal('.qrEncryptedUserKey');
-    qrData.user.description.should.equal('This is your private key, encrypted with your wallet password.');
-    qrData.user.data.should.equal(userEncryptedPrv);
-
-    assert(qrData.backup);
-    qrData.backup.title.should.equal('B: Backup Key');
-    qrData.backup.image.should.equal('.qrEncryptedBackupKey');
-    qrData.backup.description.should.equal('This is your backup private key, encrypted with your wallet password.');
-    qrData.backup.data.should.equal(backupEncryptedPrv);
-
-    assert(qrData.bitgo);
-    qrData.bitgo.title.should.equal('C: BitGo Public Key');
-    qrData.bitgo.image.should.equal('.qrBitgoKey');
-    qrData.bitgo.description.should.equal('This is the public part of the key that BitGo will use to ' +
-      'co-sign transactions\r\nwith you on your wallet.');
-    qrData.bitgo.data.should.equal(bitgoPub);
-
-    assert(qrData.passcode);
-    qrData.passcode.title.should.equal('D: Encrypted wallet Password');
-    qrData.passcode.image.should.equal('.qrEncryptedWalletPasscode');
-    qrData.passcode.description.should.equal('This is the wallet password, encrypted client-side with a key held by\r\nBitGo.');
-    const decryptedData = decrypt(passcodeEncryptionCode, qrData.passcode.data);
-    decryptedData.should.equal(passphrase);
-  });
-
-  describe('cold wallet', function () {
-    const testSets: { coinName: string; keyType: KeyType }[] = [
-      { coinName: 'btc', keyType: 'independent' },
-      { coinName: 'sol', keyType: 'tss' },
-      { coinName: 'eth', keyType: 'blsdkg' },
-    ];
-    for (const testSet of testSets) {
-      it(`key type ${testSet.keyType}`, function () {
-        const userPub = 'pub012user';
-        const userMasterKey = 'userMasterKey';
-        const backupPub = 'pub345backup';
-        const backupMasterKey = 'backupMasterKey';
-        const bitgoPub = 'pub789bitgo';
-        const qrData = generateQrData({
-          backupKeychain: createKeychain({
-            commonKeychain: testSet.keyType === 'tss' ? backupPub : undefined,
-            commonPub: testSet.keyType === 'blsdkg' ? backupPub : undefined,
-            pub: testSet.keyType === 'independent' ? backupPub : undefined,
-            type: testSet.keyType,
-          }),
-          backupMasterKey,
-          bitgoKeychain: createKeychain({
-            commonKeychain: testSet.keyType === 'tss' ? bitgoPub : undefined,
-            commonPub: testSet.keyType === 'blsdkg' ? bitgoPub : undefined,
-            pub: testSet.keyType === 'independent' ? bitgoPub : undefined,
-            type: testSet.keyType,
-          }),
-          coin: coins.get('btc'),
-          userKeychain: createKeychain({
-            commonKeychain: testSet.keyType === 'tss' ? userPub : undefined,
-            commonPub: testSet.keyType === 'blsdkg' ? userPub : undefined,
-            pub: testSet.keyType === 'independent' ? userPub : undefined,
-            type: testSet.keyType,
-          }),
-          userMasterKey,
-        });
-
-        qrData.user.title.should.equal('A: Provided User Key');
-        qrData.user.image.should.equal('.qrPublicUserKey');
-        qrData.user.description.should.equal('This is the public key you provided for your wallet.');
-        qrData.user.data.should.equal(userPub);
-        should.equal(qrData.user.publicMasterKey, userMasterKey);
-
-        assert(qrData.backup);
-        qrData.backup.title.should.equal('B: Provided Backup Key');
-        qrData.backup.image.should.equal('.qrEncryptedUserProvidedXpub');
-        qrData.backup.description.should.equal('This is the public key you provided for your wallet.');
-        qrData.backup.data.should.equal(backupPub);
-        should.equal(qrData.backup?.publicMasterKey, backupMasterKey);
-
-        assert(qrData.bitgo);
-        qrData.bitgo.data.should.equal(bitgoPub);
-
-        should.not.exist(qrData.passcode);
-      });
-    }
-  });
-
-  it('backup key from provider', function () {
-    const coin = coins.get('btc');
-    const userEncryptedPrv = 'prv123encrypted';
-    const backupPub = 'pub673backup';
-    const provider = '3rd Party Provider';
-    const bitgoPub = 'pub789bitgo';
-    const qrData = generateQrData({
-      backupKeychain: createKeychain({
-        pub: backupPub,
-        provider,
-      }),
-      backupKeyProvider: provider,
-      bitgoKeychain: createKeychain({
-        pub: bitgoPub,
-      }),
-      coin,
-      userKeychain: createKeychain({
-        encryptedPrv: userEncryptedPrv,
-      }),
-    });
-
-    qrData.user.data.should.equal(userEncryptedPrv);
-
-    assert(qrData.backup);
-    qrData.backup.title.should.equal('B: Backup Key');
-    qrData.backup.image.should.equal('.qrPublicBackupKey');
-    qrData.backup.description.should.equal('This is the public key held at ' +
-      provider +
-      ', an ' +
-      coin.name +
-      ' recovery service. If you lose\r\nyour key, ' +
-      provider +
-      ' will be able to sign transactions to recover funds.');
-    qrData.backup.data.should.equal(backupPub);
-
-    assert(qrData.bitgo);
-    qrData.bitgo.data.should.equal(bitgoPub);
-  });
-
-  it('tss backup key held at BitGo Trust', function () {
-    const coin = coins.get('btc');
-    const userEncryptedPrv = 'prv123encrypted';
-    const provider = 'BitGoTrustAsKRS';
-    const backupKeyProvider = 'BitGo Trust';
-    const userToBackupKeyShare: ApiKeyShare = { from: 'user', to: 'backup', publicShare: 'userToBackupPublic', privateShare: 'userToBackupPrivate' };
-    const bitgoToBackupKeyShare: ApiKeyShare = { from: 'bitgo', to: 'backup', publicShare: 'bitgoToBackupPublic', privateShare: 'bitgoToBackupPrivate' };
-    const qrData = generateQrData({
-      backupKeychain: createKeychain({
-        provider,
-        keyShares: [userToBackupKeyShare, bitgoToBackupKeyShare],
-        type: 'tss',
-      }),
-      backupKeyProvider,
-      bitgoKeychain: createKeychain({
-        type: 'tss',
-      }),
-      coin,
-      userKeychain: createKeychain({
-        encryptedPrv: userEncryptedPrv,
-        type: 'tss',
-      }),
-    });
-
-    qrData.user.data.should.equal(userEncryptedPrv);
-
-    assert(qrData.backup);
-    qrData.backup.title.should.equal('B: User To Backup Key Share');
-    qrData.backup.image.should.equal('.qrUserToBackupKeyShare');
-    qrData.backup.description.should.equal(`This is the key share from you for ${backupKeyProvider}. If BitGo Inc goes out of business,\r\ncontact ${backupKeyProvider} and they will help you recover your funds.`);
-    qrData.backup.data.should.equal(JSON.stringify(userToBackupKeyShare));
-
-    assert(qrData.bitgo);
-    qrData.bitgo.title.should.equal('C: BitGo To Backup Key Share');
-    qrData.bitgo.image.should.equal('.qrBitGoToBackupKeyShare');
-    qrData.bitgo.description.should.equal(`This is the key share from BitGo Inc for ${backupKeyProvider}. If BitGo Inc goes out of business,\r\ncontact ${backupKeyProvider} and they will help you recover your funds.`);
-    qrData.bitgo.data.should.equal(JSON.stringify(bitgoToBackupKeyShare));
-  });
-});