tbc-tx-parser 0.1.7 → 0.1.9

package/dist/render-transaction-description.d.ts

@@ -0,0 +1,8 @@
+import type { DecodeDisplayOptions, DecodeTxRawResult } from './types.js';
+/**
+ * Render a transaction description from an existing public decode result.
+ * This is a pure display operation: it does not parse txraw, fetch prevouts,
+ * mutate the result, or reconsider protocol classification.
+ */
+export declare function renderTransactionDescription(result: DecodeTxRawResult, options?: DecodeDisplayOptions): string;
+//# sourceMappingURL=render-transaction-description.d.ts.map

package/dist/render-transaction-description.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-transaction-description.d.ts","sourceRoot":"","sources":["../src/render-transaction-description.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AAkBpB;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,iBAAiB,EACzB,OAAO,GAAE,oBAAyB,UAmBnC"}

package/dist/render-transaction-description.js

@@ -0,0 +1,32 @@
+import { buildStandardClassificationDescription } from './result/classification-description.js';
+function validateDisplayOptions(options) {
+    if (options?.tbcUnit !== undefined &&
+        options.tbcUnit !== 'satoshi' &&
+        options.tbcUnit !== 'tbc') {
+        throw new Error('Invalid display.tbcUnit; expected "satoshi" or "tbc"');
+    }
+}
+function classificationType(classification) {
+    if (classification.protocol === 'unknown')
+        return 'unknown';
+    return `${classification.protocol}.${classification.action}`;
+}
+/**
+ * Render a transaction description from an existing public decode result.
+ * This is a pure display operation: it does not parse txraw, fetch prevouts,
+ * mutate the result, or reconsider protocol classification.
+ */
+export function renderTransactionDescription(result, options = {}) {
+    validateDisplayOptions(options);
+    if (result.classification.conformance !== 'standard') {
+        return result.classification.description;
+    }
+    return buildStandardClassificationDescription(classificationType(result.classification), result.classification.description, {
+        inputs: result.chain.inputs,
+        outputs: result.chain.outputs,
+        assetFlows: result.assetFlows,
+        feeSatoshis: result.chain.fee?.satoshis,
+        tbcUnit: options.tbcUnit,
+    });
+}
+//# sourceMappingURL=render-transaction-description.js.map

package/dist/render-transaction-description.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-transaction-description.js","sourceRoot":"","sources":["../src/render-transaction-description.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,sCAAsC,EAAE,MAAM,wCAAwC,CAAC;AAEhG,SAAS,sBAAsB,CAAC,OAAyC;IACvE,IACE,OAAO,EAAE,OAAO,KAAK,SAAS;QAC9B,OAAO,CAAC,OAAO,KAAK,SAAS;QAC7B,OAAO,CAAC,OAAO,KAAK,KAAK,EACzB,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;IAC1E,CAAC;AACH,CAAC;AAED,SAAS,kBAAkB,CAAC,cAAyC;IACnE,IAAI,cAAc,CAAC,QAAQ,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IAC5D,OAAO,GAAG,cAAc,CAAC,QAAQ,IAAI,cAAc,CAAC,MAAM,EAAqB,CAAC;AAClF,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,4BAA4B,CAC1C,MAAyB,EACzB,UAAgC,EAAE;IAElC,sBAAsB,CAAC,OAAO,CAAC,CAAC;IAEhC,IAAI,MAAM,CAAC,cAAc,CAAC,WAAW,KAAK,UAAU,EAAE,CAAC;QACrD,OAAO,MAAM,CAAC,cAAc,CAAC,WAAW,CAAC;IAC3C,CAAC;IAED,OAAO,sCAAsC,CAC3C,kBAAkB,CAAC,MAAM,CAAC,cAAc,CAAC,EACzC,MAAM,CAAC,cAAc,CAAC,WAAW,EACjC;QACE,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM;QAC3B,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,OAAO;QAC7B,UAAU,EAAE,MAAM,CAAC,UAAU;QAC7B,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,QAAQ;QACvC,OAAO,EAAE,OAAO,CAAC,OAAO;KACzB,CACF,CAAC;AACJ,CAAC"}

package/dist/result/classification-description.d.ts

@@ -0,0 +1,11 @@
+import type { AssetFlow, DecodedInput, DecodedOutput, ProtocolDetails, PublicDecodedInput, PublicDecodedOutput, TbcDisplayUnit, TransactionType } from '../types.js';
+export interface ClassificationDescriptionFacts {
+    assetFlows?: AssetFlow[];
+    inputs: Array<DecodedInput | PublicDecodedInput>;
+    outputs: Array<DecodedOutput | PublicDecodedOutput>;
+    feeSatoshis?: number;
+    tbcUnit?: TbcDisplayUnit;
+    protocolDetails?: ProtocolDetails;
+}
+export declare function buildStandardClassificationDescription(type: TransactionType, fallback: string, facts: ClassificationDescriptionFacts): string;
+//# sourceMappingURL=classification-description.d.ts.map

package/dist/result/classification-description.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classification-description.d.ts","sourceRoot":"","sources":["../../src/result/classification-description.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,YAAY,EACZ,aAAa,EACb,eAAe,EACf,kBAAkB,EAClB,mBAAmB,EACnB,cAAc,EACd,eAAe,EAChB,MAAM,aAAa,CAAC;AAKrB,MAAM,WAAW,8BAA8B;IAC7C,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;IACzB,MAAM,EAAE,KAAK,CAAC,YAAY,GAAG,kBAAkB,CAAC,CAAC;IACjD,OAAO,EAAE,KAAK,CAAC,aAAa,GAAG,mBAAmB,CAAC,CAAC;IACpD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC;AAyoBD,wBAAgB,sCAAsC,CACpD,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,8BAA8B,UAqBtC"}

package/dist/result/classification-description.js

@@ -0,0 +1,570 @@
+import { SATOSHIS_PER_TBC } from '../constants/chain.js';
+import { getMultiSigAddress, getSignatureAndPublicKeyCount } from '../utils/multi-sig.js';
+import { formatTokenRawAmount } from '../utils/token-amount.js';
+function commaInteger(value) {
+    const [integer = '0', decimal] = value.split('.');
+    const grouped = integer.replace(/\B(?=(\d{3})+(?!\d))/gu, ',');
+    return decimal ? `${grouped}.${decimal}` : grouped;
+}
+function trimDecimal(value) {
+    return value.includes('.') ? value.replace(/0+$/u, '').replace(/\.$/u, '') : value;
+}
+function formatNativeAmount(satoshis, unit = 'satoshi', fixedTbcDecimals = false) {
+    if (unit === 'satoshi') {
+        return `${commaInteger(satoshis.toString())} ${satoshis === 1n ? 'satoshi' : 'satoshis'}`;
+    }
+    const negative = satoshis < 0n;
+    const absolute = negative ? -satoshis : satoshis;
+    const scale = BigInt(SATOSHIS_PER_TBC);
+    const integer = absolute / scale;
+    const fraction = (absolute % scale).toString().padStart(6, '0');
+    const displayedFraction = fixedTbcDecimals ? fraction : fraction.replace(/0+$/u, '');
+    const unsigned = displayedFraction ? `${integer}.${displayedFraction}` : integer.toString();
+    return `${commaInteger(`${negative ? '-' : ''}${unsigned}`)} TBC`;
+}
+function cleanLabel(value, fallback) {
+    const normalized = value?.replace(/\s+/gu, ' ').trim();
+    if (!normalized)
+        return fallback;
+    return normalized.length > 40 ? `${normalized.slice(0, 37)}...` : normalized;
+}
+function amountKey(flow) {
+    return [
+        flow.asset.type,
+        'contractId' in flow.asset ? flow.asset.contractId : undefined,
+        'collectionId' in flow.asset ? flow.asset.collectionId : undefined,
+        'symbol' in flow.asset ? flow.asset.symbol : undefined,
+        'decimal' in flow.asset ? flow.asset.decimal : undefined,
+    ].join('|');
+}
+function summarizeAmounts(flows, tbcUnit = 'satoshi') {
+    const groups = new Map();
+    flows.forEach((flow) => {
+        if (!('amount' in flow) || !flow.amount)
+            return;
+        const key = amountKey(flow);
+        groups.set(key, [...(groups.get(key) ?? []), flow]);
+    });
+    return [...groups.values()].map((group) => {
+        const first = group[0];
+        if (first.asset.type === 'tbc') {
+            const satoshis = group.reduce((total, flow) => total + BigInt('amount' in flow && flow.amount && 'satoshis' in flow.amount ? flow.amount.satoshis : 0), 0n);
+            return {
+                assetType: 'tbc',
+                symbol: 'TBC',
+                text: formatNativeAmount(satoshis, tbcUnit),
+            };
+        }
+        const raw = group.reduce((total, flow) => total + BigInt('amount' in flow && flow.amount && 'raw' in flow.amount ? flow.amount.raw : 0), 0n);
+        const decimal = 'decimal' in first.asset
+            ? first.asset.decimal ?? ('amount' in first && first.amount && 'decimal' in first.amount ? first.amount.decimal : 0)
+            : 0;
+        const display = trimDecimal(formatTokenRawAmount(raw, decimal ?? 0));
+        const symbol = cleanLabel('symbol' in first.asset ? first.asset.symbol : undefined, 'tokens');
+        return {
+            assetType: first.asset.type,
+            symbol,
+            text: `${commaInteger(display)} ${symbol}${first.asset.type === 'ftlp' ? ' liquidity tokens' : ''}`,
+        };
+    });
+}
+function amountText(flows, fallback, tbcUnit = 'satoshi') {
+    const summaries = summarizeAmounts(flows, tbcUnit);
+    if (!summaries.length)
+        return fallback;
+    if (summaries.length === 1)
+        return summaries[0].text;
+    if (summaries.length === 2)
+        return `${summaries[0].text} and ${summaries[1].text}`;
+    return `${summaries.slice(0, -1).map((item) => item.text).join(', ')}, and ${summaries.at(-1).text}`;
+}
+function isMultisigAddress(address, facts) {
+    return facts.outputs.some((output) => output.address === address &&
+        (output.script.type === 'MULTISIG' || ('scriptKind' in output && output.scriptKind === 'multisig'))) || facts.inputs.some((input) => input.prevout?.address === address && input.prevout.script.type === 'MULTISIG');
+}
+function addressIdentity(address, facts) {
+    return {
+        key: `address:${address}`,
+        kind: isMultisigAddress(address, facts) ? 'multisig' : 'address',
+        value: address,
+    };
+}
+function endpointIdentities(endpoint, facts) {
+    if (!endpoint)
+        return [];
+    if (endpoint.poolId)
+        return [{ key: `pool:${endpoint.poolId}`, kind: 'pool', value: endpoint.poolId }];
+    if (endpoint.address)
+        return [addressIdentity(endpoint.address, facts)];
+    if (endpoint.addresses?.length) {
+        return [...new Set(endpoint.addresses)].map((address) => addressIdentity(address, facts));
+    }
+    if (endpoint.hash)
+        return [{ key: `hash:${endpoint.hash}`, kind: 'hash', value: endpoint.hash }];
+    if (endpoint.txid !== undefined || endpoint.vout !== undefined) {
+        return [{ key: `outpoint:${endpoint.txid ?? ''}:${endpoint.vout ?? ''}`, kind: 'outpoint' }];
+    }
+    if (endpoint.outpoints?.length) {
+        return endpoint.outpoints.map((outpoint) => ({
+            key: `outpoint:${outpoint.txid}:${outpoint.vout}`,
+            kind: 'outpoint',
+        }));
+    }
+    if (endpoint.script?.hex || endpoint.script?.asm) {
+        return [{ key: `script:${endpoint.script.hex ?? endpoint.script.asm}`, kind: 'script' }];
+    }
+    return [];
+}
+function summarizeDestinations(flows, facts, direction = 'to') {
+    const identities = new Map();
+    let complete = flows.length > 0;
+    for (const flow of flows) {
+        const endpoint = direction === 'to' ? flow.to : flow.from;
+        const values = endpointIdentities(endpoint, facts);
+        if (!values.length)
+            complete = false;
+        values.forEach((value) => identities.set(value.key, value));
+    }
+    return { complete, identities: [...identities.values()] };
+}
+function destinationGroupPhrase(kind, count, other) {
+    if (kind === 'address') {
+        if (count === 1)
+            return other ? 'another address' : 'an address';
+        return `${count} ${other ? 'other ' : ''}addresses`;
+    }
+    if (kind === 'multisig') {
+        if (count === 1)
+            return 'a multisignature wallet';
+        return `${count} multisignature wallets`;
+    }
+    if (kind === 'pool') {
+        if (count === 1)
+            return 'a liquidity pool';
+        return `${count} liquidity pools`;
+    }
+    if (count === 1)
+        return other ? 'another destination' : 'a destination';
+    return `${count} ${other ? 'other ' : ''}destinations`;
+}
+function singleDestinationPhrase(identity) {
+    if (identity.kind === 'address' && identity.value)
+        return `address ${identity.value}`;
+    if (identity.kind === 'multisig' && identity.value)
+        return `multisignature wallet ${identity.value}`;
+    if (identity.kind === 'pool' && identity.value)
+        return `liquidity pool ${identity.value}`;
+    if (identity.kind === 'hash' && identity.value)
+        return `destination hash ${identity.value}`;
+    if (identity.kind === 'script')
+        return 'an unrecognized script destination';
+    return 'a destination';
+}
+function joinPhrases(values) {
+    if (values.length <= 1)
+        return values[0] ?? '';
+    if (values.length === 2)
+        return `${values[0]} and ${values[1]}`;
+    return `${values.slice(0, -1).join(', ')}, and ${values.at(-1)}`;
+}
+function destinationPhrase(summary, other) {
+    if (!summary.complete || !summary.identities.length) {
+        return other ? 'other destinations' : 'destinations';
+    }
+    if (summary.identities.length === 1) {
+        return singleDestinationPhrase(summary.identities[0]);
+    }
+    const groups = new Map();
+    summary.identities.forEach((identity) => groups.set(identity.kind, (groups.get(identity.kind) ?? 0) + 1));
+    if (groups.has('hash') || groups.has('script') || groups.has('outpoint')) {
+        return destinationGroupPhrase('outpoint', summary.identities.length, other);
+    }
+    const phrase = joinPhrases([...groups.entries()].map(([kind, count]) => destinationGroupPhrase(kind, count, other)));
+    return groups.size > 1 ? `${summary.identities.length} destinations: ${phrase}` : phrase;
+}
+function sendClause(flows, facts, fallback, origin) {
+    const destinations = summarizeDestinations(flows, facts);
+    const destination = destinationPhrase(destinations, true);
+    const originClause = origin ? ` ${origin}` : '';
+    const amount = amountText(flows, fallback, facts.tbcUnit);
+    if (destinations.complete && destinations.identities.length > 1) {
+        return `Sends a total of ${amount}${originClause} to ${destination}`;
+    }
+    return `Sends ${amount}${originClause} to ${destination}`;
+}
+function actionToDestinationClause(action, flows, facts, fallback, other = false) {
+    const destinations = summarizeDestinations(flows, facts);
+    const amount = amountText(flows, fallback, facts.tbcUnit);
+    const total = destinations.complete && destinations.identities.length > 1 ? 'a total of ' : '';
+    return `${action} ${total}${amount} to ${destinationPhrase(destinations, other)}`;
+}
+function internalTransferClauses(flows, facts) {
+    const sources = summarizeDestinations(flows, facts, 'from');
+    const targets = summarizeDestinations(flows, facts);
+    const scope = sources.complete && sources.identities.length ? sources : targets;
+    const kinds = new Set(scope.identities.map((identity) => identity.kind));
+    const count = scope.identities.length;
+    if (scope.complete && count === 1) {
+        const identity = scope.identities[0];
+        if (identity.kind === 'address' && identity.value) {
+            return [`Internal transfer at address ${identity.value}`, 'no funds were sent to another address'];
+        }
+        if (identity.kind === 'multisig' && identity.value) {
+            return [`Internal transfer in multisignature wallet ${identity.value}`, 'no funds were sent elsewhere'];
+        }
+        if (identity.kind === 'pool' && identity.value) {
+            return [`Internal transfer in liquidity pool ${identity.value}`, 'no funds were sent elsewhere'];
+        }
+        if (identity.kind === 'hash' && identity.value) {
+            return [`Internal transfer at destination hash ${identity.value}`, 'no funds were sent elsewhere'];
+        }
+        return ['Internal transfer at the original destination', 'no funds were sent elsewhere'];
+    }
+    if (scope.complete && count > 1 && kinds.size === 1 && kinds.has('address')) {
+        return ['Transfer within the original addresses', 'no funds were sent outside those addresses'];
+    }
+    if (scope.complete && count > 1 && kinds.size === 1 && kinds.has('multisig')) {
+        return ['Transfer within the original multisignature wallets', 'no funds were sent outside those wallets'];
+    }
+    return ['Transfer within the original destinations', 'no funds were sent outside those destinations'];
+}
+function feeClause(facts) {
+    if (facts.feeSatoshis === undefined)
+        return undefined;
+    return `network fee: ${formatNativeAmount(BigInt(facts.feeSatoshis), facts.tbcUnit, true)}`;
+}
+function sentence(clauses) {
+    const values = clauses.filter((value) => Boolean(value));
+    if (!values.length)
+        return '';
+    return `${values.join('; ')}.`;
+}
+function flowsFor(flows, purpose, assetTypes) {
+    return flows.filter((flow) => flow.purpose === purpose && (!assetTypes || assetTypes.includes(flow.asset.type)));
+}
+function scriptAsmContains(asm, value) {
+    if (asm === undefined)
+        return false;
+    const searchable = typeof asm === 'string' ? asm : `${asm.prefix} ${asm.suffix}`;
+    return typeof value === 'string' ? searchable.includes(value) : value.test(searchable);
+}
+function poolFlows(flows, direction, assetTypes) {
+    return flows.filter((flow) => {
+        const endpoint = direction === 'to' ? flow.to : flow.from;
+        return Boolean(endpoint?.poolId) && (!assetTypes || assetTypes.includes(flow.asset.type));
+    });
+}
+function ftCodeInputCount(inputs) {
+    return inputs.reduce((count, input) => {
+        if (!input.prevout?.associatedTape?.script.data?.ftTape)
+            return count;
+        return count + ('compression' in input ? input.compression?.count ?? 1 : 1);
+    }, 0);
+}
+function materialSecondaryTbcFlows(facts) {
+    return flowsFor(facts.assetFlows ?? [], 'transfer', ['tbc']).filter((flow) => {
+        const address = flow.to?.address;
+        const satoshis = 'amount' in flow && flow.amount && 'satoshis' in flow.amount
+            ? flow.amount.satoshis
+            : undefined;
+        if (!address || satoshis === undefined)
+            return false;
+        return facts.outputs.some((output) => output.address === address &&
+            output.satoshis === satoshis &&
+            !scriptAsmContains(output.script.asm, 'OP_RETURN'));
+    });
+}
+function secondaryTbcClause(facts) {
+    const transfers = materialSecondaryTbcFlows(facts);
+    if (!transfers.length)
+        return undefined;
+    const description = sendClause(transfers, facts, 'native TBC');
+    return `also ${description.charAt(0).toLowerCase()}${description.slice(1)}`;
+}
+function describeNativeTransfer(facts) {
+    const flows = facts.assetFlows ?? [];
+    const transfers = flowsFor(flows, 'transfer', ['tbc']);
+    const self = flowsFor(flows, 'self', ['tbc']);
+    if (!transfers.length && self.length) {
+        return sentence([
+            ...internalTransferClauses(self, facts),
+            feeClause(facts),
+        ]);
+    }
+    return sentence([
+        sendClause(transfers, facts, 'native TBC'),
+        feeClause(facts),
+    ]);
+}
+function describeFungible(type, facts, assetType) {
+    const flows = facts.assetFlows ?? [];
+    const tokenFlows = flows.filter((flow) => flow.asset.type === assetType);
+    const mint = flowsFor(tokenFlows, 'mint');
+    const transfers = flowsFor(tokenFlows, 'transfer');
+    const self = flowsFor(tokenFlows, 'self');
+    const fallback = `${assetType === 'stablecoin' ? 'StableCoin' : 'FT'} tokens`;
+    if (type.endsWith('.mint')) {
+        return sentence([
+            actionToDestinationClause('Mints', mint, facts, fallback),
+            secondaryTbcClause(facts),
+            feeClause(facts),
+        ]);
+    }
+    if (type.endsWith('.merge')) {
+        const inputCount = ftCodeInputCount(facts.inputs);
+        return sentence([
+            `Combines ${inputCount || 'multiple'} token balances into a single balance of ${amountText(self, fallback, facts.tbcUnit)}`,
+            secondaryTbcClause(facts),
+            feeClause(facts),
+        ]);
+    }
+    return sentence([
+        sendClause(transfers, facts, fallback),
+        secondaryTbcClause(facts),
+        feeClause(facts),
+    ]);
+}
+function nftLabel(flow) {
+    if (!flow || (flow.asset.type !== 'nft' && flow.asset.type !== 'nftCollection'))
+        return 'NFT';
+    return `${cleanLabel(flow.asset.name ?? flow.asset.symbol, 'unnamed')} NFT`;
+}
+function nftAssetName(flow) {
+    if (!flow || (flow.asset.type !== 'nft' && flow.asset.type !== 'nftCollection'))
+        return undefined;
+    return flow.asset.name;
+}
+function describeNft(type, facts) {
+    const flows = facts.assetFlows ?? [];
+    const nftFlows = flows.filter((flow) => flow.asset.type === 'nft' || flow.asset.type === 'nftCollection');
+    const primary = nftFlows[0];
+    if (type === 'nft.collectionMint') {
+        const movement = facts.protocolDetails?.nft?.actions.find((action) => action.action === 'mintCollection');
+        const collectionTape = facts.outputs
+            .map((output) => output.script.data?.collectionTape)
+            .find((tape) => tape !== undefined);
+        const slots = movement?.action === 'mintCollection' ? movement.supply : collectionTape?.supply;
+        const collectionName = movement?.action === 'mintCollection'
+            ? movement.collectionName
+            : collectionTape?.collectionName ?? nftAssetName(primary);
+        return sentence([
+            `Creates the ${cleanLabel(collectionName, 'unnamed')} NFT collection${slots === undefined ? '' : ` with ${commaInteger(String(slots))} mint slots`}`,
+            secondaryTbcClause(facts),
+            feeClause(facts),
+        ]);
+    }
+    if (type === 'nft.mint') {
+        return sentence([
+            `Mints the ${nftLabel(primary)} to ${destinationPhrase(summarizeDestinations(nftFlows, facts), false)}`,
+            secondaryTbcClause(facts),
+            feeClause(facts),
+        ]);
+    }
+    return sentence([
+        `Transfers the ${nftLabel(primary)} to ${destinationPhrase(summarizeDestinations(primary ? [primary] : [], facts), true)}`,
+        secondaryTbcClause(facts),
+        feeClause(facts),
+    ]);
+}
+function parseMultiSigTape(value) {
+    if (!value || value.length % 2 !== 0 || !/^[0-9a-f]+$/iu.test(value))
+        return undefined;
+    try {
+        const parsed = JSON.parse(Buffer.from(value, 'hex').toString('utf8'));
+        if (!parsed || typeof parsed !== 'object')
+            return undefined;
+        const candidate = parsed;
+        if (typeof candidate.address !== 'string' || !Array.isArray(candidate.pubkeys))
+            return undefined;
+        if (!candidate.pubkeys.every((pubkey) => typeof pubkey === 'string' && /^(?:02|03)[0-9a-f]{64}$/iu.test(pubkey))) {
+            return undefined;
+        }
+        return { address: candidate.address, pubkeys: candidate.pubkeys };
+    }
+    catch {
+        return undefined;
+    }
+}
+function multisigCreationClause(transfers, facts) {
+    const outputs = facts.outputs.filter((output) => output.script.type === 'MULTISIG' && typeof output.address === 'string');
+    const tapeOutputs = facts.outputs.filter((output) => output.script.data?.codeType === 'MTape');
+    if (outputs.length !== 1 || tapeOutputs.length !== 1)
+        return undefined;
+    const output = outputs[0];
+    const tape = parseMultiSigTape(tapeOutputs[0].script.data?.publicKeyHash);
+    if (!tape || tape.address !== output.address)
+        return undefined;
+    try {
+        const { signatureCount, publicKeyCount } = getSignatureAndPublicKeyCount(tape.address);
+        if (publicKeyCount !== tape.pubkeys.length)
+            return undefined;
+        if (getMultiSigAddress(tape.pubkeys, signatureCount, publicKeyCount) !== tape.address)
+            return undefined;
+        const participantMarkerCount = facts.outputs.filter((candidate) => candidate.script.type === 'P2PKH' &&
+            scriptAsmContains(candidate.script.asm, /(?:^|\s)OP_RETURN\s+6d756c7469736967(?:\s|$)/iu)).length;
+        if (participantMarkerCount !== publicKeyCount)
+            return undefined;
+        const funding = transfers.filter((flow) => flow.to?.address === tape.address || flow.to?.addresses?.includes(tape.address));
+        if (!funding.length)
+            return undefined;
+        return `Creates and funds a ${signatureCount}-of-${publicKeyCount} multisignature wallet ${tape.address} with ${amountText(funding, 'native TBC', facts.tbcUnit)}`;
+    }
+    catch {
+        return undefined;
+    }
+}
+function describeMultisig(facts) {
+    const flows = facts.assetFlows ?? [];
+    const transfers = flowsFor(flows, 'transfer', ['tbc']);
+    const spendsMultisig = facts.inputs.some((input) => input.prevout?.script.type === 'MULTISIG');
+    const creation = multisigCreationClause(transfers, facts);
+    const source = summarizeDestinations(transfers, facts, 'from');
+    return sentence([
+        creation ?? sendClause(transfers, facts, 'native TBC', spendsMultisig ? `from ${destinationPhrase(source, false)}` : undefined),
+        feeClause(facts),
+    ]);
+}
+function describePiggyBank(type, facts) {
+    const flows = facts.assetFlows ?? [];
+    const movement = facts.protocolDetails?.piggyBank?.actions[0];
+    if (type === 'piggyBank.freeze') {
+        const locked = flowsFor(flows, 'lock', ['tbc']);
+        const publicPiggyBank = facts.outputs
+            .map((output) => output.script.data?.piggyBank)
+            .find((piggyBank) => piggyBank !== undefined);
+        const lockTime = movement?.lockTime ?? publicPiggyBank?.lockTime;
+        return sentence([
+            `Locks ${amountText(locked, 'native TBC', facts.tbcUnit)} in PiggyBank${lockTime === undefined ? '' : ` until block ${commaInteger(String(lockTime))}`}`,
+            feeClause(facts),
+        ]);
+    }
+    const released = flowsFor(flows, 'release', ['tbc']);
+    return sentence([
+        `Withdraws ${amountText(released, 'native TBC', facts.tbcUnit)} from PiggyBank after maturity`,
+        feeClause(facts),
+    ]);
+}
+function exchangeAmountText(flows, facts) {
+    const summaries = summarizeAmounts(flows, facts.tbcUnit);
+    if (summaries.length === 2)
+        return `${summaries[0].text} for ${summaries[1].text}`;
+    return amountText(flows, 'the traded assets', facts.tbcUnit);
+}
+function describeOrderBook(type, facts) {
+    const flows = facts.assetFlows ?? [];
+    const locked = flowsFor(flows, 'lock');
+    const released = flowsFor(flows, 'release');
+    const transferred = flowsFor(flows, 'transfer');
+    if (type === 'orderBook.placeBuy' || type === 'orderBook.placeSell') {
+        return sentence([
+            `Places a ${type === 'orderBook.placeBuy' ? 'buy' : 'sell'} order using ${amountText(locked, 'the required asset', facts.tbcUnit)}`,
+            feeClause(facts),
+        ]);
+    }
+    if (type === 'orderBook.cancelBuy' || type === 'orderBook.cancelSell') {
+        return sentence([
+            `Cancels a ${type === 'orderBook.cancelBuy' ? 'buy' : 'sell'} order and releases ${amountText(released, 'the locked asset', facts.tbcUnit)}`,
+            feeClause(facts),
+        ]);
+    }
+    if (type === 'orderBook.match') {
+        return sentence([
+            `Matches a buy and sell order, exchanging ${exchangeAmountText(transferred, facts)}`,
+            feeClause(facts),
+        ]);
+    }
+    return sentence([
+        `Updates an order while keeping ${amountText(locked, 'its asset', facts.tbcUnit)} locked`,
+        feeClause(facts),
+    ]);
+}
+function describePoolNft(type, facts) {
+    const flows = facts.assetFlows ?? [];
+    const intoPool = poolFlows(flows, 'to');
+    const fromPool = poolFlows(flows, 'from');
+    const lpMinted = flowsFor(flows, 'mint', ['ftlp']);
+    const lpSpent = intoPool.filter((flow) => flow.asset.type === 'ftlp');
+    const selfTokens = flowsFor(flows, 'self', ['ft', 'ftlp']);
+    const burned = flowsFor(flows, 'burn', ['ftlp']);
+    const sentToBurnAddress = flowsFor(flows, 'transfer', ['ftlp']);
+    const createdPoolFlow = flows.find((flow) => flow.asset.type === 'nft' && flow.asset.subtype === 'poolNft');
+    const createdPoolId = createdPoolFlow?.asset.type === 'nft' && createdPoolFlow.asset.subtype === 'poolNft'
+        ? createdPoolFlow.asset.contractId
+        : undefined;
+    const poolTarget = intoPool.length
+        ? destinationPhrase(summarizeDestinations(intoPool, facts), false)
+        : fromPool.length
+            ? destinationPhrase(summarizeDestinations(fromPool, facts, 'from'), false)
+            : 'a liquidity pool';
+    switch (type) {
+        case 'poolNft.init':
+            return sentence([`Starts ${poolTarget} with ${amountText(intoPool, 'its starting assets', facts.tbcUnit)}`, feeClause(facts)]);
+        case 'poolNft.increaseLiquidity':
+            return sentence([
+                `Adds ${amountText(intoPool.filter((flow) => flow.asset.type !== 'ftlp'), 'assets', facts.tbcUnit)} to ${poolTarget}`,
+                lpMinted.length ? `receives ${amountText(lpMinted, 'liquidity tokens', facts.tbcUnit)}` : undefined,
+                feeClause(facts),
+            ]);
+        case 'poolNft.consumeLiquidity':
+            return sentence([
+                `Removes liquidity from ${poolTarget} by redeeming ${amountText(lpSpent, 'liquidity tokens', facts.tbcUnit)}`,
+                `receives ${amountText(fromPool.filter((flow) => flow.asset.type !== 'ftlp'), 'the underlying assets', facts.tbcUnit)}`,
+                feeClause(facts),
+            ]);
+        case 'poolNft.swapTbcToFt':
+            return sentence([
+                `Swaps ${amountText(intoPool.filter((flow) => flow.asset.type === 'tbc'), 'native TBC', facts.tbcUnit)} for ${amountText(fromPool.filter((flow) => flow.asset.type === 'ft'), 'FT tokens', facts.tbcUnit)} in ${poolTarget}`,
+                feeClause(facts),
+            ]);
+        case 'poolNft.swapFtToTbc':
+            return sentence([
+                `Swaps ${amountText(intoPool.filter((flow) => flow.asset.type === 'ft'), 'FT tokens', facts.tbcUnit)} for ${amountText(fromPool.filter((flow) => flow.asset.type === 'tbc'), 'native TBC', facts.tbcUnit)} in ${poolTarget}`,
+                feeClause(facts),
+            ]);
+        case 'poolNft.mergeFtInPool':
+            return sentence([`Combines token balances held by ${poolTarget} into ${amountText(selfTokens, 'FT tokens', facts.tbcUnit)}`, feeClause(facts)]);
+        case 'poolNft.mergeFtLp':
+            return sentence([`Combines liquidity-token balances into ${amountText(selfTokens, 'liquidity tokens', facts.tbcUnit)}`, feeClause(facts)]);
+        case 'poolNft.burnFtLp':
+            return sentence([
+                `Burns ${amountText(burned.length ? burned : sentToBurnAddress.length ? sentToBurnAddress : lpSpent, 'liquidity tokens', facts.tbcUnit)}`,
+                feeClause(facts),
+            ]);
+        default:
+            return sentence([
+                createdPoolId ? `Creates liquidity pool ${createdPoolId}` : 'Creates a liquidity pool',
+                feeClause(facts),
+            ]);
+    }
+}
+export function buildStandardClassificationDescription(type, fallback, facts) {
+    if (!facts.assetFlows?.length && !type.startsWith('poolNft.'))
+        return fallback;
+    if (type === 'tbc.transfer')
+        return describeNativeTransfer(facts);
+    if (type === 'tbc.coinbase') {
+        const minted = flowsFor(facts.assetFlows ?? [], 'mint', ['tbc']);
+        return sentence([
+            `Creates ${amountText(minted, 'native TBC', facts.tbcUnit)} as block rewards for ${destinationPhrase(summarizeDestinations(minted, facts), false)}`,
+        ]);
+    }
+    if (type === 'tbc.multisig')
+        return describeMultisig(facts);
+    if (type.startsWith('ft.'))
+        return describeFungible(type, facts, 'ft');
+    if (type.startsWith('stablecoin.') && type !== 'stablecoin.bootstrap')
+        return describeFungible(type, facts, 'stablecoin');
+    if (type === 'stablecoin.bootstrap') {
+        return sentence(['Creates the certificate used to issue a StableCoin', feeClause(facts)]);
+    }
+    if (type.startsWith('nft.'))
+        return describeNft(type, facts);
+    if (type.startsWith('piggyBank.'))
+        return describePiggyBank(type, facts);
+    if (type.startsWith('orderBook.'))
+        return describeOrderBook(type, facts);
+    if (type.startsWith('poolNft.'))
+        return describePoolNft(type, facts);
+    return fallback;
+}
+//# sourceMappingURL=classification-description.js.map