@bitgo/abstract-utxo 10.6.0 → 10.8.0

package/dist/esm/sign.js

@@ -0,0 +1,162 @@
+import * as utxolib from '@bitgo/utxo-lib';
+import debugLib from 'debug';
+import { isReplayProtectionUnspent } from './replayProtection';
+const debug = debugLib('bitgo:v2:utxo');
+const { isWalletUnspent, signInputWithUnspent, toOutput } = utxolib.bitgo;
+export class InputSigningError extends Error {
+    static expectedWalletUnspent(inputIndex, unspent) {
+        return new InputSigningError(inputIndex, unspent, `not a wallet unspent, not a replay protection unspent`);
+    }
+    constructor(inputIndex, unspent, reason) {
+        super(`signing error at input ${inputIndex}: unspentId=${unspent.id}: ${reason}`);
+        this.inputIndex = inputIndex;
+        this.unspent = unspent;
+        this.reason = reason;
+    }
+}
+export class TransactionSigningError extends Error {
+    constructor(signErrors, verifyError) {
+        super(`sign errors at inputs: [${signErrors.join(',')}], ` +
+            `verify errors at inputs: [${verifyError.join(',')}], see log for details`);
+    }
+}
+/**
+ * Sign all inputs of a psbt and verify signatures after signing.
+ * Collects and logs signing errors and verification errors, throws error in the end if any of them
+ * failed.
+ *
+ * If it is the last signature, finalize and extract the transaction from the psbt.
+ *
+ * This function mirrors signAndVerifyWalletTransaction, but is used for signing PSBTs instead of
+ * using TransactionBuilder
+ *
+ * @param psbt
+ * @param signerKeychain
+ * @param isLastSignature
+ */
+export function signAndVerifyPsbt(psbt, signerKeychain, { isLastSignature, 
+/** deprecated */
+allowNonSegwitSigningWithoutPrevTx, }) {
+    const txInputs = psbt.txInputs;
+    const outputIds = [];
+    const scriptTypes = [];
+    const signErrors = psbt.data.inputs
+        .map((input, inputIndex) => {
+        const outputId = utxolib.bitgo.formatOutputId(utxolib.bitgo.getOutputIdForInput(txInputs[inputIndex]));
+        outputIds.push(outputId);
+        const { scriptType } = utxolib.bitgo.parsePsbtInput(input);
+        scriptTypes.push(scriptType);
+        if (scriptType === 'p2shP2pk') {
+            debug('Skipping signature for input %d of %d (RP input?)', inputIndex + 1, psbt.data.inputs.length);
+            return;
+        }
+        try {
+            psbt.signInputHD(inputIndex, signerKeychain);
+            debug('Successfully signed input %d of %d', inputIndex + 1, psbt.data.inputs.length);
+        }
+        catch (e) {
+            return new InputSigningError(inputIndex, { id: outputId }, e);
+        }
+    })
+        .filter((e) => e !== undefined);
+    const verifyErrors = psbt.data.inputs
+        .map((input, inputIndex) => {
+        const scriptType = scriptTypes[inputIndex];
+        if (scriptType === 'p2shP2pk') {
+            debug('Skipping input signature %d of %d (unspent from replay protection address which is platform signed only)', inputIndex + 1, psbt.data.inputs.length);
+            return;
+        }
+        const outputId = outputIds[inputIndex];
+        try {
+            if (!psbt.validateSignaturesOfInputHD(inputIndex, signerKeychain)) {
+                return new InputSigningError(inputIndex, { id: outputId }, new Error(`invalid signature`));
+            }
+        }
+        catch (e) {
+            debug('Invalid signature');
+            return new InputSigningError(inputIndex, { id: outputId }, e);
+        }
+    })
+        .filter((e) => e !== undefined);
+    if (signErrors.length || verifyErrors.length) {
+        throw new TransactionSigningError(signErrors, verifyErrors);
+    }
+    if (isLastSignature) {
+        psbt.finalizeAllInputs();
+        return psbt.extractTransaction();
+    }
+    return psbt;
+}
+/**
+ * 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.
+ */
+export function signAndVerifyWalletTransaction(transaction, unspents, walletSigner, { isLastSignature }) {
+    const network = transaction.network;
+    const prevOutputs = unspents.map((u) => 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 (isReplayProtectionUnspent(unspent, network)) {
+            debug('Skipping signature for input %d of %d (RP input?)', inputIndex + 1, unspents.length);
+            return;
+        }
+        if (!isWalletUnspent(unspent)) {
+            return InputSigningError.expectedWalletUnspent(inputIndex, unspent);
+        }
+        try {
+            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 (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 (!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;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sign.js","sourceRoot":"","sources":["../../src/sign.ts"],"names":[],"mappings":"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","sourcesContent":["import * as utxolib from '@bitgo/utxo-lib';\nimport debugLib from 'debug';\n\nimport { isReplayProtectionUnspent } from './replayProtection';\n\nconst debug = debugLib('bitgo:v2:utxo');\n\nconst { isWalletUnspent, signInputWithUnspent, toOutput } = utxolib.bitgo;\n\ntype Unspent<TNumber extends number | bigint = number> = utxolib.bitgo.Unspent<TNumber>;\n\ntype RootWalletKeys = utxolib.bitgo.RootWalletKeys;\n\ntype PsbtParsedScriptTypes =\n  | 'p2sh'\n  | 'p2wsh'\n  | 'p2shP2wsh'\n  | 'p2shP2pk'\n  | 'taprootKeyPathSpend'\n  | 'taprootScriptPathSpend';\n\nexport class InputSigningError<TNumber extends number | bigint = number> extends Error {\n  static expectedWalletUnspent<TNumber extends number | bigint>(\n    inputIndex: number,\n    unspent: Unspent<TNumber> | { id: string }\n  ): InputSigningError<TNumber> {\n    return new InputSigningError(inputIndex, unspent, `not a wallet unspent, not a replay protection unspent`);\n  }\n\n  constructor(\n    public inputIndex: number,\n    public unspent: Unspent<TNumber> | { id: string },\n    public reason: Error | string\n  ) {\n    super(`signing error at input ${inputIndex}: unspentId=${unspent.id}: ${reason}`);\n  }\n}\n\nexport class TransactionSigningError<TNumber extends number | bigint = number> extends Error {\n  constructor(signErrors: InputSigningError<TNumber>[], verifyError: InputSigningError<TNumber>[]) {\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 psbt 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 * If it is the last signature, finalize and extract the transaction from the psbt.\n *\n * This function mirrors signAndVerifyWalletTransaction, but is used for signing PSBTs instead of\n * using TransactionBuilder\n *\n * @param psbt\n * @param signerKeychain\n * @param isLastSignature\n */\nexport function signAndVerifyPsbt(\n  psbt: utxolib.bitgo.UtxoPsbt,\n  signerKeychain: utxolib.BIP32Interface,\n  {\n    isLastSignature,\n    /** deprecated */\n    allowNonSegwitSigningWithoutPrevTx,\n  }: { isLastSignature: boolean; allowNonSegwitSigningWithoutPrevTx?: boolean }\n): utxolib.bitgo.UtxoPsbt | utxolib.bitgo.UtxoTransaction<bigint> {\n  const txInputs = psbt.txInputs;\n  const outputIds: string[] = [];\n  const scriptTypes: PsbtParsedScriptTypes[] = [];\n\n  const signErrors: InputSigningError<bigint>[] = psbt.data.inputs\n    .map((input, inputIndex: number) => {\n      const outputId = utxolib.bitgo.formatOutputId(utxolib.bitgo.getOutputIdForInput(txInputs[inputIndex]));\n      outputIds.push(outputId);\n\n      const { scriptType } = utxolib.bitgo.parsePsbtInput(input);\n      scriptTypes.push(scriptType);\n\n      if (scriptType === 'p2shP2pk') {\n        debug('Skipping signature for input %d of %d (RP input?)', inputIndex + 1, psbt.data.inputs.length);\n        return;\n      }\n\n      try {\n        psbt.signInputHD(inputIndex, signerKeychain);\n        debug('Successfully signed input %d of %d', inputIndex + 1, psbt.data.inputs.length);\n      } catch (e) {\n        return new InputSigningError<bigint>(inputIndex, { id: outputId }, e);\n      }\n    })\n    .filter((e): e is InputSigningError<bigint> => e !== undefined);\n\n  const verifyErrors: InputSigningError<bigint>[] = psbt.data.inputs\n    .map((input, inputIndex) => {\n      const scriptType = scriptTypes[inputIndex];\n      if (scriptType === 'p2shP2pk') {\n        debug(\n          'Skipping input signature %d of %d (unspent from replay protection address which is platform signed only)',\n          inputIndex + 1,\n          psbt.data.inputs.length\n        );\n        return;\n      }\n\n      const outputId = outputIds[inputIndex];\n      try {\n        if (!psbt.validateSignaturesOfInputHD(inputIndex, signerKeychain)) {\n          return new InputSigningError(inputIndex, { id: outputId }, new Error(`invalid signature`));\n        }\n      } catch (e) {\n        debug('Invalid signature');\n        return new InputSigningError<bigint>(inputIndex, { id: outputId }, e);\n      }\n    })\n    .filter((e): e is InputSigningError<bigint> => e !== undefined);\n\n  if (signErrors.length || verifyErrors.length) {\n    throw new TransactionSigningError(signErrors, verifyErrors);\n  }\n\n  if (isLastSignature) {\n    psbt.finalizeAllInputs();\n    return psbt.extractTransaction();\n  }\n\n  return psbt;\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<TNumber extends number | bigint>(\n  transaction: utxolib.bitgo.UtxoTransaction<TNumber> | utxolib.bitgo.UtxoTransactionBuilder<TNumber>,\n  unspents: Unspent<TNumber>[],\n  walletSigner: utxolib.bitgo.WalletUnspentSigner<RootWalletKeys>,\n  { isLastSignature }: { isLastSignature: boolean }\n): utxolib.bitgo.UtxoTransaction<TNumber> {\n  const network = transaction.network as utxolib.Network;\n  const prevOutputs = unspents.map((u) => toOutput(u, network));\n\n  let txBuilder: utxolib.bitgo.UtxoTransactionBuilder<TNumber>;\n  if (transaction instanceof utxolib.bitgo.UtxoTransaction) {\n    txBuilder = utxolib.bitgo.createTransactionBuilderFromTransaction<TNumber>(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<TNumber>[] = unspents\n    .map((unspent: Unspent<TNumber>, inputIndex: number) => {\n      if (isReplayProtectionUnspent<TNumber>(unspent, network)) {\n        debug('Skipping signature for input %d of %d (RP input?)', inputIndex + 1, unspents.length);\n        return;\n      }\n      if (!isWalletUnspent<TNumber>(unspent)) {\n        return InputSigningError.expectedWalletUnspent<TNumber>(inputIndex, unspent);\n      }\n      try {\n        signInputWithUnspent<TNumber>(txBuilder, inputIndex, unspent, walletSigner);\n        debug('Successfully signed input %d of %d', inputIndex + 1, unspents.length);\n      } catch (e) {\n        return new InputSigningError<TNumber>(inputIndex, unspent, e);\n      }\n    })\n    .filter((e): e is InputSigningError<TNumber> => e !== undefined);\n\n  const signedTransaction = isLastSignature ? txBuilder.build() : txBuilder.buildIncomplete();\n\n  const verifyErrors: InputSigningError<TNumber>[] = signedTransaction.ins\n    .map((input, inputIndex) => {\n      const unspent = unspents[inputIndex] as Unspent<TNumber>;\n      if (isReplayProtectionUnspent<TNumber>(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<TNumber>(unspent)) {\n        return InputSigningError.expectedWalletUnspent<TNumber>(inputIndex, unspent);\n      }\n      try {\n        const publicKey = walletSigner.deriveForChainAndIndex(unspent.chain, unspent.index).signer.publicKey;\n        if (\n          !utxolib.bitgo.verifySignatureWithPublicKey<TNumber>(signedTransaction, inputIndex, prevOutputs, publicKey)\n        ) {\n          return new InputSigningError(inputIndex, unspent, new Error(`invalid signature`));\n        }\n      } catch (e) {\n        debug('Invalid signature');\n        return new InputSigningError<TNumber>(inputIndex, unspent, e);\n      }\n    })\n    .filter((e): e is InputSigningError<TNumber> => e !== undefined);\n\n  if (signErrors.length || verifyErrors.length) {\n    throw new TransactionSigningError(signErrors, verifyErrors);\n  }\n\n  return signedTransaction;\n}\n"]}

package/dist/esm/transaction/bip322.d.ts

@@ -0,0 +1,27 @@
+import * as t from 'io-ts';
+declare const BIP322MessageInfo: t.TypeC<{
+    address: t.StringC;
+    message: t.StringC;
+    pubkeys: t.ArrayC<t.StringC>;
+    scriptType: t.UnionC<[t.LiteralC<"p2sh">, t.LiteralC<"p2shP2wsh">, t.LiteralC<"p2wsh">, t.LiteralC<"p2tr">, t.LiteralC<"p2trMusig2">]>;
+}>;
+export type BIP322MessageInfo = t.TypeOf<typeof BIP322MessageInfo>;
+declare const BIP322MessageBroadcastable: t.TypeC<{
+    txHex: t.StringC;
+    messageInfo: t.ArrayC<t.TypeC<{
+        address: t.StringC;
+        message: t.StringC;
+        pubkeys: t.ArrayC<t.StringC>;
+        scriptType: t.UnionC<[t.LiteralC<"p2sh">, t.LiteralC<"p2shP2wsh">, t.LiteralC<"p2wsh">, t.LiteralC<"p2tr">, t.LiteralC<"p2trMusig2">]>;
+    }>>;
+}>;
+export type BIP322MessageBroadcastable = t.TypeOf<typeof BIP322MessageBroadcastable>;
+export declare function serializeBIP322BroadcastableMessage(message: BIP322MessageBroadcastable): string;
+export declare function deserializeBIP322BroadcastableMessage(hex: string): BIP322MessageBroadcastable;
+export declare function verifyTransactionFromBroadcastableMessage(message: BIP322MessageBroadcastable, coinName: string): boolean;
+export declare function generateBIP322MessageListAndVerifyFromMessageBroadcastable(messageBroadcastables: BIP322MessageBroadcastable[], coinName: string): {
+    address: string;
+    message: string;
+}[];
+export {};
+//# sourceMappingURL=bip322.d.ts.map

package/dist/esm/transaction/bip322.js

@@ -0,0 +1,86 @@
+import { decodeOrElse } from '@bitgo/sdk-core';
+import { bip322 } from '@bitgo/utxo-core';
+import { bitgo, networks } from '@bitgo/utxo-lib';
+import * as t from 'io-ts';
+const BIP322MessageInfo = t.type({
+    address: t.string,
+    message: t.string,
+    pubkeys: t.array(t.string),
+    scriptType: t.union([
+        t.literal('p2sh'),
+        t.literal('p2shP2wsh'),
+        t.literal('p2wsh'),
+        t.literal('p2tr'),
+        t.literal('p2trMusig2'),
+    ]),
+});
+const BIP322MessageBroadcastable = t.type({
+    txHex: t.string,
+    messageInfo: t.array(BIP322MessageInfo),
+});
+export function serializeBIP322BroadcastableMessage(message) {
+    return Buffer.from(JSON.stringify(message), 'utf8').toString('hex');
+}
+export function deserializeBIP322BroadcastableMessage(hex) {
+    const json = JSON.parse(Buffer.from(hex, 'hex').toString('utf8'));
+    return decodeOrElse(BIP322MessageBroadcastable.name, BIP322MessageBroadcastable, json, (error) => {
+        throw new Error(`Failed to decode ${BIP322MessageBroadcastable.name}: ${error}`);
+    });
+}
+export function verifyTransactionFromBroadcastableMessage(message, coinName) {
+    let network = networks.bitcoin;
+    if (coinName === 'tbtc4') {
+        network = networks.bitcoinTestnet4;
+    }
+    else if (coinName !== 'btc') {
+        throw new Error('Only tbtc4 or btc coinNames are supported.');
+    }
+    if (bitgo.isPsbt(message.txHex)) {
+        const psbt = bitgo.createPsbtFromBuffer(Buffer.from(message.txHex, 'hex'), network);
+        try {
+            bip322.assertBip322PsbtProof(psbt, message.messageInfo);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    else {
+        const tx = bitgo.createTransactionFromBuffer(Buffer.from(message.txHex, 'hex'), network, { amountType: 'bigint' });
+        try {
+            bip322.assertBip322TxProof(tx, message.messageInfo);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}
+export function generateBIP322MessageListAndVerifyFromMessageBroadcastable(messageBroadcastables, coinName) {
+    // Map from the address to the message. If there are duplicates of the address, make sure that the
+    // message is the same. If there are duplicate addresses and the messages are not the same, throw an error.
+    const addressMap = new Map();
+    messageBroadcastables.forEach((message, index) => {
+        if (verifyTransactionFromBroadcastableMessage(message, coinName)) {
+            message.messageInfo.forEach((info) => {
+                const { address, message: msg } = info;
+                if (addressMap.has(address)) {
+                    if (addressMap.get(address) !== msg) {
+                        throw new Error(`Duplicate address ${address} has different messages`);
+                    }
+                }
+                else {
+                    addressMap.set(address, msg);
+                }
+            });
+        }
+        else {
+            throw new Error(`Message Broadcastable ${index} did not have a successful validation`);
+        }
+    });
+    return Array.from(addressMap.entries()).map(([address, message]) => ({
+        address,
+        message,
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bip322.js","sourceRoot":"","sources":["../../../src/transaction/bip322.ts"],"names":[],"mappings":"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","sourcesContent":["import { decodeOrElse } from '@bitgo/sdk-core';\nimport { bip322 } from '@bitgo/utxo-core';\nimport { bitgo, networks, Network } from '@bitgo/utxo-lib';\nimport * as t from 'io-ts';\n\nconst BIP322MessageInfo = t.type({\n  address: t.string,\n  message: t.string,\n  pubkeys: t.array(t.string),\n  scriptType: t.union([\n    t.literal('p2sh'),\n    t.literal('p2shP2wsh'),\n    t.literal('p2wsh'),\n    t.literal('p2tr'),\n    t.literal('p2trMusig2'),\n  ]),\n});\n\nexport type BIP322MessageInfo = t.TypeOf<typeof BIP322MessageInfo>;\n\nconst BIP322MessageBroadcastable = t.type({\n  txHex: t.string,\n  messageInfo: t.array(BIP322MessageInfo),\n});\n\nexport type BIP322MessageBroadcastable = t.TypeOf<typeof BIP322MessageBroadcastable>;\n\nexport function serializeBIP322BroadcastableMessage(message: BIP322MessageBroadcastable): string {\n  return Buffer.from(JSON.stringify(message), 'utf8').toString('hex');\n}\n\nexport function deserializeBIP322BroadcastableMessage(hex: string): BIP322MessageBroadcastable {\n  const json = JSON.parse(Buffer.from(hex, 'hex').toString('utf8'));\n  return decodeOrElse(BIP322MessageBroadcastable.name, BIP322MessageBroadcastable, json, (error) => {\n    throw new Error(`Failed to decode ${BIP322MessageBroadcastable.name}: ${error}`);\n  });\n}\n\nexport function verifyTransactionFromBroadcastableMessage(\n  message: BIP322MessageBroadcastable,\n  coinName: string\n): boolean {\n  let network: Network = networks.bitcoin;\n  if (coinName === 'tbtc4') {\n    network = networks.bitcoinTestnet4;\n  } else if (coinName !== 'btc') {\n    throw new Error('Only tbtc4 or btc coinNames are supported.');\n  }\n  if (bitgo.isPsbt(message.txHex)) {\n    const psbt = bitgo.createPsbtFromBuffer(Buffer.from(message.txHex, 'hex'), network);\n    try {\n      bip322.assertBip322PsbtProof(psbt, message.messageInfo);\n      return true;\n    } catch (error) {\n      return false;\n    }\n  } else {\n    const tx = bitgo.createTransactionFromBuffer(Buffer.from(message.txHex, 'hex'), network, { amountType: 'bigint' });\n    try {\n      bip322.assertBip322TxProof(tx, message.messageInfo);\n      return true;\n    } catch (error) {\n      return false;\n    }\n  }\n}\n\nexport function generateBIP322MessageListAndVerifyFromMessageBroadcastable(\n  messageBroadcastables: BIP322MessageBroadcastable[],\n  coinName: string\n): { address: string; message: string }[] {\n  // Map from the address to the message. If there are duplicates of the address, make sure that the\n  // message is the same. If there are duplicate addresses and the messages are not the same, throw an error.\n  const addressMap = new Map<string, string>();\n\n  messageBroadcastables.forEach((message, index) => {\n    if (verifyTransactionFromBroadcastableMessage(message, coinName)) {\n      message.messageInfo.forEach((info) => {\n        const { address, message: msg } = info;\n        if (addressMap.has(address)) {\n          if (addressMap.get(address) !== msg) {\n            throw new Error(`Duplicate address ${address} has different messages`);\n          }\n        } else {\n          addressMap.set(address, msg);\n        }\n      });\n    } else {\n      throw new Error(`Message Broadcastable ${index} did not have a successful validation`);\n    }\n  });\n\n  return Array.from(addressMap.entries()).map(([address, message]) => ({\n    address,\n    message,\n  }));\n}\n"]}

package/dist/esm/transaction/common/verifyPayGoAmount.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=verifyPayGoAmount.d.ts.map

package/dist/{src → esm}/transaction/common/verifyPayGoAmount.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyaWZ5UGF5R29BbW91bnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdHJhbnNhY3Rpb24vY29tbW9uL3ZlcmlmeVBheUdvQW1vdW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIiXX0=

package/dist/esm/transaction/descriptor/explainPsbt.d.ts

@@ -0,0 +1,5 @@
+import * as utxolib from '@bitgo/utxo-lib';
+import * as coreDescriptors from '@bitgo/utxo-core/descriptor';
+import type { TransactionExplanationDescriptor } from '../fixedScript/explainTransaction';
+export declare function explainPsbt(psbt: utxolib.bitgo.UtxoPsbt, descriptors: coreDescriptors.DescriptorMap): TransactionExplanationDescriptor;
+//# sourceMappingURL=explainPsbt.d.ts.map

package/dist/esm/transaction/descriptor/explainPsbt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explainPsbt.d.ts","sourceRoot":"","sources":["../../../../src/transaction/descriptor/explainPsbt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AAE3C,OAAO,KAAK,eAAe,MAAM,6BAA6B,CAAC;AAG/D,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,mCAAmC,CAAC;AA4B1F,wBAAgB,WAAW,CACzB,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAC5B,WAAW,EAAE,eAAe,CAAC,aAAa,GACzC,gCAAgC,CAkBlC"}

package/dist/esm/transaction/descriptor/explainPsbt.js

@@ -0,0 +1,44 @@
+import * as coreDescriptors from '@bitgo/utxo-core/descriptor';
+import { toExtendedAddressFormat } from '../recipient';
+function toRecipient(output, network) {
+    return {
+        address: toExtendedAddressFormat(output.script, network),
+        amount: output.value.toString(),
+    };
+}
+function sumValues(arr) {
+    return arr.reduce((sum, e) => sum + e.value, BigInt(0));
+}
+function getInputSignaturesForInputIndex(psbt, inputIndex) {
+    const { partialSig } = psbt.data.inputs[inputIndex];
+    if (!partialSig) {
+        return 0;
+    }
+    return partialSig.reduce((agg, p) => {
+        const valid = psbt.validateSignaturesOfInputCommon(inputIndex, p.pubkey);
+        return agg + (valid ? 1 : 0);
+    }, 0);
+}
+function getInputSignatures(psbt) {
+    return psbt.data.inputs.map((_, i) => getInputSignaturesForInputIndex(psbt, i));
+}
+export function explainPsbt(psbt, descriptors) {
+    const parsedTransaction = coreDescriptors.parse(psbt, descriptors, psbt.network);
+    const { inputs, outputs } = parsedTransaction;
+    const externalOutputs = outputs.filter((o) => o.scriptId === undefined);
+    const changeOutputs = outputs.filter((o) => o.scriptId !== undefined);
+    const fee = sumValues(inputs) - sumValues(outputs);
+    const inputSignatures = getInputSignatures(psbt);
+    return {
+        inputSignatures,
+        signatures: inputSignatures.reduce((a, b) => Math.min(a, b), Infinity),
+        locktime: psbt.locktime,
+        id: psbt.getUnsignedTx().getId(),
+        outputs: externalOutputs.map((o) => toRecipient(o, psbt.network)),
+        outputAmount: sumValues(externalOutputs).toString(),
+        changeOutputs: changeOutputs.map((o) => toRecipient(o, psbt.network)),
+        changeAmount: sumValues(changeOutputs).toString(),
+        fee: fee.toString(),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/transaction/descriptor/index.d.ts

@@ -0,0 +1,7 @@
+export { DescriptorMap } from '@bitgo/utxo-core/descriptor';
+export { explainPsbt } from './explainPsbt';
+export { parse } from './parse';
+export { parseToAmountType } from './parseToAmountType';
+export { verifyTransaction } from './verifyTransaction';
+export { signPsbt } from './signPsbt';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/transaction/descriptor/index.js

@@ -0,0 +1,6 @@
+export { explainPsbt } from './explainPsbt';
+export { parse } from './parse';
+export { parseToAmountType } from './parseToAmountType';
+export { verifyTransaction } from './verifyTransaction';
+export { signPsbt } from './signPsbt';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdHJhbnNhY3Rpb24vZGVzY3JpcHRvci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzVDLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFDaEMsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDeEQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0scUJBQXFCLENBQUM7QUFDeEQsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IERlc2NyaXB0b3JNYXAgfSBmcm9tICdAYml0Z28vdXR4by1jb3JlL2Rlc2NyaXB0b3InO1xuZXhwb3J0IHsgZXhwbGFpblBzYnQgfSBmcm9tICcuL2V4cGxhaW5Qc2J0JztcbmV4cG9ydCB7IHBhcnNlIH0gZnJvbSAnLi9wYXJzZSc7XG5leHBvcnQgeyBwYXJzZVRvQW1vdW50VHlwZSB9IGZyb20gJy4vcGFyc2VUb0Ftb3VudFR5cGUnO1xuZXhwb3J0IHsgdmVyaWZ5VHJhbnNhY3Rpb24gfSBmcm9tICcuL3ZlcmlmeVRyYW5zYWN0aW9uJztcbmV4cG9ydCB7IHNpZ25Qc2J0IH0gZnJvbSAnLi9zaWduUHNidCc7XG4iXX0=

package/dist/esm/transaction/descriptor/parse.d.ts

@@ -0,0 +1,16 @@
+import * as utxolib from '@bitgo/utxo-lib';
+import { ITransactionRecipient } from '@bitgo/sdk-core';
+import * as coreDescriptors from '@bitgo/utxo-core/descriptor';
+import { AbstractUtxoCoin, ParseTransactionOptions } from '../../abstractUtxoCoin';
+import { BaseOutput, BaseParsedTransaction, BaseParsedTransactionOutputs } from '../types';
+import { IDescriptorWallet } from '../../descriptor/descriptorWallet';
+type ParsedOutput = coreDescriptors.ParsedOutput;
+export type RecipientOutput = Omit<ParsedOutput, 'value'> & {
+    value: bigint | 'max';
+};
+export type ParsedOutputsBigInt = BaseParsedTransactionOutputs<bigint, BaseOutput<bigint | 'max'>>;
+export declare function toBaseParsedTransactionOutputsFromPsbt(psbt: utxolib.bitgo.UtxoPsbt, descriptorMap: coreDescriptors.DescriptorMap, recipients: ITransactionRecipient[], network: utxolib.Network): ParsedOutputsBigInt;
+export type ParsedDescriptorTransaction<TAmount extends number | bigint> = BaseParsedTransaction<TAmount, BaseOutput<TAmount | 'max'>>;
+export declare function parse(coin: AbstractUtxoCoin, wallet: IDescriptorWallet, params: ParseTransactionOptions<number | bigint>): ParsedDescriptorTransaction<bigint>;
+export {};
+//# sourceMappingURL=parse.d.ts.map

package/dist/esm/transaction/descriptor/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../src/transaction/descriptor/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,eAAe,MAAM,6BAA6B,CAAC;AAE/D,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACnF,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,4BAA4B,EAAE,MAAM,UAAU,CAAC;AAG3F,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAItE,KAAK,YAAY,GAAG,eAAe,CAAC,YAAY,CAAC;AAEjD,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,YAAY,EAAE,OAAO,CAAC,GAAG;IAC1D,KAAK,EAAE,MAAM,GAAG,KAAK,CAAC;CACvB,CAAC;AAkDF,MAAM,MAAM,mBAAmB,GAAG,4BAA4B,CAAC,MAAM,EAAE,UAAU,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC;AAmBnG,wBAAgB,sCAAsC,CACpD,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAC5B,aAAa,EAAE,eAAe,CAAC,aAAa,EAC5C,UAAU,EAAE,qBAAqB,EAAE,EACnC,OAAO,EAAE,OAAO,CAAC,OAAO,GACvB,mBAAmB,CASrB;AAED,MAAM,MAAM,2BAA2B,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,IAAI,qBAAqB,CAC9F,OAAO,EACP,UAAU,CAAC,OAAO,GAAG,KAAK,CAAC,CAC5B,CAAC;AAEF,wBAAgB,KAAK,CACnB,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,iBAAiB,EACzB,MAAM,EAAE,uBAAuB,CAAC,MAAM,GAAG,MAAM,CAAC,GAC/C,2BAA2B,CAAC,MAAM,CAAC,CA4BrC"}

package/dist/esm/transaction/descriptor/parse.js

@@ -0,0 +1,79 @@
+import * as utxolib from '@bitgo/utxo-lib';
+import * as coreDescriptors from '@bitgo/utxo-core/descriptor';
+import { getKeySignatures, toBip32Triple, UtxoNamedKeychains } from '../../keychains';
+import { getDescriptorMapFromWallet, getPolicyForEnv } from '../../descriptor';
+import { fromExtendedAddressFormatToScript, toExtendedAddressFormat } from '../recipient';
+import { outputDifferencesWithExpected } from '../outputDifference';
+function toRecipientOutput(recipient, network) {
+    return {
+        address: recipient.address,
+        value: recipient.amount === 'max' ? 'max' : BigInt(recipient.amount),
+        script: fromExtendedAddressFormatToScript(recipient.address, network),
+    };
+}
+function parseOutputsWithPsbt(psbt, descriptorMap, recipientOutputs) {
+    const parsed = coreDescriptors.parse(psbt, descriptorMap, psbt.network);
+    const changeOutputs = parsed.outputs.filter((o) => o.scriptId !== undefined);
+    const outputDiffs = outputDifferencesWithExpected(parsed.outputs, recipientOutputs);
+    return {
+        outputs: parsed.outputs,
+        changeOutputs,
+        ...outputDiffs,
+    };
+}
+function sumValues(arr) {
+    return arr.reduce((sum, e) => sum + e.value, BigInt(0));
+}
+function toBaseOutputs(outputs, network) {
+    return outputs.map((o) => ({
+        address: toExtendedAddressFormat(o.script, network),
+        amount: o.value === 'max' ? 'max' : BigInt(o.value),
+        external: o.scriptId === undefined,
+    }));
+}
+function toBaseParsedTransactionOutputs({ outputs, changeOutputs, explicitOutputs, implicitOutputs, missingOutputs }, network) {
+    const explicitExternalOutputs = explicitOutputs.filter((o) => o.scriptId === undefined);
+    const implicitExternalOutputs = implicitOutputs.filter((o) => o.scriptId === undefined);
+    return {
+        outputs: toBaseOutputs(outputs, network),
+        changeOutputs: toBaseOutputs(changeOutputs, network),
+        explicitExternalOutputs: toBaseOutputs(explicitExternalOutputs, network),
+        explicitExternalSpendAmount: sumValues(explicitExternalOutputs),
+        implicitExternalOutputs: toBaseOutputs(implicitExternalOutputs, network),
+        implicitExternalSpendAmount: sumValues(implicitExternalOutputs),
+        missingOutputs: toBaseOutputs(missingOutputs, network),
+    };
+}
+export function toBaseParsedTransactionOutputsFromPsbt(psbt, descriptorMap, recipients, network) {
+    return toBaseParsedTransactionOutputs(parseOutputsWithPsbt(psbt, descriptorMap, recipients.map((r) => toRecipientOutput(r, psbt.network))), network);
+}
+export function parse(coin, wallet, params) {
+    if (params.txParams.allowExternalChangeAddress) {
+        throw new Error('allowExternalChangeAddress is not supported for descriptor wallets');
+    }
+    if (params.txParams.changeAddress) {
+        throw new Error('changeAddress is not supported for descriptor wallets');
+    }
+    const keychains = params.verification?.keychains;
+    if (!keychains || !UtxoNamedKeychains.is(keychains)) {
+        throw new Error('keychain is required for descriptor wallets');
+    }
+    const { recipients } = params.txParams;
+    if (!recipients) {
+        throw new Error('recipients is required');
+    }
+    const psbt = coin.decodeTransactionFromPrebuild(params.txPrebuild);
+    if (!(psbt instanceof utxolib.bitgo.UtxoPsbt)) {
+        throw new Error('expected psbt to be an instance of UtxoPsbt');
+    }
+    const walletKeys = toBip32Triple(keychains);
+    const descriptorMap = getDescriptorMapFromWallet(wallet, walletKeys, getPolicyForEnv(params.wallet.bitgo.env));
+    return {
+        ...toBaseParsedTransactionOutputsFromPsbt(psbt, descriptorMap, recipients, psbt.network),
+        keychains,
+        keySignatures: getKeySignatures(wallet) ?? {},
+        customChange: undefined,
+        needsCustomChangeKeySignatureVerification: false,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parse.js","sourceRoot":"","sources":["../../../../src/transaction/descriptor/parse.ts"],"names":[],"mappings":"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","sourcesContent":["import * as utxolib from '@bitgo/utxo-lib';\nimport { ITransactionRecipient } from '@bitgo/sdk-core';\nimport * as coreDescriptors from '@bitgo/utxo-core/descriptor';\n\nimport { AbstractUtxoCoin, ParseTransactionOptions } from '../../abstractUtxoCoin';\nimport { BaseOutput, BaseParsedTransaction, BaseParsedTransactionOutputs } from '../types';\nimport { getKeySignatures, toBip32Triple, UtxoNamedKeychains } from '../../keychains';\nimport { getDescriptorMapFromWallet, getPolicyForEnv } from '../../descriptor';\nimport { IDescriptorWallet } from '../../descriptor/descriptorWallet';\nimport { fromExtendedAddressFormatToScript, toExtendedAddressFormat } from '../recipient';\nimport { outputDifferencesWithExpected, OutputDifferenceWithExpected } from '../outputDifference';\n\ntype ParsedOutput = coreDescriptors.ParsedOutput;\n\nexport type RecipientOutput = Omit<ParsedOutput, 'value'> & {\n  value: bigint | 'max';\n};\n\nfunction toRecipientOutput(recipient: ITransactionRecipient, network: utxolib.Network): RecipientOutput {\n  return {\n    address: recipient.address,\n    value: recipient.amount === 'max' ? 'max' : BigInt(recipient.amount),\n    script: fromExtendedAddressFormatToScript(recipient.address, network),\n  };\n}\n\n// TODO(BTC-1697): allow outputs with `value: 'max'` here\ntype ParsedOutputs = OutputDifferenceWithExpected<ParsedOutput, RecipientOutput> & {\n  outputs: ParsedOutput[];\n  changeOutputs: ParsedOutput[];\n};\n\nfunction parseOutputsWithPsbt(\n  psbt: utxolib.bitgo.UtxoPsbt,\n  descriptorMap: coreDescriptors.DescriptorMap,\n  recipientOutputs: RecipientOutput[]\n): ParsedOutputs {\n  const parsed = coreDescriptors.parse(psbt, descriptorMap, psbt.network);\n  const changeOutputs = parsed.outputs.filter((o) => o.scriptId !== undefined);\n  const outputDiffs = outputDifferencesWithExpected(parsed.outputs, recipientOutputs);\n  return {\n    outputs: parsed.outputs,\n    changeOutputs,\n    ...outputDiffs,\n  };\n}\n\nfunction sumValues(arr: { value: bigint }[]): bigint {\n  return arr.reduce((sum, e) => sum + e.value, BigInt(0));\n}\n\nfunction toBaseOutputs(outputs: ParsedOutput[], network: utxolib.Network): BaseOutput<bigint>[];\nfunction toBaseOutputs(outputs: RecipientOutput[], network: utxolib.Network): BaseOutput<bigint | 'max'>[];\nfunction toBaseOutputs(\n  outputs: (ParsedOutput | RecipientOutput)[],\n  network: utxolib.Network\n): BaseOutput<bigint | 'max'>[] {\n  return outputs.map(\n    (o): BaseOutput<bigint | 'max'> => ({\n      address: toExtendedAddressFormat(o.script, network),\n      amount: o.value === 'max' ? 'max' : BigInt(o.value),\n      external: o.scriptId === undefined,\n    })\n  );\n}\n\nexport type ParsedOutputsBigInt = BaseParsedTransactionOutputs<bigint, BaseOutput<bigint | 'max'>>;\n\nfunction toBaseParsedTransactionOutputs(\n  { outputs, changeOutputs, explicitOutputs, implicitOutputs, missingOutputs }: ParsedOutputs,\n  network: utxolib.Network\n): ParsedOutputsBigInt {\n  const explicitExternalOutputs = explicitOutputs.filter((o) => o.scriptId === undefined);\n  const implicitExternalOutputs = implicitOutputs.filter((o) => o.scriptId === undefined);\n  return {\n    outputs: toBaseOutputs(outputs, network),\n    changeOutputs: toBaseOutputs(changeOutputs, network),\n    explicitExternalOutputs: toBaseOutputs(explicitExternalOutputs, network),\n    explicitExternalSpendAmount: sumValues(explicitExternalOutputs),\n    implicitExternalOutputs: toBaseOutputs(implicitExternalOutputs, network),\n    implicitExternalSpendAmount: sumValues(implicitExternalOutputs),\n    missingOutputs: toBaseOutputs(missingOutputs, network),\n  };\n}\n\nexport function toBaseParsedTransactionOutputsFromPsbt(\n  psbt: utxolib.bitgo.UtxoPsbt,\n  descriptorMap: coreDescriptors.DescriptorMap,\n  recipients: ITransactionRecipient[],\n  network: utxolib.Network\n): ParsedOutputsBigInt {\n  return toBaseParsedTransactionOutputs(\n    parseOutputsWithPsbt(\n      psbt,\n      descriptorMap,\n      recipients.map((r) => toRecipientOutput(r, psbt.network))\n    ),\n    network\n  );\n}\n\nexport type ParsedDescriptorTransaction<TAmount extends number | bigint> = BaseParsedTransaction<\n  TAmount,\n  BaseOutput<TAmount | 'max'>\n>;\n\nexport function parse(\n  coin: AbstractUtxoCoin,\n  wallet: IDescriptorWallet,\n  params: ParseTransactionOptions<number | bigint>\n): ParsedDescriptorTransaction<bigint> {\n  if (params.txParams.allowExternalChangeAddress) {\n    throw new Error('allowExternalChangeAddress is not supported for descriptor wallets');\n  }\n  if (params.txParams.changeAddress) {\n    throw new Error('changeAddress is not supported for descriptor wallets');\n  }\n  const keychains = params.verification?.keychains;\n  if (!keychains || !UtxoNamedKeychains.is(keychains)) {\n    throw new Error('keychain is required for descriptor wallets');\n  }\n  const { recipients } = params.txParams;\n  if (!recipients) {\n    throw new Error('recipients is required');\n  }\n  const psbt = coin.decodeTransactionFromPrebuild(params.txPrebuild);\n  if (!(psbt instanceof utxolib.bitgo.UtxoPsbt)) {\n    throw new Error('expected psbt to be an instance of UtxoPsbt');\n  }\n  const walletKeys = toBip32Triple(keychains);\n  const descriptorMap = getDescriptorMapFromWallet(wallet, walletKeys, getPolicyForEnv(params.wallet.bitgo.env));\n  return {\n    ...toBaseParsedTransactionOutputsFromPsbt(psbt, descriptorMap, recipients, psbt.network),\n    keychains,\n    keySignatures: getKeySignatures(wallet) ?? {},\n    customChange: undefined,\n    needsCustomChangeKeySignatureVerification: false,\n  };\n}\n"]}

package/dist/esm/transaction/descriptor/parseToAmountType.d.ts

@@ -0,0 +1,14 @@
+import { AbstractUtxoCoin, ParseTransactionOptions } from '../../abstractUtxoCoin';
+import { BaseOutput, BaseParsedTransaction } from '../types';
+import { IDescriptorWallet } from '../../descriptor/descriptorWallet';
+import { ParsedDescriptorTransaction } from './parse';
+type AmountType = 'number' | 'bigint' | 'string';
+export declare function toAmountType(v: number | bigint | string, t: AmountType): number | bigint | string;
+type AmountTypeOptions = {
+    amountTypeBaseOutput: AmountType;
+    amountTypeAggregate: AmountType;
+};
+export declare function parsedDescriptorTransactionToTNumber<TAmount extends number | bigint, TOutput>(obj: ParsedDescriptorTransaction<bigint>, params: AmountTypeOptions): BaseParsedTransaction<TAmount, TOutput>;
+export declare function parseToAmountType<TAmount extends number | bigint>(coin: AbstractUtxoCoin, wallet: IDescriptorWallet, params: ParseTransactionOptions<TAmount>): BaseParsedTransaction<TAmount, BaseOutput<string>>;
+export {};
+//# sourceMappingURL=parseToAmountType.d.ts.map

package/dist/esm/transaction/descriptor/parseToAmountType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseToAmountType.d.ts","sourceRoot":"","sources":["../../../../src/transaction/descriptor/parseToAmountType.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACnF,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAEtE,OAAO,EAAS,2BAA2B,EAAE,MAAM,SAAS,CAAC;AAE7D,KAAK,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEjD,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAYjG;AAED,KAAK,iBAAiB,GAAG;IACvB,oBAAoB,EAAE,UAAU,CAAC;IACjC,mBAAmB,EAAE,UAAU,CAAC;CACjC,CAAC;AAyCF,wBAAgB,oCAAoC,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EAAE,OAAO,EAC3F,GAAG,EAAE,2BAA2B,CAAC,MAAM,CAAC,EACxC,MAAM,EAAE,iBAAiB,GACxB,qBAAqB,CAAC,OAAO,EAAE,OAAO,CAAC,CAIzC;AAED,wBAAgB,iBAAiB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EAC/D,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,iBAAiB,EACzB,MAAM,EAAE,uBAAuB,CAAC,OAAO,CAAC,GACvC,qBAAqB,CAAC,OAAO,EAAE,UAAU,CAAC,MAAM,CAAC,CAAC,CAKpD"}