Create MPC Keys - EdDSA

// 1. Set Up SDK
// Use the JavaScript SDK for this step (see JavaScript tab)

// 2. Create User Key Shares
// Use the JavaScript SDK for this step (see JavaScript tab)

// 3. Create Backup Key Shares
// Use the JavaScript SDK for this step (see JavaScript tab)

// 4. Create BitGo Keychain
export COIN="<ASSET_ID>"
export ACCESS_TOKEN="<YOUR_ACCESS_TOKEN>"
export ENTERPRISE_ID="<ENTERPRISE_ID>"

curl -X POST \
  https://app.bitgo-test.com/api/v2/$COIN/key \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -d '{
    "keyType":"tss",
    "source": "bitgo",
    "enterprise": "'"$ENTERPRISE_ID"'",
    "keyShares": [
      {
        "from": "user",
        "to": "bitgo",
        "publicShare": "<USER_PUBLIC_SHARE>",
        "privateShare": "<PGP_ENCRYPTED_PRIVATE_SHARE>",
        "privateShareProof": "<PGP_PUBLIC_KEY_BLOCK>"
      },
      {
        "from": "backup",
        "to": "bitgo",
        "publicShare": "<BACKUP_PUBLIC_SHARE>",
        "privateShare": "<PGP_ENCRYPTED_PRIVATE_SHARE>",
        "privateShareProof": "<PGP_PUBLIC_KEY_BLOCK>"
      }
    ],
    "userGPGPublicKey": "<USER_PGP_PUBLIC_KEY>",
    "backupGPGPublicKey": "<BACKUP_PGP_PUBLIC_KEY>"
  }'

// 5. Create User Keychain
curl -X POST \
  https://app.bitgo-test.com/api/v2/$COIN/key \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -d '{
    "commonKeychain": "<COMMON_KEYCHAIN>",
    "encryptedPrv": "<ENCRYPTED_PRV>",
    "keyType":"tss",
    "source": "user",
    "originalPasscodeEncryptionCode": "<CODE>"
  }'

// 6. Create Backup Keychain
curl -X POST \
  https://app.bitgo-test.com/api/v2/$COIN/key \
  -H 'Content-Type: application/json' \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -d '{
    "commonKeychain": "<COMMON_KEYCHAIN>",
    "encryptedPrv": "<ENCRYPTED_PRV>",
    "keyType":"tss",
    "source": "backup"
  }'

// 1. Set Up SDK
const bitgo = new BitGo({
  accessToken: "my access token",
  env: "test",
});

const enterprise = "my enterprise id";
const passphrase = "my very secure wallet passphrase";
const originalPasscodeEncryptionCode = "1234";
const coin = "tsol";
const m = 2;
const n = 3;

openpgp.config.rejectCurves = new Set();

async function main() {
  const uploadKeyUrl = bitgo.microservicesUrl(`/api/v2/${coin}/key`);
  const MPC = await Eddsa.initialize();
  const randomHexString = crypto.randomBytes(12).toString("hex");
  const userGpgKey = await openpgp.generateKey({
    userIDs: [
      {
        name: randomHexString,
        email: `user-${randomHexString}@${randomHexString}.com`,
      },
    ],
    curve: "secp256k1",
  });
  const bitgoPublicKeyStr = (await bitgo.fetchConstants()).mpc
    .bitgoPublicKey as string;
  const bitgoKey = await openpgp.readKey({ armoredKey: bitgoPublicKeyStr });
  console.log("\n\nbitgo public key");
  console.log(bitgoPublicKeyStr);

  // 2. Create User Key Shares
  const userKeyShare = MPC.keyShare(1, m, n);
  console.log("\n\ncreated user key share");
  console.log(JSON.stringify(userKeyShare, undefined, 2));

  // 3. Create Backup Key Shares
  const backupKeyShare = MPC.keyShare(2, m, n);
  console.log("\n\ncreated backup key share");
  console.log(JSON.stringify(backupKeyShare, undefined, 2));

  // 4. Create BitGo Keychain
  const userToBitgoPublicShare = Buffer.concat([
    Buffer.from(userKeyShare.uShare.y, "hex"),
    Buffer.from(userKeyShare.uShare.chaincode, "hex"),
  ]).toString("hex");
  const userToBitgoPrivateShare = Buffer.concat([
    Buffer.from(userKeyShare.yShares[3].u, "hex"),
    Buffer.from(userKeyShare.yShares[3].chaincode, "hex"),
  ]).toString("hex");
  const userToBitgoKeyShare = {
    publicShare: userToBitgoPublicShare,
    privateShare: userToBitgoPrivateShare,
    privateShareProof: await createShareProof(
      userGpgKey.privateKey,
      userToBitgoPrivateShare.slice(0, 64)
    ),
  };
  const backupToBitgoPublicShare = Buffer.concat([
    Buffer.from(backupKeyShare.uShare.y, "hex"),
    Buffer.from(backupKeyShare.uShare.chaincode, "hex"),
  ]).toString("hex");
  const backupToBitgoPrivateShare = Buffer.concat([
    Buffer.from(backupKeyShare.yShares[3].u, "hex"),
    Buffer.from(backupKeyShare.yShares[3].chaincode, "hex"),
  ]).toString("hex");
  const backupToBitgoKeyShare = {
    publicShare: backupToBitgoPublicShare,
    privateShare: backupToBitgoPrivateShare,
    privateShareProof: await createShareProof(
      userGpgKey.privateKey,
      backupToBitgoPrivateShare.slice(0, 64)
    ),
  };
  const encUserToBitGoMessage = await encryptText(
    userToBitgoKeyShare.privateShare,
    bitgoKey
  );
  const encBackupToBitGoMessage = await encryptText(
    userToBitgoKeyShare.privateShare,
    bitgoKey
  );
  const createBitGoMPCParams = {
    keyType: "MPC",
    source: "bitgo",
    keyShares: [
      {
        from: "user",
        to: "bitgo",
        publicShare: userToBitgoKeyShare.publicShare,
        privateShare: encUserToBitGoMessage,
        privateShareProof: userToBitgoKeyShare.privateShareProof,
      },
      {
        from: "backup",
        to: "bitgo",
        publicShare: backupToBitgoKeyShare.publicShare,
        privateShare: encBackupToBitGoMessage,
        privateShareProof: backupToBitgoKeyShare.privateShareProof,
      },
    ],
    userGPGPublicKey: userGpgKey.publicKey,
    backupGPGPublicKey: userGpgKey.publicKey,
    enterprise: enterprise,
  };
  const bitgoKeychain = (await bitgo
    .post(uploadKeyUrl)
    .send(createBitGoMPCParams)
    .result()) as any as Keychain;
  console.log("\n\ncreated bitgo keychain");
  console.log(JSON.stringify(bitgoKeychain, undefined, 2));

  // 5. Create User Keychain
  const bitgoKeyShares = bitgoKeychain.keyShares;
  const bitGoToUserShare = bitgoKeyShares!.find(
    (keyShare) => keyShare.from === "bitgo" && keyShare.to === "user"
  );
  const bitGoToUserPrivateShare = await decryptPrivateShare(
    bitGoToUserShare!.privateShare,
    userGpgKey
  );
  const bitgoToUser = {
    i: 1,
    j: 3,
    y: bitGoToUserShare!.publicShare.slice(0, 64),
    u: bitGoToUserPrivateShare.slice(0, 64).toString(),
    chaincode: bitGoToUserPrivateShare.slice(64).toString(),
  };
  const userCombined = MPC.keyCombine(userKeyShare.uShare, [
    backupKeyShare.yShares[1],
    bitgoToUser,
  ]);
  const commonKeychain =
    userCombined.pShare.y + userCombined.pShare.chaincode;
  if (commonKeychain !== bitgoKeychain.commonKeychain) {
    throw new Error(
      "Failed to create user keychain - commonKeychains do not match."
    );
  }
  const userSigningMaterial = {
    uShare: userKeyShare.uShare,
    bitgoYShare: bitgoToUser,
    backupYShare: backupKeyShare.yShares[1],
  };
  const userKeychainParams: AddKeychainOptions = {
    source: "user",
    keyType: "MPC",
    commonKeychain: bitgoKeychain.commonKeychain,
    encryptedPrv: bitgo.encrypt({
      input: JSON.stringify(userSigningMaterial),
      password: passphrase,
    }),
    originalPasscodeEncryptionCode,
  };
  const userKeychain = (await bitgo
    .post(uploadKeyUrl)
    .send(userKeychainParams)
    .result()) as any as Keychain;
  console.log("\n\ncreated user keychain");
  console.log(JSON.stringify(userKeychain, undefined, 2));

  // 6. Create Backup Keychain
  const bitGoToBackupShare = bitgoKeyShares!.find(
    (keyShare) => keyShare.from === "bitgo" && keyShare.to === "backup"
  );
  const bitGoToBackupPrivateShare = await decryptPrivateShare(
    bitGoToBackupShare!.privateShare,
    userGpgKey
  );
  const bitgoToBackup = {
    i: 2,
    j: 3,
    y: bitGoToBackupShare!.publicShare.slice(0, 64),
    u: bitGoToBackupPrivateShare.slice(0, 64).toString(),
    chaincode: bitGoToBackupPrivateShare.slice(64).toString(),
  };
  const backupCombined = MPC.keyCombine(backupKeyShare.uShare, [
    userKeyShare.yShares[2],
    bitgoToBackup,
  ]);
  const backupCommonKeychain =
    backupCombined.pShare.y + backupCombined.pShare.chaincode;
  if (backupCommonKeychain !== bitgoKeychain.commonKeychain) {
    throw new Error(
      "Failed to create backup keychain - commonKeychains do not match."
    );
  }
  const backupSigningMaterial = {
    uShare: backupKeyShare.uShare,
    bitgoYShare: bitgoToBackup,
    userYShare: userKeyShare.yShares[2],
  };
  console.log(
    "\n\ncreated backup keychain (not uploaded to bitgo, must be stored locally)"
  );
  console.log(JSON.stringify(backupSigningMaterial, undefined, 2));
  const backupKeychainParams: AddKeychainOptions = {
    source: "backup",
    keyType: "MPC",
    commonKeychain: backupCommonKeychain,
  };
  const backupKeychain = (await bitgo
    .post(uploadKeyUrl)
    .send(backupKeychainParams)
    .result()) as any as Keychain;
  console.log("\n\ncreated backup keychain");
  console.log(JSON.stringify(backupKeychain, undefined, 2));
}

main().catch((err) => console.error(err));