feat(sdk-core): added OFC BitGo signing on wallet and coins object

allow wallet and coins object to sign using the BitGo key
if the passphrase is not provided during signing

Ticket: WCN-217-2

Author: alextse-bg

modules/sdk-core/src/coins/ofc.ts

@@ -15,6 +15,7 @@ import {
   SignTransactionOptions,
   VerifyAddressOptions,
   VerifyTransactionOptions,
+  Wallet,
 } from '../';
 
 export class Ofc extends BaseCoin {
@@ -104,6 +105,26 @@ export class Ofc extends BaseCoin {
     throw new MethodNotImplementedError();
   }
 
+  /**
+   * Signs a message using a trading wallet's BitGo Key
+   * @param wallet - uses the BitGo key of this trading wallet to sign the message remotely in a KMS
+   * @param message
+   */
+  async signMessage(wallet: Wallet, message: string): Promise<Buffer>;
+  /**
+   * Signs a message using the private key
+   * @param key - uses the private key to sign the message
+   * @param message
+   */
+  async signMessage(key: { prv: string }, message: string): Promise<Buffer>;
+  async signMessage(keyOrWallet: { prv: string } | Wallet, message: string): Promise<Buffer> {
+    if (!(keyOrWallet instanceof Wallet)) {
+      return super.signMessage(keyOrWallet, message);
+    }
+    const signatureHexString = await keyOrWallet.toTradingAccount().signPayload({ payload: message });
+    return Buffer.from(signatureHexString, 'hex');
+  }
+
   /** @inheritDoc */
   auditDecryptedKey(params: AuditDecryptedKeyParams) {
     throw new MethodNotImplementedError();

modules/sdk-core/src/coins/ofcToken.ts

@@ -9,6 +9,7 @@ import {
   SignTransactionOptions as BaseSignTransactionOptions,
   SignedTransaction,
   ITransactionRecipient,
+  Wallet,
 } from '../';
 import { isBolt11Invoice } from '../lightning';
 
@@ -18,7 +19,8 @@ export interface SignTransactionOptions extends BaseSignTransactionOptions {
   txPrebuild: {
     payload: string;
   };
-  prv: string;
+  prv?: string;
+  wallet?: Wallet;
 }
 
 export { OfcTokenConfig };
@@ -107,15 +109,25 @@ export class OfcToken extends Ofc {
   }
 
   /**
-   * Assemble keychain and half-sign prebuilt transaction
+   * Signs a half-signed OFC transaction.
+   * Signs the transaction remotely using the BitGo key if prv is not provided.
    * @param params
    * @returns {Promise<SignedTransaction>}
    */
   async signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {
     const txPrebuild = params.txPrebuild;
     const payload = txPrebuild.payload;
-    const signatureBuffer = (await this.signMessage(params, payload)) as any;
-    const signature: string = signatureBuffer.toString('hex');
+
+    let signature: string;
+    if (params.wallet) {
+      signature = await params.wallet.toTradingAccount().signPayload({ payload, walletPassphrase: params.prv });
+    } else if (params.prv) {
+      const signatureBuffer = (await this.signMessage({ prv: params.prv }, payload)) as any;
+      signature = signatureBuffer.toString('hex');
+    } else {
+      throw new Error('You must pass in either one of wallet or prv');
+    }
+
     return { halfSigned: { payload, signature } } as any;
   }
 

modules/sdk-core/test/unit/coins/ofc.ts

@@ -0,0 +1,153 @@
+/**
+ * @prettier
+ */
+import sinon from 'sinon';
+import 'should';
+import { Ofc, OfcToken } from '../../../src/coins';
+import { BaseCoin, Wallet } from '../../../src';
+
+const TEST_TOKEN_CONFIG = {
+  coin: 'ofcusdt',
+  decimalPlaces: 6,
+  name: 'OFCUSDT',
+  type: 'ofcusdt',
+  backingCoin: 'usdt',
+  isFiat: false,
+};
+
+describe('Ofc / OfcToken', function () {
+  let mockBitGo: any;
+  let coinUrlStub: sinon.SinonStub;
+  const hexSignature = 'deadbeef';
+  const signUrl = 'https://test.bitgo.com/api/v2/ofc/wallet/wallet-id/tx/sign';
+  const walletData = {
+    id: 'wallet-id',
+    keys: ['userKey', 'bitgoKey'],
+    type: 'trading',
+    multisigType: 'onchain',
+    enterprise: 'ent-id',
+  };
+
+  beforeEach(function () {
+    coinUrlStub = sinon.stub().returns(signUrl);
+    mockBitGo = {
+      url: sinon.stub().returns('https://test.bitgo.com/'),
+      post: sinon.stub().returnsThis(),
+      send: sinon.stub().returnsThis(),
+      result: sinon.stub().resolves({ signature: hexSignature }),
+      coin: sinon.stub().returns({ url: coinUrlStub }),
+    };
+  });
+
+  afterEach(function () {
+    sinon.restore();
+  });
+
+  describe('signMessage', function () {
+    let ofc: Ofc;
+
+    beforeEach(function () {
+      ofc = new Ofc(mockBitGo);
+    });
+
+    describe('with a Wallet instance', function () {
+      it('should delegate to wallet.toTradingAccount().signPayload() and return a Buffer', async function () {
+        const wallet = new Wallet(mockBitGo, ofc, walletData);
+
+        const message = 'test message';
+        const result = await ofc.signMessage(wallet, message);
+
+        mockBitGo.send.calledOnceWith({ payload: message }).should.be.true();
+        mockBitGo.result.calledOnce.should.be.true();
+        result.should.deepEqual(Buffer.from(hexSignature, 'hex'));
+      });
+    });
+
+    describe('with a prv key', function () {
+      it('should delegate to the base class signMessage with the exact key and message', async function () {
+        const expectedResult = Buffer.from('basesignature', 'hex');
+        const superSignMessageStub = sinon.stub(BaseCoin.prototype, 'signMessage').resolves(expectedResult);
+
+        const key = {
+          prv: 'xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqhuCo36EkzGH6qiT9mJHBvuPKtLRYD4NxFb5hgXMQBB2LLT6mxLDHHo',
+        };
+        const message = 'test message';
+        const result = await ofc.signMessage(key, message);
+
+        superSignMessageStub.calledOnceWith(key, message).should.be.true();
+        result.should.equal(expectedResult);
+      });
+    });
+  });
+
+  describe('signTransaction (OfcToken)', function () {
+    let ofcToken: OfcToken;
+    const payload = '{"amount":"100","from":"alice","to":"bob"}';
+
+    beforeEach(function () {
+      ofcToken = new OfcToken(mockBitGo, TEST_TOKEN_CONFIG);
+    });
+
+    describe('with wallet and no prv (BitGo remote signing)', function () {
+      it('should POST to the sign endpoint with the payload and return the halfSigned result', async function () {
+        const wallet = new Wallet(mockBitGo, ofcToken, walletData);
+        const result = await ofcToken.signTransaction({ txPrebuild: { payload }, wallet });
+
+        mockBitGo.coin.calledOnceWith('ofc').should.be.true();
+        coinUrlStub.calledOnceWith('/wallet/wallet-id/tx/sign').should.be.true();
+        mockBitGo.post.calledOnceWith(signUrl).should.be.true();
+        mockBitGo.send.calledOnceWith({ payload }).should.be.true();
+        result.should.deepEqual({ halfSigned: { payload, signature: hexSignature } });
+      });
+    });
+
+    describe('with wallet and prv (local signing routed through wallet)', function () {
+      it('should fetch and decrypt the user key, then sign via baseCoin.signMessage', async function () {
+        const passphrase = 'test-passphrase';
+        const encryptedPrv = 'encrypted-prv-value';
+        const decryptedPrv = 'decrypted-prv-value';
+        const signatureBytes = Buffer.from('aabbccdd', 'hex');
+
+        const keychainsGetStub = sinon.stub().resolves({ encryptedPrv });
+        sinon.stub(ofcToken as any, 'keychains').returns({ get: keychainsGetStub });
+        mockBitGo.decrypt = sinon.stub().returns(decryptedPrv);
+        const signMessageStub = sinon.stub(BaseCoin.prototype, 'signMessage').resolves(signatureBytes);
+
+        const wallet = new Wallet(mockBitGo, ofcToken, walletData);
+        const result = await ofcToken.signTransaction({
+          txPrebuild: { payload },
+          wallet,
+          prv: passphrase,
+        });
+
+        keychainsGetStub.calledOnceWith({ id: walletData.keys[0] }).should.be.true();
+        (mockBitGo.decrypt as sinon.SinonStub)
+          .calledOnceWith({ input: encryptedPrv, password: passphrase })
+          .should.be.true();
+        signMessageStub.calledOnceWith({ prv: decryptedPrv }, payload).should.be.true();
+        result.should.deepEqual({ halfSigned: { payload, signature: signatureBytes.toString('hex') } });
+      });
+    });
+
+    describe('with prv only (local signing without wallet)', function () {
+      it('should pass the prv to baseCoin.signMessage and return the correct halfSigned result', async function () {
+        const prv = 'test-prv';
+        const signatureBytes = Buffer.from('ccddee', 'hex');
+        const superSignMessageStub = sinon.stub(BaseCoin.prototype, 'signMessage').resolves(signatureBytes);
+
+        const result = await ofcToken.signTransaction({ txPrebuild: { payload }, prv });
+
+        superSignMessageStub.calledOnceWith({ prv }, payload).should.be.true();
+        result.should.deepEqual({ halfSigned: { payload, signature: signatureBytes.toString('hex') } });
+      });
+    });
+
+    describe('with neither wallet nor prv', function () {
+      it('should throw an error', async function () {
+        await ofcToken
+          .signTransaction({ txPrebuild: { payload } })
+          .should.be.rejectedWith('You must pass in either one of wallet or prv');
+      });
+    });
+  });
+});