@bitgo-beta/abstract-utxo 1.6.1-alpha.44 → 1.6.1-alpha.441

package/dist/esm/transaction/fixedScript/signTransaction.js

@@ -0,0 +1,44 @@
+import assert from 'assert';
+import { isTriple } from '@bitgo-beta/sdk-core';
+import _ from 'lodash';
+import { bitgo } from '@bitgo-beta/utxo-lib';
+import { fixedScriptWallet } from '@bitgo/wasm-utxo';
+import { signLegacyTransaction } from './signLegacyTransaction';
+import { signPsbtWithMusig2Participant } from './signPsbt';
+import { signPsbtWithMusig2ParticipantWasm } from './signPsbtWasm';
+import { getReplayProtectionPubkeys } from './replayProtection';
+export async function signTransaction(coin, tx, signerKeychain, network, params) {
+    let isLastSignature = false;
+    if (_.isBoolean(params.isLastSignature)) {
+        // if build is called instead of buildIncomplete, no signature placeholders are left in the sig script
+        isLastSignature = params.isLastSignature;
+    }
+    if (tx instanceof bitgo.UtxoPsbt) {
+        return signPsbtWithMusig2Participant(coin, tx, signerKeychain, {
+            isLastSignature,
+            signingStep: params.signingStep,
+            walletId: params.walletId,
+        });
+    }
+    else if (tx instanceof fixedScriptWallet.BitGoPsbt) {
+        assert(params.pubs, 'pubs are required for fixed script signing');
+        assert(isTriple(params.pubs), 'pubs must be a triple');
+        const rootWalletKeys = fixedScriptWallet.RootWalletKeys.fromXpubs(params.pubs);
+        return signPsbtWithMusig2ParticipantWasm(coin, tx, signerKeychain, rootWalletKeys, {
+            replayProtection: {
+                publicKeys: getReplayProtectionPubkeys(network),
+            },
+            isLastSignature,
+            signingStep: params.signingStep,
+            walletId: params.walletId,
+        });
+    }
+    return signLegacyTransaction(tx, signerKeychain, {
+        isLastSignature,
+        signingStep: params.signingStep,
+        txInfo: params.txInfo,
+        pubs: params.pubs,
+        cosignerPub: params.cosignerPub,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/transaction/fixedScript/verifyTransaction.d.ts

@@ -0,0 +1,21 @@
+import { BitGoBase } from '@bitgo-beta/sdk-core';
+import { AbstractUtxoCoin, VerifyTransactionOptions } from '../../abstractUtxoCoin';
+/**
+ * Verify that a transaction prebuild complies with the original intention for fixed-script wallets
+ *
+ * This implementation handles transaction verification for traditional UTXO coins using fixed scripts
+ * (non-descriptor wallets). It validates keychains, signatures, outputs, and amounts.
+ *
+ * @param coin - The UTXO coin instance
+ * @param bitgo - BitGo API instance for network calls
+ * @param params - Verification parameters
+ * @param params.txParams - Transaction parameters passed to send
+ * @param params.txPrebuild - Prebuild object returned by server
+ * @param params.wallet - Wallet object to obtain keys to verify against
+ * @param params.verification - Verification options (disableNetworking, keychains, addresses)
+ * @param params.reqId - Optional request ID for logging
+ * @returns {boolean} True if verification passes
+ * @throws {TxIntentMismatchError} if transaction validation fails
+ */
+export declare function verifyTransaction<TNumber extends bigint | number>(coin: AbstractUtxoCoin, bitgo: BitGoBase, params: VerifyTransactionOptions<TNumber>): Promise<boolean>;
+//# sourceMappingURL=verifyTransaction.d.ts.map

package/dist/esm/transaction/fixedScript/verifyTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyTransaction.d.ts","sourceRoot":"","sources":["../../../../src/transaction/fixedScript/verifyTransaction.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAoC,MAAM,sBAAsB,CAAC;AAGnF,OAAO,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAsBpF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EACrE,IAAI,EAAE,gBAAgB,EACtB,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,wBAAwB,CAAC,OAAO,CAAC,GACxC,OAAO,CAAC,OAAO,CAAC,CAmJlB"}

package/dist/esm/transaction/fixedScript/verifyTransaction.js

@@ -0,0 +1,160 @@
+import buildDebug from 'debug';
+import _ from 'lodash';
+import BigNumber from 'bignumber.js';
+import { TxIntentMismatchError } from '@bitgo-beta/sdk-core';
+import * as utxolib from '@bitgo-beta/utxo-lib';
+import { verifyCustomChangeKeySignatures, verifyKeySignature, verifyUserPublicKey } from '../../verifyKey';
+import { getPsbtTxInputs, getTxInputs } from '../fetchInputs';
+const debug = buildDebug('bitgo:abstract-utxo:verifyTransaction');
+/**
+ * Get the maximum percentage limit for pay-as-you-go outputs
+ *
+ * @protected
+ */
+function getPayGoLimit(allowPaygoOutput) {
+    // allowing paygo outputs needs to be the default behavior, so only disallow paygo outputs if the
+    // relevant verification option is both set and false
+    if (!_.isNil(allowPaygoOutput) && !allowPaygoOutput) {
+        return 0;
+    }
+    // 150 basis points is the absolute permitted maximum if paygo outputs are allowed
+    return 0.015;
+}
+/**
+ * Verify that a transaction prebuild complies with the original intention for fixed-script wallets
+ *
+ * This implementation handles transaction verification for traditional UTXO coins using fixed scripts
+ * (non-descriptor wallets). It validates keychains, signatures, outputs, and amounts.
+ *
+ * @param coin - The UTXO coin instance
+ * @param bitgo - BitGo API instance for network calls
+ * @param params - Verification parameters
+ * @param params.txParams - Transaction parameters passed to send
+ * @param params.txPrebuild - Prebuild object returned by server
+ * @param params.wallet - Wallet object to obtain keys to verify against
+ * @param params.verification - Verification options (disableNetworking, keychains, addresses)
+ * @param params.reqId - Optional request ID for logging
+ * @returns {boolean} True if verification passes
+ * @throws {TxIntentMismatchError} if transaction validation fails
+ */
+export async function verifyTransaction(coin, bitgo, params) {
+    const { txParams, txPrebuild, wallet, verification = {}, reqId } = params;
+    const txExplanation = await TxIntentMismatchError.tryGetTxExplanation(coin, txPrebuild);
+    // Helper to throw TxIntentMismatchError with consistent context
+    const throwTxMismatch = (message) => {
+        throw new TxIntentMismatchError(message, reqId, [txParams], txPrebuild.txHex, txExplanation);
+    };
+    if (!_.isUndefined(verification.disableNetworking) && !_.isBoolean(verification.disableNetworking)) {
+        throw new TypeError('verification.disableNetworking must be a boolean');
+    }
+    const isPsbt = txPrebuild.txHex && utxolib.bitgo.isPsbt(txPrebuild.txHex);
+    if (isPsbt && txPrebuild.txInfo?.unspents) {
+        throw new Error('should not have unspents in txInfo for psbt');
+    }
+    const disableNetworking = !!verification.disableNetworking;
+    const parsedTransaction = await coin.parseTransaction({
+        txParams,
+        txPrebuild,
+        wallet,
+        verification,
+        reqId,
+    });
+    const keychains = parsedTransaction.keychains;
+    // verify that the claimed user public key corresponds to the wallet's user private key
+    let userPublicKeyVerified = false;
+    try {
+        // verify the user public key matches the private key - this will throw if there is no match
+        userPublicKeyVerified = verifyUserPublicKey(bitgo, { userKeychain: keychains.user, disableNetworking, txParams });
+    }
+    catch (e) {
+        debug('failed to verify user public key!', e);
+    }
+    // let's verify these keychains
+    const keySignatures = parsedTransaction.keySignatures;
+    if (!_.isEmpty(keySignatures)) {
+        const verify = (key, pub) => {
+            if (!keychains.user || !keychains.user.pub) {
+                throwTxMismatch('missing user keychain');
+            }
+            return verifyKeySignature({
+                userKeychain: keychains.user,
+                keychainToVerify: key,
+                keySignature: pub,
+            });
+        };
+        const isBackupKeySignatureValid = verify(keychains.backup, keySignatures.backupPub);
+        const isBitgoKeySignatureValid = verify(keychains.bitgo, keySignatures.bitgoPub);
+        if (!isBackupKeySignatureValid || !isBitgoKeySignatureValid) {
+            throw new Error('secondary public key signatures invalid');
+        }
+        debug('successfully verified backup and bitgo key signatures');
+    }
+    else if (!disableNetworking) {
+        // these keys were obtained online and their signatures were not verified
+        // this could be dangerous
+        console.log('unsigned keys obtained online are being used for address verification');
+    }
+    if (parsedTransaction.needsCustomChangeKeySignatureVerification) {
+        if (!keychains.user || !userPublicKeyVerified) {
+            throw new Error('transaction requires verification of user public key, but it was unable to be verified');
+        }
+        const customChangeKeySignaturesVerified = verifyCustomChangeKeySignatures(parsedTransaction, keychains.user);
+        if (!customChangeKeySignaturesVerified) {
+            throw new Error('transaction requires verification of custom change key signatures, but they were unable to be verified');
+        }
+        debug('successfully verified user public key and custom change key signatures');
+    }
+    const missingOutputs = parsedTransaction.missingOutputs;
+    if (missingOutputs.length !== 0) {
+        // there are some outputs in the recipients list that have not made it into the actual transaction
+        throwTxMismatch('expected outputs missing in transaction prebuild');
+    }
+    const intendedExternalSpend = parsedTransaction.explicitExternalSpendAmount;
+    // this is a limit we impose for the total value that is amended to the transaction beyond what was originally intended
+    const payAsYouGoLimit = new BigNumber(getPayGoLimit(verification.allowPaygoOutput)).multipliedBy(intendedExternalSpend.toString());
+    /*
+    Some explanation for why we're doing what we're doing:
+    Some customers will have an output to BitGo's PAYGo wallet added to their transaction, and we need to account for
+    it here. To protect someone tampering with the output to make it send more than it should to BitGo, we define a
+    threshold for the output's value above which we'll throw an error, because the paygo output should never be that
+    high.
+     */
+    // make sure that all the extra addresses are change addresses
+    // get all the additional external outputs the server added and calculate their values
+    const nonChangeAmount = new BigNumber(parsedTransaction.implicitExternalSpendAmount.toString());
+    debug('Intended spend is %s, Non-change amount is %s, paygo limit is %s', intendedExternalSpend.toString(), nonChangeAmount.toString(), payAsYouGoLimit.toString());
+    // There are two instances where we will get into this point here
+    if (nonChangeAmount.gt(payAsYouGoLimit)) {
+        if (isPsbt && parsedTransaction.customChange) {
+            // In the case that we have a custom change address on a wallet and we are building the transaction
+            // with a PSBT, we do not have the metadata to verify the address from the custom change wallet, nor
+            // can we fetch that information from the other wallet because we may not have the credentials. Therefore,
+            // we will not throw an error here, but we will log a warning.
+            debug(`cannot verify some of the addresses because it belongs to a separate wallet`);
+        }
+        else {
+            // the additional external outputs can only be BitGo's pay-as-you-go fee, but we cannot verify the wallet address
+            // there are some addresses that are outside the scope of intended recipients that are not change addresses
+            throwTxMismatch('prebuild attempts to spend to unintended external recipients');
+        }
+    }
+    const allOutputs = parsedTransaction.outputs;
+    if (!txPrebuild.txHex) {
+        throw new Error(`txPrebuild.txHex not set`);
+    }
+    const inputs = isPsbt
+        ? getPsbtTxInputs(txPrebuild.txHex, coin.network).map((v) => ({
+            ...v,
+            value: utxolib.bitgo.toTNumber(v.value, coin.amountType),
+        }))
+        : await getTxInputs({ txPrebuild, bitgo, coin, disableNetworking, reqId });
+    // coins (doge) that can exceed number limits (and thus will use bigint) will have the `valueString` field
+    const inputAmount = inputs.reduce((sum, i) => sum + BigInt(coin.amountType === 'bigint' ? i.valueString : i.value), BigInt(0));
+    const outputAmount = allOutputs.reduce((sum, o) => sum + BigInt(o.amount), BigInt(0));
+    const fee = inputAmount - outputAmount;
+    if (fee < 0) {
+        throw new Error(`attempting to spend ${outputAmount} satoshis, which exceeds the input amount (${inputAmount} satoshis) by ${-fee}`);
+    }
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"verifyTransaction.js","sourceRoot":"","sources":["../../../../src/transaction/fixedScript/verifyTransaction.ts"],"names":[],"mappings":"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","sourcesContent":["import buildDebug from 'debug';\nimport _ from 'lodash';\nimport BigNumber from 'bignumber.js';\nimport { BitGoBase, TxIntentMismatchError, IBaseCoin } from '@bitgo-beta/sdk-core';\nimport * as utxolib from '@bitgo-beta/utxo-lib';\n\nimport { AbstractUtxoCoin, VerifyTransactionOptions } from '../../abstractUtxoCoin';\nimport { Output, ParsedTransaction } from '../types';\nimport { verifyCustomChangeKeySignatures, verifyKeySignature, verifyUserPublicKey } from '../../verifyKey';\nimport { getPsbtTxInputs, getTxInputs } from '../fetchInputs';\n\nconst debug = buildDebug('bitgo:abstract-utxo:verifyTransaction');\n\n/**\n * Get the maximum percentage limit for pay-as-you-go outputs\n *\n * @protected\n */\nfunction getPayGoLimit(allowPaygoOutput?: boolean): number {\n  // allowing paygo outputs needs to be the default behavior, so only disallow paygo outputs if the\n  // relevant verification option is both set and false\n  if (!_.isNil(allowPaygoOutput) && !allowPaygoOutput) {\n    return 0;\n  }\n  // 150 basis points is the absolute permitted maximum if paygo outputs are allowed\n  return 0.015;\n}\n\n/**\n * Verify that a transaction prebuild complies with the original intention for fixed-script wallets\n *\n * This implementation handles transaction verification for traditional UTXO coins using fixed scripts\n * (non-descriptor wallets). It validates keychains, signatures, outputs, and amounts.\n *\n * @param coin - The UTXO coin instance\n * @param bitgo - BitGo API instance for network calls\n * @param params - Verification parameters\n * @param params.txParams - Transaction parameters passed to send\n * @param params.txPrebuild - Prebuild object returned by server\n * @param params.wallet - Wallet object to obtain keys to verify against\n * @param params.verification - Verification options (disableNetworking, keychains, addresses)\n * @param params.reqId - Optional request ID for logging\n * @returns {boolean} True if verification passes\n * @throws {TxIntentMismatchError} if transaction validation fails\n */\nexport async function verifyTransaction<TNumber extends bigint | number>(\n  coin: AbstractUtxoCoin,\n  bitgo: BitGoBase,\n  params: VerifyTransactionOptions<TNumber>\n): Promise<boolean> {\n  const { txParams, txPrebuild, wallet, verification = {}, reqId } = params;\n\n  const txExplanation = await TxIntentMismatchError.tryGetTxExplanation(coin as unknown as IBaseCoin, txPrebuild);\n\n  // Helper to throw TxIntentMismatchError with consistent context\n  const throwTxMismatch = (message: string): never => {\n    throw new TxIntentMismatchError(message, reqId, [txParams], txPrebuild.txHex, txExplanation);\n  };\n\n  if (!_.isUndefined(verification.disableNetworking) && !_.isBoolean(verification.disableNetworking)) {\n    throw new TypeError('verification.disableNetworking must be a boolean');\n  }\n  const isPsbt = txPrebuild.txHex && utxolib.bitgo.isPsbt(txPrebuild.txHex);\n  if (isPsbt && txPrebuild.txInfo?.unspents) {\n    throw new Error('should not have unspents in txInfo for psbt');\n  }\n  const disableNetworking = !!verification.disableNetworking;\n  const parsedTransaction: ParsedTransaction<TNumber> = await coin.parseTransaction<TNumber>({\n    txParams,\n    txPrebuild,\n    wallet,\n    verification,\n    reqId,\n  });\n\n  const keychains = parsedTransaction.keychains;\n\n  // verify that the claimed user public key corresponds to the wallet's user private key\n  let userPublicKeyVerified = false;\n  try {\n    // verify the user public key matches the private key - this will throw if there is no match\n    userPublicKeyVerified = verifyUserPublicKey(bitgo, { userKeychain: keychains.user, disableNetworking, txParams });\n  } catch (e) {\n    debug('failed to verify user public key!', e);\n  }\n\n  // let's verify these keychains\n  const keySignatures = parsedTransaction.keySignatures;\n  if (!_.isEmpty(keySignatures)) {\n    const verify = (key, pub) => {\n      if (!keychains.user || !keychains.user.pub) {\n        throwTxMismatch('missing user keychain');\n      }\n      return verifyKeySignature({\n        userKeychain: keychains.user as { pub: string },\n        keychainToVerify: key,\n        keySignature: pub,\n      });\n    };\n    const isBackupKeySignatureValid = verify(keychains.backup, keySignatures.backupPub);\n    const isBitgoKeySignatureValid = verify(keychains.bitgo, keySignatures.bitgoPub);\n    if (!isBackupKeySignatureValid || !isBitgoKeySignatureValid) {\n      throw new Error('secondary public key signatures invalid');\n    }\n    debug('successfully verified backup and bitgo key signatures');\n  } else if (!disableNetworking) {\n    // these keys were obtained online and their signatures were not verified\n    // this could be dangerous\n    console.log('unsigned keys obtained online are being used for address verification');\n  }\n\n  if (parsedTransaction.needsCustomChangeKeySignatureVerification) {\n    if (!keychains.user || !userPublicKeyVerified) {\n      throw new Error('transaction requires verification of user public key, but it was unable to be verified');\n    }\n    const customChangeKeySignaturesVerified = verifyCustomChangeKeySignatures(parsedTransaction, keychains.user);\n    if (!customChangeKeySignaturesVerified) {\n      throw new Error(\n        'transaction requires verification of custom change key signatures, but they were unable to be verified'\n      );\n    }\n    debug('successfully verified user public key and custom change key signatures');\n  }\n\n  const missingOutputs = parsedTransaction.missingOutputs;\n  if (missingOutputs.length !== 0) {\n    // there are some outputs in the recipients list that have not made it into the actual transaction\n    throwTxMismatch('expected outputs missing in transaction prebuild');\n  }\n\n  const intendedExternalSpend = parsedTransaction.explicitExternalSpendAmount;\n\n  // this is a limit we impose for the total value that is amended to the transaction beyond what was originally intended\n  const payAsYouGoLimit = new BigNumber(getPayGoLimit(verification.allowPaygoOutput)).multipliedBy(\n    intendedExternalSpend.toString()\n  );\n\n  /*\n  Some explanation for why we're doing what we're doing:\n  Some customers will have an output to BitGo's PAYGo wallet added to their transaction, and we need to account for\n  it here. To protect someone tampering with the output to make it send more than it should to BitGo, we define a\n  threshold for the output's value above which we'll throw an error, because the paygo output should never be that\n  high.\n   */\n\n  // make sure that all the extra addresses are change addresses\n  // get all the additional external outputs the server added and calculate their values\n  const nonChangeAmount = new BigNumber(parsedTransaction.implicitExternalSpendAmount.toString());\n\n  debug(\n    'Intended spend is %s, Non-change amount is %s, paygo limit is %s',\n    intendedExternalSpend.toString(),\n    nonChangeAmount.toString(),\n    payAsYouGoLimit.toString()\n  );\n\n  // There are two instances where we will get into this point here\n  if (nonChangeAmount.gt(payAsYouGoLimit)) {\n    if (isPsbt && parsedTransaction.customChange) {\n      // In the case that we have a custom change address on a wallet and we are building the transaction\n      // with a PSBT, we do not have the metadata to verify the address from the custom change wallet, nor\n      // can we fetch that information from the other wallet because we may not have the credentials. Therefore,\n      // we will not throw an error here, but we will log a warning.\n      debug(`cannot verify some of the addresses because it belongs to a separate wallet`);\n    } else {\n      // the additional external outputs can only be BitGo's pay-as-you-go fee, but we cannot verify the wallet address\n      // there are some addresses that are outside the scope of intended recipients that are not change addresses\n      throwTxMismatch('prebuild attempts to spend to unintended external recipients');\n    }\n  }\n\n  const allOutputs = parsedTransaction.outputs;\n  if (!txPrebuild.txHex) {\n    throw new Error(`txPrebuild.txHex not set`);\n  }\n  const inputs = isPsbt\n    ? getPsbtTxInputs(txPrebuild.txHex, coin.network).map((v) => ({\n        ...v,\n        value: utxolib.bitgo.toTNumber(v.value, coin.amountType),\n      }))\n    : await getTxInputs({ txPrebuild, bitgo, coin, disableNetworking, reqId });\n  // coins (doge) that can exceed number limits (and thus will use bigint) will have the `valueString` field\n  const inputAmount = inputs.reduce(\n    (sum: bigint, i) => sum + BigInt(coin.amountType === 'bigint' ? i.valueString : i.value),\n    BigInt(0)\n  );\n  const outputAmount = allOutputs.reduce((sum: bigint, o: Output) => sum + BigInt(o.amount), BigInt(0));\n  const fee = inputAmount - outputAmount;\n\n  if (fee < 0) {\n    throw new Error(\n      `attempting to spend ${outputAmount} satoshis, which exceeds the input amount (${inputAmount} satoshis) by ${-fee}`\n    );\n  }\n\n  return true;\n}\n"]}

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

@@ -0,0 +1,9 @@
+import * as utxolib from '@bitgo-beta/utxo-lib';
+/**
+ * We want to return the verification pubkey from our statics that has our
+ * verification pubkey.
+ * @param network
+ * @returns
+ */
+export declare function getPayGoVerificationPubkey(network: utxolib.Network): string | undefined;
+//# sourceMappingURL=getPayGoVerificationPubkey.d.ts.map

package/dist/esm/transaction/getPayGoVerificationPubkey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPayGoVerificationPubkey.d.ts","sourceRoot":"","sources":["../../../src/transaction/getPayGoVerificationPubkey.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAC;AAKhD;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,GAAG,MAAM,GAAG,SAAS,CAMvF"}

package/dist/esm/transaction/getPayGoVerificationPubkey.js

@@ -0,0 +1,17 @@
+import * as utxolib from '@bitgo-beta/utxo-lib';
+const BITGOPAYGOATTESTATIONPUBKEY = 'xpub6BKRgmCPX5oQiJgJ6Vq6BF8tDvZhwQki5dVVQohckK2ZJXtxj8K6M9pavLwt9piW33hZz17SWmG8QWsjJ1tHdde2Fs5UA3DFbApCtbdaGKn';
+/**
+ * We want to return the verification pubkey from our statics that has our
+ * verification pubkey.
+ * @param network
+ * @returns
+ */
+export function getPayGoVerificationPubkey(network) {
+    if (utxolib.isTestnet(network)) {
+        return BITGOPAYGOATTESTATIONPUBKEY;
+    }
+    else if (utxolib.isMainnet(network)) {
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0UGF5R29WZXJpZmljYXRpb25QdWJrZXkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHJhbnNhY3Rpb24vZ2V0UGF5R29WZXJpZmljYXRpb25QdWJrZXkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxzQkFBc0IsQ0FBQztBQUVoRCxNQUFNLDJCQUEyQixHQUMvQixpSEFBaUgsQ0FBQztBQUVwSDs7Ozs7R0FLRztBQUNILE1BQU0sVUFBVSwwQkFBMEIsQ0FBQyxPQUF3QjtJQUNqRSxJQUFJLE9BQU8sQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQztRQUMvQixPQUFPLDJCQUEyQixDQUFDO0lBQ3JDLENBQUM7U0FBTSxJQUFJLE9BQU8sQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQztRQUN0QyxPQUFPLFNBQVMsQ0FBQztJQUNuQixDQUFDO0FBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIHV0eG9saWIgZnJvbSAnQGJpdGdvLWJldGEvdXR4by1saWInO1xuXG5jb25zdCBCSVRHT1BBWUdPQVRURVNUQVRJT05QVUJLRVkgPVxuICAneHB1YjZCS1JnbUNQWDVvUWlKZ0o2VnE2QkY4dER2Wmh3UWtpNWRWVlFvaGNrSzJaSlh0eGo4SzZNOXBhdkx3dDlwaVczM2haejE3U1dtRzhRV3NqSjF0SGRkZTJGczVVQTNERmJBcEN0YmRhR0tuJztcblxuLyoqXG4gKiBXZSB3YW50IHRvIHJldHVybiB0aGUgdmVyaWZpY2F0aW9uIHB1YmtleSBmcm9tIG91ciBzdGF0aWNzIHRoYXQgaGFzIG91clxuICogdmVyaWZpY2F0aW9uIHB1YmtleS5cbiAqIEBwYXJhbSBuZXR3b3JrXG4gKiBAcmV0dXJuc1xuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0UGF5R29WZXJpZmljYXRpb25QdWJrZXkobmV0d29yazogdXR4b2xpYi5OZXR3b3JrKTogc3RyaW5nIHwgdW5kZWZpbmVkIHtcbiAgaWYgKHV0eG9saWIuaXNUZXN0bmV0KG5ldHdvcmspKSB7XG4gICAgcmV0dXJuIEJJVEdPUEFZR09BVFRFU1RBVElPTlBVQktFWTtcbiAgfSBlbHNlIGlmICh1dHhvbGliLmlzTWFpbm5ldChuZXR3b3JrKSkge1xuICAgIHJldHVybiB1bmRlZmluZWQ7XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,8 @@
+export * from './types';
+export * from './recipient';
+export { explainTx } from './explainTransaction';
+export { parseTransaction } from './parseTransaction';
+export { verifyTransaction } from './verifyTransaction';
+export * from './fetchInputs';
+export * as bip322 from './bip322';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transaction/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,cAAc,eAAe,CAAC;AAC9B,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC"}

package/dist/esm/transaction/index.js

@@ -0,0 +1,8 @@
+export * from './types';
+export * from './recipient';
+export { explainTx } from './explainTransaction';
+export { parseTransaction } from './parseTransaction';
+export { verifyTransaction } from './verifyTransaction';
+export * from './fetchInputs';
+export * as bip322 from './bip322';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHJhbnNhY3Rpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxhQUFhLENBQUM7QUFDNUIsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3hELGNBQWMsZUFBZSxDQUFDO0FBQzlCLE9BQU8sS0FBSyxNQUFNLE1BQU0sVUFBVSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG5leHBvcnQgKiBmcm9tICcuL3JlY2lwaWVudCc7XG5leHBvcnQgeyBleHBsYWluVHggfSBmcm9tICcuL2V4cGxhaW5UcmFuc2FjdGlvbic7XG5leHBvcnQgeyBwYXJzZVRyYW5zYWN0aW9uIH0gZnJvbSAnLi9wYXJzZVRyYW5zYWN0aW9uJztcbmV4cG9ydCB7IHZlcmlmeVRyYW5zYWN0aW9uIH0gZnJvbSAnLi92ZXJpZnlUcmFuc2FjdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL2ZldGNoSW5wdXRzJztcbmV4cG9ydCAqIGFzIGJpcDMyMiBmcm9tICcuL2JpcDMyMic7XG4iXX0=

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

@@ -0,0 +1,40 @@
+export type ComparableOutput<TValue> = {
+    script: Buffer;
+    value: TValue;
+};
+/** Actual outputs have fixed values. */
+export type ActualOutput = ComparableOutput<bigint>;
+/** Expected outputs can have a fixed value or 'max'. */
+export type ExpectedOutput = ComparableOutput<bigint | 'max'>;
+/**
+ * @param a
+ * @param b
+ * @returns whether the two outputs are equal. Outputs with value `max` are considered equal to any other output with the same script.
+ */
+export declare function matchingOutput<TValue>(a: ComparableOutput<TValue>, b: ComparableOutput<TValue>): boolean;
+/**
+ * @returns all outputs in the first array that are not in the second array.
+ * Outputs can occur more than once in each array.
+ * An output with value `max` is considered equal to any other output with the same script.
+ */
+export declare function outputDifference<A extends ActualOutput | ExpectedOutput, B extends ActualOutput | ExpectedOutput>(first: A[], second: B[]): A[];
+export type OutputDifferenceWithExpected<TActual extends ActualOutput, TExpected extends ExpectedOutput> = {
+    /** These are the external outputs that were expected and found in the transaction. */
+    explicitOutputs: TActual[];
+    /**
+     * These are the surprise external outputs that were not explicitly specified in the transaction.
+     * They can be PayGo fees.
+     */
+    implicitOutputs: TActual[];
+    /**
+     * These are the outputs that were expected to be in the transaction but were not found.
+     */
+    missingOutputs: TExpected[];
+};
+/**
+ * @param actualOutputs - external outputs in the transaction
+ * @param expectedOutputs - external outputs that were expected to be in the transaction
+ * @returns the difference between the actual and expected external outputs
+ */
+export declare function outputDifferencesWithExpected<TActual extends ActualOutput, TExpected extends ExpectedOutput>(actualOutputs: TActual[], expectedOutputs: TExpected[]): OutputDifferenceWithExpected<TActual, TExpected>;
+//# sourceMappingURL=outputDifference.d.ts.map

package/dist/esm/transaction/outputDifference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outputDifference.d.ts","sourceRoot":"","sources":["../../../src/transaction/outputDifference.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,CAAC,MAAM,IAAI;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,wCAAwC;AACxC,MAAM,MAAM,YAAY,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC;AAEpD,wDAAwD;AACxD,MAAM,MAAM,cAAc,GAAG,gBAAgB,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC;AAE9D;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,GAAG,OAAO,CAKxG;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,YAAY,GAAG,cAAc,EAAE,CAAC,SAAS,YAAY,GAAG,cAAc,EAC/G,KAAK,EAAE,CAAC,EAAE,EACV,MAAM,EAAE,CAAC,EAAE,GACV,CAAC,EAAE,CASL;AAED,MAAM,MAAM,4BAA4B,CAAC,OAAO,SAAS,YAAY,EAAE,SAAS,SAAS,cAAc,IAAI;IACzG,sFAAsF;IACtF,eAAe,EAAE,OAAO,EAAE,CAAC;IAC3B;;;OAGG;IACH,eAAe,EAAE,OAAO,EAAE,CAAC;IAC3B;;OAEG;IACH,cAAc,EAAE,SAAS,EAAE,CAAC;CAC7B,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,SAAS,YAAY,EAAE,SAAS,SAAS,cAAc,EAC1G,aAAa,EAAE,OAAO,EAAE,EACxB,eAAe,EAAE,SAAS,EAAE,GAC3B,4BAA4B,CAAC,OAAO,EAAE,SAAS,CAAC,CASlD"}

package/dist/esm/transaction/outputDifference.js

@@ -0,0 +1,42 @@
+/**
+ * @param a
+ * @param b
+ * @returns whether the two outputs are equal. Outputs with value `max` are considered equal to any other output with the same script.
+ */
+export function matchingOutput(a, b) {
+    if (a.value === 'max' || b.value === 'max') {
+        return a.script.equals(b.script);
+    }
+    return a.script.equals(b.script) && a.value === b.value;
+}
+/**
+ * @returns all outputs in the first array that are not in the second array.
+ * Outputs can occur more than once in each array.
+ * An output with value `max` is considered equal to any other output with the same script.
+ */
+export function outputDifference(first, second) {
+    first = first.slice();
+    for (const output of second) {
+        const index = first.findIndex((o) => matchingOutput(o, output));
+        if (index !== -1) {
+            first.splice(index, 1);
+        }
+    }
+    return first;
+}
+/**
+ * @param actualOutputs - external outputs in the transaction
+ * @param expectedOutputs - external outputs that were expected to be in the transaction
+ * @returns the difference between the actual and expected external outputs
+ */
+export function outputDifferencesWithExpected(actualOutputs, expectedOutputs) {
+    const implicitOutputs = outputDifference(actualOutputs, expectedOutputs);
+    const explicitOutputs = outputDifference(actualOutputs, implicitOutputs);
+    const missingOutputs = outputDifference(expectedOutputs, actualOutputs);
+    return {
+        explicitOutputs,
+        implicitOutputs,
+        missingOutputs,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,4 @@
+import { AbstractUtxoCoin, ParseTransactionOptions } from '../abstractUtxoCoin';
+import { ParsedTransaction } from './types';
+export declare function parseTransaction<TNumber extends bigint | number>(coin: AbstractUtxoCoin, params: ParseTransactionOptions<TNumber>): Promise<ParsedTransaction<TNumber>>;
+//# sourceMappingURL=parseTransaction.d.ts.map

package/dist/esm/transaction/parseTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseTransaction.d.ts","sourceRoot":"","sources":["../../../src/transaction/parseTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAGhF,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAI5C,wBAAsB,gBAAgB,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EACpE,IAAI,EAAE,gBAAgB,EACtB,MAAM,EAAE,uBAAuB,CAAC,OAAO,CAAC,GACvC,OAAO,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAMrC"}

package/dist/esm/transaction/parseTransaction.js

@@ -0,0 +1,12 @@
+import { isDescriptorWallet } from '../descriptor';
+import * as descriptor from './descriptor';
+import * as fixedScript from './fixedScript';
+export async function parseTransaction(coin, params) {
+    if (isDescriptorWallet(params.wallet)) {
+        return descriptor.parseToAmountType(coin, params.wallet, params);
+    }
+    else {
+        return fixedScript.parseTransaction(coin, params);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2VUcmFuc2FjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90cmFuc2FjdGlvbi9wYXJzZVRyYW5zYWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUduRCxPQUFPLEtBQUssVUFBVSxNQUFNLGNBQWMsQ0FBQztBQUMzQyxPQUFPLEtBQUssV0FBVyxNQUFNLGVBQWUsQ0FBQztBQUU3QyxNQUFNLENBQUMsS0FBSyxVQUFVLGdCQUFnQixDQUNwQyxJQUFzQixFQUN0QixNQUF3QztJQUV4QyxJQUFJLGtCQUFrQixDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDO1FBQ3RDLE9BQU8sVUFBVSxDQUFDLGlCQUFpQixDQUFDLElBQUksRUFBRSxNQUFNLENBQUMsTUFBTSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQ25FLENBQUM7U0FBTSxDQUFDO1FBQ04sT0FBTyxXQUFXLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQ3BELENBQUM7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQWJzdHJhY3RVdHhvQ29pbiwgUGFyc2VUcmFuc2FjdGlvbk9wdGlvbnMgfSBmcm9tICcuLi9hYnN0cmFjdFV0eG9Db2luJztcbmltcG9ydCB7IGlzRGVzY3JpcHRvcldhbGxldCB9IGZyb20gJy4uL2Rlc2NyaXB0b3InO1xuXG5pbXBvcnQgeyBQYXJzZWRUcmFuc2FjdGlvbiB9IGZyb20gJy4vdHlwZXMnO1xuaW1wb3J0ICogYXMgZGVzY3JpcHRvciBmcm9tICcuL2Rlc2NyaXB0b3InO1xuaW1wb3J0ICogYXMgZml4ZWRTY3JpcHQgZnJvbSAnLi9maXhlZFNjcmlwdCc7XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBwYXJzZVRyYW5zYWN0aW9uPFROdW1iZXIgZXh0ZW5kcyBiaWdpbnQgfCBudW1iZXI+KFxuICBjb2luOiBBYnN0cmFjdFV0eG9Db2luLFxuICBwYXJhbXM6IFBhcnNlVHJhbnNhY3Rpb25PcHRpb25zPFROdW1iZXI+XG4pOiBQcm9taXNlPFBhcnNlZFRyYW5zYWN0aW9uPFROdW1iZXI+PiB7XG4gIGlmIChpc0Rlc2NyaXB0b3JXYWxsZXQocGFyYW1zLndhbGxldCkpIHtcbiAgICByZXR1cm4gZGVzY3JpcHRvci5wYXJzZVRvQW1vdW50VHlwZShjb2luLCBwYXJhbXMud2FsbGV0LCBwYXJhbXMpO1xuICB9IGVsc2Uge1xuICAgIHJldHVybiBmaXhlZFNjcmlwdC5wYXJzZVRyYW5zYWN0aW9uKGNvaW4sIHBhcmFtcyk7XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,29 @@
+import * as utxolib from '@bitgo-beta/utxo-lib';
+/**
+ * Check if the address is a script recipient (starts with `scriptPubKey:`).
+ * @param address
+ */
+export declare function isScriptRecipient(address: string): boolean;
+/**
+ * An extended address is one that encodes either a regular address or a hex encoded script with the prefix `scriptPubKey:`.
+ * This function converts the extended address format to either a script or an address.
+ * @param extendedAddress
+ */
+export declare function fromExtendedAddressFormat(extendedAddress: string): {
+    address: string;
+} | {
+    script: string;
+};
+export declare function fromExtendedAddressFormatToScript(extendedAddress: string, network: utxolib.Network): Buffer;
+/**
+ * Convert a script or address to the extended address format.
+ * @param script
+ * @param network
+ * @returns if the script is an OP_RETURN script, then it will be prefixed with `scriptPubKey:`, otherwise it will be converted to an address.
+ */
+export declare function toExtendedAddressFormat(script: Buffer, network: utxolib.Network): string;
+export declare function assertValidTransactionRecipient(output: {
+    amount: bigint | number | string;
+    address?: string;
+}): void;
+//# sourceMappingURL=recipient.d.ts.map

package/dist/esm/transaction/recipient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recipient.d.ts","sourceRoot":"","sources":["../../../src/transaction/recipient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAC;AAIhD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,eAAe,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAK3G;AAED,wBAAgB,iCAAiC,CAAC,eAAe,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,GAAG,MAAM,CAM3G;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,GAAG,MAAM,CAIxF;AAED,wBAAgB,+BAA+B,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAUpH"}

package/dist/esm/transaction/recipient.js

@@ -0,0 +1,48 @@
+import * as utxolib from '@bitgo-beta/utxo-lib';
+const ScriptRecipientPrefix = 'scriptPubKey:';
+/**
+ * Check if the address is a script recipient (starts with `scriptPubKey:`).
+ * @param address
+ */
+export function isScriptRecipient(address) {
+    return address.toLowerCase().startsWith(ScriptRecipientPrefix.toLowerCase());
+}
+/**
+ * An extended address is one that encodes either a regular address or a hex encoded script with the prefix `scriptPubKey:`.
+ * This function converts the extended address format to either a script or an address.
+ * @param extendedAddress
+ */
+export function fromExtendedAddressFormat(extendedAddress) {
+    if (isScriptRecipient(extendedAddress)) {
+        return { script: extendedAddress.slice(ScriptRecipientPrefix.length) };
+    }
+    return { address: extendedAddress };
+}
+export function fromExtendedAddressFormatToScript(extendedAddress, network) {
+    const result = fromExtendedAddressFormat(extendedAddress);
+    if ('script' in result) {
+        return Buffer.from(result.script, 'hex');
+    }
+    return utxolib.addressFormat.toOutputScriptTryFormats(result.address, network);
+}
+/**
+ * Convert a script or address to the extended address format.
+ * @param script
+ * @param network
+ * @returns if the script is an OP_RETURN script, then it will be prefixed with `scriptPubKey:`, otherwise it will be converted to an address.
+ */
+export function toExtendedAddressFormat(script, network) {
+    return script[0] === utxolib.opcodes.OP_RETURN
+        ? `${ScriptRecipientPrefix}${script.toString('hex')}`
+        : utxolib.address.fromOutputScript(script, network);
+}
+export function assertValidTransactionRecipient(output) {
+    // In the case that this is an OP_RETURN output or another non-encodable scriptPubkey, we dont have an address.
+    // We will verify that the amount is zero, and if it isnt then we will throw an error.
+    if (!output.address || isScriptRecipient(output.address)) {
+        if (output.amount.toString() !== '0') {
+            throw new Error(`Only zero amounts allowed for non-encodeable scriptPubkeys: amount: ${output.amount}, address: ${output.address}`);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,6 @@
+import { BitGoBase } from '@bitgo-beta/sdk-core';
+import { AbstractUtxoCoin, SignTransactionOptions } from '../abstractUtxoCoin';
+export declare function signTransaction<TNumber extends number | bigint>(coin: AbstractUtxoCoin, bitgo: BitGoBase, params: SignTransactionOptions<TNumber>): Promise<{
+    txHex: string;
+}>;
+//# sourceMappingURL=signTransaction.d.ts.map

package/dist/esm/transaction/signTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signTransaction.d.ts","sourceRoot":"","sources":["../../../src/transaction/signTransaction.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAKjD,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAyB/E,wBAAsB,eAAe,CAAC,OAAO,SAAS,MAAM,GAAG,MAAM,EACnE,IAAI,EAAE,gBAAgB,EACtB,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,sBAAsB,CAAC,OAAO,CAAC,GACtC,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,CA2C5B"}