cashscript 0.11.4 → 0.12.0

package/dist/test/JestExtensions.js

@@ -5,13 +5,11 @@ expect.extend({
         loggerSpy.mockClear();
         // silence actual stdout output
         loggerSpy.mockImplementation(() => { });
+        // Run debug, ignoring any errors because we only care about the logs, even if the transaction fails
         try {
-            executeDebug(transaction);
-        }
-        catch (error) {
-            if (error instanceof OldTransactionBuilderError)
-                throw error;
+            transaction.debug();
         }
+        catch (error) { }
         // We concatenate all the logs into a single string - if no logs are present, we set received to undefined
         const receivedBase = loggerSpy.mock.calls.reduce((acc, [log]) => `${acc}\n${log}`, '').trim();
         const received = receivedBase === '' ? undefined : receivedBase;
@@ -43,14 +41,12 @@ expect.extend({
 expect.extend({
     toFailRequireWith(transaction, match) {
         try {
-            executeDebug(transaction);
+            transaction.debug();
             const matcherHint = this.utils.matcherHint('.toFailRequireWith', undefined, match.toString(), { isNot: this.isNot });
             const message = () => `${matcherHint}\n\nContract function did not fail a require statement.`;
             return { message, pass: false };
         }
         catch (transactionError) {
-            if (transactionError instanceof OldTransactionBuilderError)
-                throw transactionError;
             const matcherHint = this.utils.matcherHint('toFailRequireWith', 'received', 'expected', { isNot: this.isNot });
             const expectedText = `Expected pattern: ${this.isNot ? 'not ' : ''}${this.utils.printExpected(match)}`;
             const receivedText = `Received string: ${this.utils.printReceived(transactionError?.message ?? '')}`;
@@ -66,33 +62,16 @@ expect.extend({
     },
     toFailRequire(transaction) {
         try {
-            executeDebug(transaction);
+            transaction.debug();
             const message = () => 'Contract function did not fail a require statement.';
             return { message, pass: false };
         }
         catch (transactionError) {
-            if (transactionError instanceof OldTransactionBuilderError)
-                throw transactionError;
             const receivedText = `Received string: ${this.utils.printReceived(transactionError?.message ?? '')}`;
             const message = () => `Contract function failed a require statement.\n${receivedText}`;
             return { message, pass: true };
         }
     },
 });
-// Wrapper function with custom error in case people use it with the old transaction builder
-// This is a temporary solution until we fully remove the old transaction builder from the SDK
-const executeDebug = (transaction) => {
-    const debugResults = transaction.debug();
-    if (debugResults instanceof Promise) {
-        debugResults.catch(() => { });
-        throw new OldTransactionBuilderError();
-    }
-};
-class OldTransactionBuilderError extends Error {
-    constructor() {
-        super('The CashScript JestExtensions do not support the old transaction builder since v0.11.0. Please use the new TransactionBuilder class.');
-        this.name = 'OldTransactionBuilderError';
-    }
-}
 export {};
 //# sourceMappingURL=JestExtensions.js.map

package/dist/types/type-inference.d.ts

@@ -1,15 +1,17 @@
 import type SignatureTemplate from '../SignatureTemplate.js';
+type BytesType = Uint8Array | string;
+type SignatureType = SignatureTemplate | BytesType;
 type TypeMap = {
-    [k: `bytes${number}`]: Uint8Array | string;
+    [k: `bytes${number}`]: BytesType;
 } & {
-    byte: Uint8Array | string;
-    bytes: Uint8Array | string;
+    byte: BytesType;
+    bytes: BytesType;
     bool: boolean;
     int: bigint;
     string: string;
-    pubkey: Uint8Array | string;
-    sig: SignatureTemplate | Uint8Array | string;
-    datasig: Uint8Array | string;
+    pubkey: BytesType;
+    sig: SignatureType;
+    datasig: BytesType;
 };
 type ProcessParam<Param> = Param extends {
     type: infer Type;

package/dist/utils.d.ts

@@ -38,3 +38,4 @@ export declare const extendedStringify: (obj: any, spaces?: number) => string;
 export declare const zip: <T, U>(a: readonly T[], b: readonly U[]) => [T, U][];
 export declare const isFungibleTokenUtxo: (utxo: Utxo) => boolean;
 export declare const isNonTokenUtxo: (utxo: Utxo) => boolean;
+export declare const delay: (ms: number) => Promise<void>;

package/dist/utils.js

@@ -1,5 +1,5 @@
-import { cashAddressToLockingBytecode, decodeCashAddress, addressContentsToLockingBytecode, lockingBytecodeToCashAddress, binToHex, generateSigningSerializationBch, utf8ToBin, hexToBin, flattenBinArray, LockingBytecodeType, encodeTransactionOutput, isHex, bigIntToCompactUint, NonFungibleTokenCapability, bigIntToVmNumber, } from '@bitauth/libauth';
-import { encodeInt, hash160, hash256, sha256, Op, scriptToBytecode, } from '@cashscript/utils';
+import { cashAddressToLockingBytecode, decodeCashAddress, addressContentsToLockingBytecode, lockingBytecodeToCashAddress, binToHex, generateSigningSerializationBch, utf8ToBin, hexToBin, LockingBytecodeType, encodeTransactionOutput, isHex, bigIntToCompactUint, NonFungibleTokenCapability, bigIntToVmNumber, } from '@bitauth/libauth';
+import { encodeInt, hash160, hash256, sha256, Op, scriptToBytecode, encodeNullDataScript, } from '@cashscript/utils';
 import { Network, } from './interfaces.js';
 import { VERSION_SIZE, LOCKTIME_SIZE } from './constants.js';
 import { OutputSatoshisTooSmallError, OutputTokenAmountTooSmallError, TokensToNonTokenAddressError, UndefinedInputError, } from './Errors.js';
@@ -220,27 +220,6 @@ export function getNetworkPrefix(network) {
             return 'bitcoincash';
     }
 }
-// ////////////////////////////////////////////////////////////////////////////
-// For encoding OP_RETURN data (doesn't require BIP62.3 / MINIMALDATA)
-function encodeNullDataScript(chunks) {
-    return flattenBinArray(chunks.map((chunk) => {
-        if (typeof chunk === 'number') {
-            return new Uint8Array([chunk]);
-        }
-        const pushdataOpcode = getPushDataOpcode(chunk);
-        return new Uint8Array([...pushdataOpcode, ...chunk]);
-    }));
-}
-function getPushDataOpcode(data) {
-    const { byteLength } = data;
-    if (byteLength === 0)
-        return Uint8Array.from([0x4c, 0x00]);
-    if (byteLength < 76)
-        return Uint8Array.from([byteLength]);
-    if (byteLength < 256)
-        return Uint8Array.from([0x4c, byteLength]);
-    throw new Error('Pushdata too large');
-}
 const randomInt = () => BigInt(Math.floor(Math.random() * 10000));
 export const randomUtxo = (defaults) => ({
     ...{
@@ -290,4 +269,5 @@ export const extendedStringify = (obj, spaces) => JSON.stringify(obj, (_, v) =>
 export const zip = (a, b) => (Array.from(Array(Math.max(b.length, a.length)), (_, i) => [a[i], b[i]]));
 export const isFungibleTokenUtxo = (utxo) => (utxo.token !== undefined && utxo.token.amount > 0n && utxo.token.nft === undefined);
 export const isNonTokenUtxo = (utxo) => utxo.token === undefined;
+export const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashscript",
-  "version": "0.11.4",
+  "version": "0.12.0",
   "description": "Easily write and interact with Bitcoin Cash contracts",
   "keywords": [
     "bitcoin cash",
@@ -45,13 +45,10 @@
     "test": "NODE_OPTIONS='--experimental-vm-modules --no-warnings' jest"
   },
   "dependencies": {
-    "@bitauth/libauth": "^3.1.0-next.2",
-    "@cashscript/utils": "^0.11.4",
+    "@bitauth/libauth": "^3.1.0-next.8",
+    "@cashscript/utils": "^0.12.0",
     "@electrum-cash/network": "^4.1.3",
     "@mr-zwets/bchn-api-wrapper": "^1.0.1",
-    "@types/node": "^22.17.0",
-    "delay": "^6.0.0",
-    "fast-deep-equal": "^3.1.3",
     "pako": "^2.1.0",
     "semver": "^7.7.2"
   },
@@ -64,5 +61,5 @@
     "jest": "^29.7.0",
     "typescript": "^5.9.2"
   },
-  "gitHead": "d878d068b91ddc5a4ca1807376520ae451e4a0ed"
+  "gitHead": "dfa7ea1cfe1c369ab1dd9a919ab89b9a98331872"
 }

package/dist/LibauthTemplate.d.ts

@@ -1,32 +0,0 @@
-import { AbiFunction, AbiInput, Artifact } from '@cashscript/utils';
-import { WalletTemplate, WalletTemplateScenarioBytecode } from '@bitauth/libauth';
-import { Utxo, TokenDetails, LibauthTokenDetails, Output, SignatureAlgorithm, HashType } from './interfaces.js';
-import { Transaction } from './Transaction.js';
-import { EncodedFunctionArgument } from './Argument.js';
-import { Contract } from './Contract.js';
-interface BuildTemplateOptions {
-    transaction: Transaction;
-    transactionHex?: string;
-}
-export declare const buildTemplate: ({ transaction, transactionHex, }: BuildTemplateOptions) => Promise<WalletTemplate>;
-export declare const getBitauthUri: (template: WalletTemplate) => string;
-export declare const generateTemplateScenarioTransactionOutputLockingBytecode: (csOutput: Output, contract: Contract) => string | {};
-export declare const generateTemplateScenarioBytecode: (input: Utxo, inputIndex: number, p2pkhScriptNameTemplate: string, insertSlot?: boolean) => WalletTemplateScenarioBytecode | ["slot"];
-export declare const generateTemplateScenarioParametersValues: (types: readonly AbiInput[], encodedArgs: EncodedFunctionArgument[]) => Record<string, string>;
-export declare const generateTemplateScenarioParametersFunctionIndex: (abiFunction: AbiFunction, abi: readonly AbiFunction[]) => Record<string, string>;
-export declare const addHexPrefixExceptEmpty: (value: string) => string;
-export declare const generateTemplateScenarioKeys: (types: readonly AbiInput[], encodedArgs: EncodedFunctionArgument[]) => Record<string, string>;
-export declare const formatParametersForDebugging: (types: readonly AbiInput[], args: EncodedFunctionArgument[]) => string;
-export declare const getSignatureAlgorithmName: (signatureAlgorithm: SignatureAlgorithm) => string;
-export declare const getHashTypeName: (hashType: HashType) => string;
-export declare const formatBytecodeForDebugging: (artifact: Artifact) => string;
-export declare const serialiseTokenDetails: (token?: TokenDetails | LibauthTokenDetails) => LibauthTemplateTokenDetails | undefined;
-export interface LibauthTemplateTokenDetails {
-    amount: string;
-    category: string;
-    nft?: {
-        capability: 'none' | 'mutable' | 'minting';
-        commitment: string;
-    };
-}
-export {};

package/dist/LibauthTemplate.js

@@ -1,324 +0,0 @@
-import { bytecodeToScript, formatBitAuthScript, } from '@cashscript/utils';
-import { hexToBin, decodeTransaction, binToHex, binToBase64, utf8ToBin, isHex, } from '@bitauth/libauth';
-import { deflate } from 'pako';
-import { isUtxoP2PKH, SignatureAlgorithm, HashType, isUnlockableUtxo, isStandardUnlockableUtxo, } from './interfaces.js';
-import SignatureTemplate from './SignatureTemplate.js';
-import { addressToLockScript, extendedStringify, zip } from './utils.js';
-import { generateUnlockingScriptParams } from './advanced/LibauthTemplate.js';
-export const buildTemplate = async ({ transaction, transactionHex = undefined, // set this argument to prevent unnecessary call `transaction.build()`
- }) => {
-    const contract = transaction.contract;
-    const txHex = transactionHex ?? await transaction.build();
-    const template = {
-        $schema: 'https://ide.bitauth.com/authentication-template-v0.schema.json',
-        description: 'Imported from cashscript',
-        name: 'CashScript Generated Debugging Template',
-        supported: ['BCH_2025_05'],
-        version: 0,
-        entities: generateTemplateEntities(contract.artifact, transaction.abiFunction, transaction.encodedFunctionArgs),
-        scripts: generateTemplateScripts(contract.artifact, contract.addressType, transaction.abiFunction, transaction.encodedFunctionArgs, contract.encodedConstructorArgs),
-        scenarios: generateTemplateScenarios(contract, transaction, txHex, contract.artifact, transaction.abiFunction, transaction.encodedFunctionArgs, contract.encodedConstructorArgs),
-    };
-    transaction.inputs
-        .forEach((input, index) => {
-        if (!isUtxoP2PKH(input))
-            return;
-        const lockScriptName = `p2pkh_placeholder_lock_${index}`;
-        const unlockScriptName = `p2pkh_placeholder_unlock_${index}`;
-        const placeholderKeyName = `placeholder_key_${index}`;
-        const signatureAlgorithmName = getSignatureAlgorithmName(input.template.getSignatureAlgorithm());
-        const hashtypeName = getHashTypeName(input.template.getHashType(false));
-        const signatureString = `${placeholderKeyName}.${signatureAlgorithmName}.${hashtypeName}`;
-        template.entities[contract.name + '_parameters'].scripts.push(lockScriptName, unlockScriptName);
-        template.entities[contract.name + '_parameters'].variables = {
-            ...template.entities[contract.name + '_parameters'].variables,
-            [placeholderKeyName]: {
-                description: placeholderKeyName,
-                name: placeholderKeyName,
-                type: 'Key',
-            },
-        };
-        // add extra unlocking and locking script for P2PKH inputs spent alongside our contract
-        // this is needed for correct cross-references in the template
-        template.scripts[unlockScriptName] = {
-            name: unlockScriptName,
-            script: `<${signatureString}>\n<${placeholderKeyName}.public_key>`,
-            unlocks: lockScriptName,
-        };
-        template.scripts[lockScriptName] = {
-            lockingType: 'standard',
-            name: lockScriptName,
-            script: `OP_DUP\nOP_HASH160 <$(<${placeholderKeyName}.public_key> OP_HASH160\n)> OP_EQUALVERIFY\nOP_CHECKSIG`,
-        };
-    });
-    return template;
-};
-export const getBitauthUri = (template) => {
-    const base64toBase64Url = (base64) => base64.replace(/\+/g, '-').replace(/\//g, '_');
-    const payload = base64toBase64Url(binToBase64(deflate(utf8ToBin(extendedStringify(template)))));
-    return `https://ide.bitauth.com/import-template/${payload}`;
-};
-const generateTemplateEntities = (artifact, abiFunction, encodedFunctionArgs) => {
-    const functionParameters = Object.fromEntries(abiFunction.inputs.map((input, index) => ([
-        input.name,
-        {
-            description: `"${input.name}" parameter of function "${abiFunction.name}"`,
-            name: input.name,
-            type: encodedFunctionArgs[index] instanceof SignatureTemplate ? 'Key' : 'WalletData',
-        },
-    ])));
-    const constructorParameters = Object.fromEntries(artifact.constructorInputs.map((input) => ([
-        input.name,
-        {
-            description: `"${input.name}" parameter of this contract`,
-            name: input.name,
-            type: 'WalletData',
-        },
-    ])));
-    const entities = {
-        [artifact.contractName + '_parameters']: {
-            description: 'Contract creation and function parameters',
-            name: artifact.contractName + '_parameters',
-            scripts: [
-                artifact.contractName + '_lock',
-                artifact.contractName + '_unlock',
-            ],
-            variables: {
-                ...functionParameters,
-                ...constructorParameters,
-            },
-        },
-    };
-    // function_index is a special variable that indicates the function to execute
-    if (artifact.abi.length > 1) {
-        entities[artifact.contractName + '_parameters'].variables.function_index = {
-            description: 'Script function index to execute',
-            name: 'function_index',
-            type: 'WalletData',
-        };
-    }
-    return entities;
-};
-const generateTemplateScripts = (artifact, addressType, abiFunction, encodedFunctionArgs, encodedConstructorArgs) => {
-    // definition of locking scripts and unlocking scripts with their respective bytecode
-    return {
-        [artifact.contractName + '_unlock']: generateTemplateUnlockScript(artifact, abiFunction, encodedFunctionArgs),
-        [artifact.contractName + '_lock']: generateTemplateLockScript(artifact, addressType, encodedConstructorArgs),
-    };
-};
-const generateTemplateLockScript = (artifact, addressType, constructorArguments) => {
-    return {
-        lockingType: addressType,
-        name: artifact.contractName + '_lock',
-        script: [
-            `// "${artifact.contractName}" contract constructor parameters`,
-            formatParametersForDebugging(artifact.constructorInputs, constructorArguments),
-            '',
-            '// bytecode',
-            formatBytecodeForDebugging(artifact),
-        ].join('\n'),
-    };
-};
-const generateTemplateUnlockScript = (artifact, abiFunction, encodedFunctionArgs) => {
-    const functionIndex = artifact.abi.findIndex((func) => func.name === abiFunction.name);
-    const functionIndexString = artifact.abi.length > 1
-        ? ['// function index in contract', `<function_index> // int = <${functionIndex}>`, '']
-        : [];
-    return {
-        // this unlocking script must pass our only scenario
-        passes: [artifact.contractName + '_evaluate'],
-        name: artifact.contractName + '_unlock',
-        script: [
-            `// "${abiFunction.name}" function parameters`,
-            formatParametersForDebugging(abiFunction.inputs, encodedFunctionArgs),
-            '',
-            ...functionIndexString,
-        ].join('\n'),
-        unlocks: artifact.contractName + '_lock',
-    };
-};
-const generateTemplateScenarios = (contract, transaction, transactionHex, artifact, abiFunction, encodedFunctionArgs, encodedConstructorArgs) => {
-    const libauthTransaction = decodeTransaction(hexToBin(transactionHex));
-    if (typeof libauthTransaction === 'string')
-        throw Error(libauthTransaction);
-    const scenarios = {
-        // single scenario to spend out transaction under test given the CashScript parameters provided
-        [artifact.contractName + '_evaluate']: {
-            name: artifact.contractName + '_evaluate',
-            description: 'An example evaluation where this script execution passes.',
-            data: {
-                // encode values for the variables defined above in `entities` property
-                bytecode: {
-                    ...generateTemplateScenarioParametersFunctionIndex(abiFunction, artifact.abi),
-                    ...generateTemplateScenarioParametersValues(abiFunction.inputs, encodedFunctionArgs),
-                    ...generateTemplateScenarioParametersValues(artifact.constructorInputs, encodedConstructorArgs),
-                },
-                currentBlockHeight: 2,
-                currentBlockTime: Math.round(+new Date() / 1000),
-                keys: {
-                    privateKeys: generateTemplateScenarioKeys(abiFunction.inputs, encodedFunctionArgs),
-                },
-            },
-            transaction: generateTemplateScenarioTransaction(contract, libauthTransaction, transaction),
-            sourceOutputs: generateTemplateScenarioSourceOutputs(transaction),
-        },
-    };
-    return scenarios;
-};
-const generateTemplateScenarioTransaction = (contract, libauthTransaction, csTransaction) => {
-    const slotIndex = csTransaction.inputs.findIndex((input) => !isUtxoP2PKH(input));
-    const inputs = libauthTransaction.inputs.map((input, inputIndex) => {
-        const csInput = csTransaction.inputs[inputIndex];
-        return {
-            outpointIndex: input.outpointIndex,
-            outpointTransactionHash: binToHex(input.outpointTransactionHash),
-            sequenceNumber: input.sequenceNumber,
-            unlockingBytecode: generateTemplateScenarioBytecode(csInput, inputIndex, 'p2pkh_placeholder_unlock', inputIndex === slotIndex),
-        };
-    });
-    const locktime = libauthTransaction.locktime;
-    const outputs = libauthTransaction.outputs.map((output, index) => {
-        const csOutput = csTransaction.outputs[index];
-        return {
-            lockingBytecode: generateTemplateScenarioTransactionOutputLockingBytecode(csOutput, contract),
-            token: serialiseTokenDetails(output.token),
-            valueSatoshis: Number(output.valueSatoshis),
-        };
-    });
-    const version = libauthTransaction.version;
-    return { inputs, locktime, outputs, version };
-};
-export const generateTemplateScenarioTransactionOutputLockingBytecode = (csOutput, contract) => {
-    if (csOutput.to instanceof Uint8Array)
-        return binToHex(csOutput.to);
-    if ([contract.address, contract.tokenAddress].includes(csOutput.to))
-        return {};
-    return binToHex(addressToLockScript(csOutput.to));
-};
-const generateTemplateScenarioSourceOutputs = (csTransaction) => {
-    const slotIndex = csTransaction.inputs.findIndex((input) => !isUtxoP2PKH(input));
-    return csTransaction.inputs.map((input, inputIndex) => {
-        return {
-            lockingBytecode: generateTemplateScenarioBytecode(input, inputIndex, 'p2pkh_placeholder_lock', inputIndex === slotIndex),
-            valueSatoshis: Number(input.satoshis),
-            token: serialiseTokenDetails(input.token),
-        };
-    });
-};
-// Used for generating the locking / unlocking bytecode for source outputs and inputs
-export const generateTemplateScenarioBytecode = (input, inputIndex, p2pkhScriptNameTemplate, insertSlot) => {
-    if (insertSlot)
-        return ['slot'];
-    const p2pkhScriptName = `${p2pkhScriptNameTemplate}_${inputIndex}`;
-    const placeholderKeyName = `placeholder_key_${inputIndex}`;
-    // This is for P2PKH inputs in the old transaction builder (TODO: remove when we remove old transaction builder)
-    if (isUtxoP2PKH(input)) {
-        return {
-            script: p2pkhScriptName,
-            overrides: {
-                keys: {
-                    privateKeys: {
-                        [placeholderKeyName]: binToHex(input.template.privateKey),
-                    },
-                },
-            },
-        };
-    }
-    if (isUnlockableUtxo(input) && isStandardUnlockableUtxo(input)) {
-        return generateUnlockingScriptParams(input, p2pkhScriptNameTemplate, inputIndex);
-    }
-    // 'slot' means that we are currently evaluating this specific input,
-    // {} means that it is the same script type, but not being evaluated
-    return {};
-};
-export const generateTemplateScenarioParametersValues = (types, encodedArgs) => {
-    const typesAndArguments = zip(types, encodedArgs);
-    const entries = typesAndArguments
-        // SignatureTemplates are handled by the 'keys' object in the scenario
-        .filter(([, arg]) => !(arg instanceof SignatureTemplate))
-        .map(([input, arg]) => {
-        const encodedArgumentHex = binToHex(arg);
-        const prefixedEncodedArgument = addHexPrefixExceptEmpty(encodedArgumentHex);
-        return [input.name, prefixedEncodedArgument];
-    });
-    return Object.fromEntries(entries);
-};
-export const generateTemplateScenarioParametersFunctionIndex = (abiFunction, abi) => {
-    const functionIndex = abi.length > 1
-        ? abi.findIndex((func) => func.name === abiFunction.name)
-        : undefined;
-    return functionIndex !== undefined ? { function_index: functionIndex.toString() } : {};
-};
-export const addHexPrefixExceptEmpty = (value) => {
-    return value.length > 0 ? `0x${value}` : '';
-};
-export const generateTemplateScenarioKeys = (types, encodedArgs) => {
-    const typesAndArguments = zip(types, encodedArgs);
-    const entries = typesAndArguments
-        .filter(([, arg]) => arg instanceof SignatureTemplate)
-        .map(([input, arg]) => [input.name, binToHex(arg.privateKey)]);
-    return Object.fromEntries(entries);
-};
-export const formatParametersForDebugging = (types, args) => {
-    if (types.length === 0)
-        return '// none';
-    // We reverse the arguments because the order of the arguments in the bytecode is reversed
-    const typesAndArguments = zip(types, args).reverse();
-    return typesAndArguments.map(([input, arg]) => {
-        if (arg instanceof SignatureTemplate) {
-            const signatureAlgorithmName = getSignatureAlgorithmName(arg.getSignatureAlgorithm());
-            const hashtypeName = getHashTypeName(arg.getHashType(false));
-            return `<${input.name}.${signatureAlgorithmName}.${hashtypeName}> // ${input.type}`;
-        }
-        const typeStr = input.type === 'bytes' ? `bytes${arg.length}` : input.type;
-        // we output these values as pushdata, comment will contain the type and the value of the variable
-        // e.g. <timeout> // int = <0xa08601>
-        return `<${input.name}> // ${typeStr} = <${`0x${binToHex(arg)}`}>`;
-    }).join('\n');
-};
-export const getSignatureAlgorithmName = (signatureAlgorithm) => {
-    const signatureAlgorithmNames = {
-        [SignatureAlgorithm.SCHNORR]: 'schnorr_signature',
-        [SignatureAlgorithm.ECDSA]: 'ecdsa_signature',
-    };
-    return signatureAlgorithmNames[signatureAlgorithm];
-};
-export const getHashTypeName = (hashType) => {
-    const hashtypeNames = {
-        [HashType.SIGHASH_ALL]: 'all_outputs',
-        [HashType.SIGHASH_ALL | HashType.SIGHASH_ANYONECANPAY]: 'all_outputs_single_input',
-        [HashType.SIGHASH_ALL | HashType.SIGHASH_UTXOS]: 'all_outputs_all_utxos',
-        [HashType.SIGHASH_ALL | HashType.SIGHASH_ANYONECANPAY | HashType.SIGHASH_UTXOS]: 'all_outputs_single_input_INVALID_all_utxos',
-        [HashType.SIGHASH_SINGLE]: 'corresponding_output',
-        [HashType.SIGHASH_SINGLE | HashType.SIGHASH_ANYONECANPAY]: 'corresponding_output_single_input',
-        [HashType.SIGHASH_SINGLE | HashType.SIGHASH_UTXOS]: 'corresponding_output_all_utxos',
-        [HashType.SIGHASH_SINGLE | HashType.SIGHASH_ANYONECANPAY | HashType.SIGHASH_UTXOS]: 'corresponding_output_single_input_INVALID_all_utxos',
-        [HashType.SIGHASH_NONE]: 'no_outputs',
-        [HashType.SIGHASH_NONE | HashType.SIGHASH_ANYONECANPAY]: 'no_outputs_single_input',
-        [HashType.SIGHASH_NONE | HashType.SIGHASH_UTXOS]: 'no_outputs_all_utxos',
-        [HashType.SIGHASH_NONE | HashType.SIGHASH_ANYONECANPAY | HashType.SIGHASH_UTXOS]: 'no_outputs_single_input_INVALID_all_utxos',
-    };
-    return hashtypeNames[hashType];
-};
-export const formatBytecodeForDebugging = (artifact) => {
-    if (!artifact.debug) {
-        return artifact.bytecode
-            .split(' ')
-            .map((asmElement) => (isHex(asmElement) ? `<0x${asmElement}>` : asmElement))
-            .join('\n');
-    }
-    return formatBitAuthScript(bytecodeToScript(hexToBin(artifact.debug.bytecode)), artifact.debug.sourceMap, artifact.source);
-};
-export const serialiseTokenDetails = (token) => {
-    if (!token)
-        return undefined;
-    return {
-        amount: token.amount.toString(),
-        category: token.category instanceof Uint8Array ? binToHex(token.category) : token.category,
-        nft: token.nft ? {
-            capability: token.nft.capability,
-            commitment: token.nft.commitment instanceof Uint8Array ? binToHex(token.nft.commitment) : token.nft.commitment,
-        } : undefined,
-    };
-};
-//# sourceMappingURL=LibauthTemplate.js.map

package/dist/Transaction.d.ts

@@ -1,45 +0,0 @@
-import { WalletTemplate } from '@bitauth/libauth';
-import { AbiFunction } from '@cashscript/utils';
-import { Utxo, Output, Recipient, TokenDetails, TransactionDetails, Unlocker } from './interfaces.js';
-import SignatureTemplate from './SignatureTemplate.js';
-import { Contract } from './Contract.js';
-import { DebugResults } from './debugging.js';
-import { EncodedFunctionArgument } from './Argument.js';
-export declare class Transaction {
-    contract: Contract;
-    private unlocker;
-    abiFunction: AbiFunction;
-    encodedFunctionArgs: EncodedFunctionArgument[];
-    private selector?;
-    inputs: Utxo[];
-    outputs: Output[];
-    private sequence;
-    private locktime;
-    private feePerByte;
-    private hardcodedFee;
-    private minChange;
-    private tokenChange;
-    constructor(contract: Contract, unlocker: Unlocker, abiFunction: AbiFunction, encodedFunctionArgs: EncodedFunctionArgument[], selector?: number | undefined);
-    from(input: Utxo): this;
-    from(inputs: Utxo[]): this;
-    fromP2PKH(input: Utxo, template: SignatureTemplate): this;
-    fromP2PKH(inputs: Utxo[], template: SignatureTemplate): this;
-    to(to: string, amount: bigint, token?: TokenDetails): this;
-    to(outputs: Recipient[]): this;
-    withOpReturn(chunks: string[]): this;
-    withAge(age: number): this;
-    withTime(time: number): this;
-    withHardcodedFee(hardcodedFee: bigint): this;
-    withFeePerByte(feePerByte: number): this;
-    withMinChange(minChange: bigint): this;
-    withoutChange(): this;
-    withoutTokenChange(): this;
-    build(): Promise<string>;
-    send(): Promise<TransactionDetails>;
-    send(raw: true): Promise<string>;
-    debug(): Promise<DebugResults>;
-    bitauthUri(): Promise<string>;
-    getLibauthTemplate(): Promise<WalletTemplate>;
-    private getTxDetails;
-    private setInputsAndOutputs;
-}