@bitgo/abstract-utxo 1.0.1-rc.0

package/dist/src/sign.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signAndVerifyWalletTransaction = exports.TransactionSigningError = exports.InputSigningError = void 0;
+/**
+ * @prettier
+ */
+const utxolib = require("@bitgo/utxo-lib");
+const bitgo_1 = require("@bitgo/utxo-lib/dist/src/bitgo");
+const debugLib = require("debug");
+const replayProtection_1 = require("./replayProtection");
+const debug = debugLib('bitgo:v2:utxo');
+class InputSigningError extends Error {
+    constructor(inputIndex, unspent, reason) {
+        super(`signing error at input ${inputIndex}: unspentId=${unspent.id}: ${reason}`);
+        this.inputIndex = inputIndex;
+        this.unspent = unspent;
+        this.reason = reason;
+    }
+    static expectedWalletUnspent(inputIndex, unspent) {
+        return new InputSigningError(inputIndex, unspent, `not a wallet unspent, not a replay protection unspent`);
+    }
+}
+exports.InputSigningError = InputSigningError;
+class TransactionSigningError extends Error {
+    constructor(signErrors, verifyError) {
+        super(`sign errors at inputs: [${signErrors.join(',')}], ` +
+            `verify errors at inputs: [${verifyError.join(',')}], see log for details`);
+    }
+}
+exports.TransactionSigningError = TransactionSigningError;
+/**
+ * Sign all inputs of a wallet transaction and verify signatures after signing.
+ * Collects and logs signing errors and verification errors, throws error in the end if any of them
+ * failed.
+ *
+ * @param transaction - wallet transaction (builder) to be signed
+ * @param unspents - transaction unspents
+ * @param walletSigner - signing parameters
+ * @param isLastSignature - Returns full-signed transaction when true. Builds half-signed when false.
+ */
+function signAndVerifyWalletTransaction(transaction, unspents, walletSigner, { isLastSignature }) {
+    const network = transaction.network;
+    const prevOutputs = unspents.map((u) => bitgo_1.toOutput(u, network));
+    let txBuilder;
+    if (transaction instanceof utxolib.bitgo.UtxoTransaction) {
+        txBuilder = utxolib.bitgo.createTransactionBuilderFromTransaction(transaction, prevOutputs);
+        if (transaction.ins.length !== unspents.length) {
+            throw new Error(`transaction inputs must match unspents`);
+        }
+    }
+    else if (transaction instanceof utxolib.bitgo.UtxoTransactionBuilder) {
+        txBuilder = transaction;
+    }
+    else {
+        throw new Error(`must pass UtxoTransaction or UtxoTransactionBuilder`);
+    }
+    const signErrors = unspents
+        .map((unspent, inputIndex) => {
+        if (replayProtection_1.isReplayProtectionUnspent(unspent, network)) {
+            debug('Skipping signature for input %d of %d (RP input?)', inputIndex + 1, unspents.length);
+            return;
+        }
+        if (!bitgo_1.isWalletUnspent(unspent)) {
+            return InputSigningError.expectedWalletUnspent(inputIndex, unspent);
+        }
+        try {
+            bitgo_1.signInputWithUnspent(txBuilder, inputIndex, unspent, walletSigner);
+            debug('Successfully signed input %d of %d', inputIndex + 1, unspents.length);
+        }
+        catch (e) {
+            return new InputSigningError(inputIndex, unspent, e);
+        }
+    })
+        .filter((e) => e !== undefined);
+    const signedTransaction = isLastSignature ? txBuilder.build() : txBuilder.buildIncomplete();
+    const verifyErrors = signedTransaction.ins
+        .map((input, inputIndex) => {
+        const unspent = unspents[inputIndex];
+        if (replayProtection_1.isReplayProtectionUnspent(unspent, network)) {
+            debug('Skipping input signature %d of %d (unspent from replay protection address which is platform signed only)', inputIndex + 1, unspents.length);
+            return;
+        }
+        if (!bitgo_1.isWalletUnspent(unspent)) {
+            return InputSigningError.expectedWalletUnspent(inputIndex, unspent);
+        }
+        try {
+            const publicKey = walletSigner.deriveForChainAndIndex(unspent.chain, unspent.index).signer.publicKey;
+            if (!utxolib.bitgo.verifySignatureWithPublicKey(signedTransaction, inputIndex, prevOutputs, publicKey)) {
+                return new InputSigningError(inputIndex, unspent, new Error(`invalid signature`));
+            }
+        }
+        catch (e) {
+            debug('Invalid signature');
+            return new InputSigningError(inputIndex, unspent, e);
+        }
+    })
+        .filter((e) => e !== undefined);
+    if (signErrors.length || verifyErrors.length) {
+        throw new TransactionSigningError(signErrors, verifyErrors);
+    }
+    return signedTransaction;
+}
+exports.signAndVerifyWalletTransaction = signAndVerifyWalletTransaction;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sign.js","sourceRoot":"","sources":["../../src/sign.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport * as utxolib from '@bitgo/utxo-lib';\nimport {\n  isWalletUnspent,\n  RootWalletKeys,\n  signInputWithUnspent,\n  toOutput,\n  Unspent,\n  WalletUnspentSigner,\n} from '@bitgo/utxo-lib/dist/src/bitgo';\nimport * as debugLib from 'debug';\n\nimport { isReplayProtectionUnspent } from './replayProtection';\n\nconst debug = debugLib('bitgo:v2:utxo');\n\nexport class InputSigningError extends Error {\n  static expectedWalletUnspent(inputIndex: number, unspent: Unspent): InputSigningError {\n    return new InputSigningError(inputIndex, unspent, `not a wallet unspent, not a replay protection unspent`);\n  }\n\n  constructor(public inputIndex: number, public unspent: Unspent, public reason: Error | string) {\n    super(`signing error at input ${inputIndex}: unspentId=${unspent.id}: ${reason}`);\n  }\n}\n\nexport class TransactionSigningError extends Error {\n  constructor(signErrors: InputSigningError[], verifyError: InputSigningError[]) {\n    super(\n      `sign errors at inputs: [${signErrors.join(',')}], ` +\n        `verify errors at inputs: [${verifyError.join(',')}], see log for details`\n    );\n  }\n}\n\n/**\n * Sign all inputs of a wallet transaction and verify signatures after signing.\n * Collects and logs signing errors and verification errors, throws error in the end if any of them\n * failed.\n *\n * @param transaction - wallet transaction (builder) to be signed\n * @param unspents - transaction unspents\n * @param walletSigner - signing parameters\n * @param isLastSignature - Returns full-signed transaction when true. Builds half-signed when false.\n */\nexport function signAndVerifyWalletTransaction(\n  transaction: utxolib.bitgo.UtxoTransaction | utxolib.bitgo.UtxoTransactionBuilder,\n  unspents: Unspent[],\n  walletSigner: WalletUnspentSigner<RootWalletKeys>,\n  { isLastSignature }: { isLastSignature: boolean }\n): utxolib.bitgo.UtxoTransaction {\n  const network = transaction.network as utxolib.Network;\n  const prevOutputs = unspents.map((u) => toOutput(u, network));\n\n  let txBuilder: utxolib.bitgo.UtxoTransactionBuilder;\n  if (transaction instanceof utxolib.bitgo.UtxoTransaction) {\n    txBuilder = utxolib.bitgo.createTransactionBuilderFromTransaction(transaction, prevOutputs);\n    if (transaction.ins.length !== unspents.length) {\n      throw new Error(`transaction inputs must match unspents`);\n    }\n  } else if (transaction instanceof utxolib.bitgo.UtxoTransactionBuilder) {\n    txBuilder = transaction;\n  } else {\n    throw new Error(`must pass UtxoTransaction or UtxoTransactionBuilder`);\n  }\n\n  const signErrors: InputSigningError[] = unspents\n    .map((unspent: Unspent, inputIndex: number) => {\n      if (isReplayProtectionUnspent(unspent, network)) {\n        debug('Skipping signature for input %d of %d (RP input?)', inputIndex + 1, unspents.length);\n        return;\n      }\n      if (!isWalletUnspent(unspent)) {\n        return InputSigningError.expectedWalletUnspent(inputIndex, unspent);\n      }\n      try {\n        signInputWithUnspent(txBuilder, inputIndex, unspent, walletSigner);\n        debug('Successfully signed input %d of %d', inputIndex + 1, unspents.length);\n      } catch (e) {\n        return new InputSigningError(inputIndex, unspent, e);\n      }\n    })\n    .filter((e): e is InputSigningError => e !== undefined);\n\n  const signedTransaction = isLastSignature ? txBuilder.build() : txBuilder.buildIncomplete();\n\n  const verifyErrors: InputSigningError[] = signedTransaction.ins\n    .map((input, inputIndex) => {\n      const unspent = unspents[inputIndex] as Unspent;\n      if (isReplayProtectionUnspent(unspent, network)) {\n        debug(\n          'Skipping input signature %d of %d (unspent from replay protection address which is platform signed only)',\n          inputIndex + 1,\n          unspents.length\n        );\n        return;\n      }\n      if (!isWalletUnspent(unspent)) {\n        return InputSigningError.expectedWalletUnspent(inputIndex, unspent);\n      }\n      try {\n        const publicKey = walletSigner.deriveForChainAndIndex(unspent.chain, unspent.index).signer.publicKey;\n        if (!utxolib.bitgo.verifySignatureWithPublicKey(signedTransaction, inputIndex, prevOutputs, publicKey)) {\n          return new InputSigningError(inputIndex, unspent, new Error(`invalid signature`));\n        }\n      } catch (e) {\n        debug('Invalid signature');\n        return new InputSigningError(inputIndex, unspent, e);\n      }\n    })\n    .filter((e): e is InputSigningError => e !== undefined);\n\n  if (signErrors.length || verifyErrors.length) {\n    throw new TransactionSigningError(signErrors, verifyErrors);\n  }\n\n  return signedTransaction;\n}\n"]}