cashscript 0.9.1 → 0.10.0-next.0

package/dist/{Contract.d.ts → src/Contract.d.ts}

@@ -1,9 +1,11 @@
-import { Artifact } from '@cashscript/utils';
+import { Artifact, Script } from '@cashscript/utils';
 import { Transaction } from './Transaction.js';
 import { Argument } from './Argument.js';
 import { Unlocker, ContractOptions, Utxo } from './interfaces.js';
+import NetworkProvider from './network/NetworkProvider.js';
 export declare class Contract {
-    private artifact;
+    artifact: Artifact;
+    constructorArgs: Argument[];
     private options?;
     name: string;
     address: string;
@@ -13,9 +15,9 @@ export declare class Contract {
     opcount: number;
     functions: Record<string, ContractFunction>;
     unlock: Record<string, ContractUnlocker>;
-    private redeemScript;
-    private provider;
-    private addressType;
+    redeemScript: Script;
+    provider: NetworkProvider;
+    addressType: 'p2sh20' | 'p2sh32';
     constructor(artifact: Artifact, constructorArgs: Argument[], options?: ContractOptions | undefined);
     getBalance(): Promise<bigint>;
     getUtxos(): Promise<Utxo[]>;

package/dist/{Contract.js → src/Contract.js}

@@ -8,6 +8,7 @@ import { ElectrumNetworkProvider } from './network/index.js';
 export class Contract {
     constructor(artifact, constructorArgs, options) {
         this.artifact = artifact;
+        this.constructorArgs = constructorArgs;
         this.options = options;
         this.provider = this.options?.provider ?? new ElectrumNetworkProvider();
         this.addressType = this.options?.addressType ?? 'p2sh32';
@@ -73,7 +74,8 @@ export class Contract {
             // Encode passed args (this also performs type checking)
             const encodedArgs = args
                 .map((arg, i) => encodeArgument(arg, abiFunction.inputs[i].type));
-            return new Transaction(this.address, this.provider, this.redeemScript, abiFunction, encodedArgs, selector);
+            const unlocker = this.createUnlocker(abiFunction, selector)(...args);
+            return new Transaction(this, unlocker, abiFunction, encodedArgs, selector);
         };
     }
     createUnlocker(abiFunction, selector) {
@@ -82,14 +84,22 @@ export class Contract {
             const encodedArgs = args
                 .map((arg, i) => encodeArgument(arg, abiFunction.inputs[i].type));
             const generateUnlockingBytecode = ({ transaction, sourceOutputs, inputIndex }) => {
+                // TODO: Remove old-style covenant code for v1.0 release
+                let covenantHashType = -1;
                 const completeArgs = encodedArgs.map((arg) => {
                     if (!(arg instanceof SignatureTemplate))
                         return arg;
+                    // First signature is used for sighash preimage (maybe not the best way)
+                    if (covenantHashType < 0)
+                        covenantHashType = arg.getHashType();
                     const preimage = createSighashPreimage(transaction, sourceOutputs, inputIndex, bytecode, arg.getHashType());
                     const sighash = hash256(preimage);
                     return arg.generateSignature(sighash);
                 });
-                const unlockingBytecode = createInputScript(this.redeemScript, completeArgs, selector);
+                const preimage = abiFunction.covenant
+                    ? createSighashPreimage(transaction, sourceOutputs, inputIndex, bytecode, covenantHashType)
+                    : undefined;
+                const unlockingBytecode = createInputScript(this.redeemScript, completeArgs, selector, preimage);
                 return unlockingBytecode;
             };
             const generateLockingBytecode = () => addressToLockScript(this.address);

package/dist/{Errors.d.ts → src/Errors.d.ts}

@@ -10,8 +10,8 @@ export declare class TokensToNonTokenAddressError extends Error {
 }
 export declare class FailedTransactionError extends Error {
     reason: string;
-    meep?: string | undefined;
-    constructor(reason: string, meep?: string | undefined);
+    debugStr?: string | undefined;
+    constructor(reason: string, debugStr?: string | undefined);
 }
 export declare class FailedRequireError extends FailedTransactionError {
 }

package/dist/{Errors.js → src/Errors.js}

@@ -14,10 +14,10 @@ export class TokensToNonTokenAddressError extends Error {
     }
 }
 export class FailedTransactionError extends Error {
-    constructor(reason, meep) {
-        super(`Transaction failed with reason: ${reason}${meep ? `\n${meep}` : ''}`);
+    constructor(reason, debugStr) {
+        super(`Transaction failed with reason: ${reason}${debugStr ? `\n\n${debugStr}` : ''}`);
         this.reason = reason;
-        this.meep = meep;
+        this.debugStr = debugStr;
     }
 }
 export class FailedRequireError extends FailedTransactionError {

package/dist/src/LibauthTemplate.d.ts

@@ -0,0 +1,12 @@
+import { Artifact } from '@cashscript/utils';
+import { AuthenticationTemplate, AuthenticationProgramStateBCHCHIPs } from '@bitauth/libauth';
+import { Transaction } from './Transaction.js';
+export declare const stringify: (any: any, spaces?: number | undefined) => string;
+export declare const buildTemplate: ({ transaction, transactionHex, }: {
+    transaction: Transaction;
+    transactionHex?: string | undefined;
+}) => Promise<AuthenticationTemplate>;
+export declare const getBitauthUri: (template: AuthenticationTemplate) => string;
+export declare const evaluateTemplate: (template: AuthenticationTemplate) => boolean;
+export declare type DebugResult = AuthenticationProgramStateBCHCHIPs[];
+export declare const debugTemplate: (template: AuthenticationTemplate, artifact: Artifact) => DebugResult;

package/dist/src/LibauthTemplate.js

@@ -0,0 +1,472 @@
+import { Op, PrimitiveType, bytecodeToScript, decodeBool, decodeInt, decodeString, formatLibauthScript, } from '@cashscript/utils';
+import { hash160, hexToBin, decodeTransaction, binToHex, authenticationTemplateToCompilerConfiguration, createCompiler, createVirtualMachineBCHCHIPs, binToBase64, utf8ToBin, isHex, AuthenticationErrorCommon, } from '@bitauth/libauth';
+import { deflate } from 'pako';
+import { isUtxoP2PKH, } from '../src/interfaces.js';
+import { encodeArgument as csEncodeArgument } from './Argument.js';
+import { toRegExp } from './utils.js';
+// all bitauth variables must be in snake case
+const snakeCase = (str) => (str
+    && str
+        .match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g)
+        .map((s) => s.toLowerCase())
+        .join('_'));
+const merge = (array) => array.reduce((prev, cur) => ({
+    ...prev,
+    ...{ [Object.keys(cur)[0]]: cur[Object.keys(cur)[0]] },
+}), {});
+const encodeArgument = (argument, typeStr) => {
+    if (typeStr === PrimitiveType.INT && argument === 0n) {
+        return Uint8Array.from([0]);
+    }
+    return csEncodeArgument(argument, typeStr);
+};
+// stringify version which can serialize otherwise unsupported types
+export const stringify = (any, spaces) => JSON.stringify(any, (_, v) => {
+    if (typeof v === 'bigint') {
+        return `${v.toString()}`;
+    }
+    if (v instanceof Uint8Array) {
+        return `${binToHex(v)}`;
+    }
+    return v;
+}, spaces);
+const zip = (a, b) => Array.from(Array(Math.max(b.length, a.length)), (_, i) => [a[i], b[i]]);
+const createScenarioTransaction = (libauthTransaction, csTransaction) => {
+    const contract = csTransaction.contract;
+    const result = {};
+    // only one 'slot' is allowed, otherwise {} must be used
+    let inputSlotInserted = false;
+    result.inputs = libauthTransaction.inputs.map((input, index) => {
+        const csInput = csTransaction.inputs[index];
+        const signable = isUtxoP2PKH(csInput);
+        let unlockingBytecode = {};
+        if (signable) {
+            unlockingBytecode = {
+                script: 'p2pkh_placeholder_unlock',
+                overrides: {
+                    keys: {
+                        privateKeys: {
+                            placeholder_key: binToHex(csInput.template.privateKey),
+                        },
+                    },
+                },
+            };
+        }
+        else {
+            // assume it is our contract's input
+            // eslint-disable-next-line
+            if (!inputSlotInserted) {
+                unlockingBytecode = ['slot'];
+                inputSlotInserted = true;
+            }
+        }
+        return {
+            outpointIndex: input.outpointIndex,
+            outpointTransactionHash: input.outpointTransactionHash instanceof Uint8Array
+                ? binToHex(input.outpointTransactionHash)
+                : input.outpointTransactionHash,
+            sequenceNumber: input.sequenceNumber,
+            unlockingBytecode,
+        };
+    });
+    result.locktime = libauthTransaction.locktime;
+    result.outputs = libauthTransaction.outputs.map((output, index) => {
+        const csOutput = csTransaction.outputs[index];
+        let { lockingBytecode } = output;
+        if (typeof csOutput.to === 'string') {
+            if ([
+                contract.address,
+                contract.tokenAddress,
+            ].includes(csOutput.to)) {
+                lockingBytecode = {};
+            }
+            else {
+                for (const csInput of csTransaction.inputs) {
+                    if (isUtxoP2PKH(csInput)) {
+                        const inputPkh = hash160(csInput.template.getPublicKey());
+                        if (binToHex(output.lockingBytecode).slice(6, 46)
+                            === binToHex(inputPkh)) {
+                            lockingBytecode = {
+                                script: 'p2pkh_placeholder_lock',
+                                overrides: {
+                                    keys: {
+                                        privateKeys: {
+                                            placeholder_key: binToHex(csInput.template.privateKey),
+                                        },
+                                    },
+                                },
+                            };
+                        }
+                    }
+                }
+            }
+        }
+        return {
+            lockingBytecode: lockingBytecode instanceof Uint8Array
+                ? binToHex(lockingBytecode)
+                : lockingBytecode,
+            token: output.token,
+            valueSatoshis: Number(output.valueSatoshis),
+        };
+    });
+    result.version = libauthTransaction.version;
+    return result;
+};
+const createScenarioSourceOutputs = (csTransaction) => {
+    // only one 'slot' is allowed, otherwise {} must be used
+    let inputSlotInserted = false;
+    return csTransaction.inputs.map((csInput) => {
+        const signable = isUtxoP2PKH(csInput);
+        let lockingBytecode = {};
+        if (signable) {
+            lockingBytecode = {
+                script: 'p2pkh_placeholder_lock',
+                overrides: {
+                    keys: {
+                        privateKeys: {
+                            placeholder_key: binToHex(csInput.template.privateKey),
+                        },
+                    },
+                },
+            };
+        }
+        else {
+            // assume it is our contract's input
+            // eslint-disable-next-line
+            if (!inputSlotInserted) {
+                lockingBytecode = ['slot'];
+                inputSlotInserted = true;
+            }
+        }
+        const result = {
+            lockingBytecode: lockingBytecode,
+            valueSatoshis: Number(csInput.satoshis),
+        };
+        if (csInput.token) {
+            result.token = {
+                amount: csInput.token.amount.toString(),
+                category: csInput.token.category,
+            };
+            if (csInput.token.nft) {
+                result.token.nft = {
+                    capability: csInput.token.nft.capability,
+                    commitment: csInput.token.nft.commitment
+                };
+            }
+        }
+        return result;
+    });
+};
+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 libauthTransaction = decodeTransaction(hexToBin(txHex));
+    if (typeof libauthTransaction === 'string') {
+        throw Error(libauthTransaction);
+    }
+    const constructorInputs = contract.artifact.constructorInputs
+        .slice()
+        .reverse();
+    const contractParameters = contract.constructorArgs.slice().reverse();
+    const abiFunction = transaction.abiFunction;
+    const funcName = abiFunction.name;
+    const functionIndex = contract.artifact.abi.findIndex((func) => func.name === funcName);
+    const func = contract.artifact.abi[functionIndex];
+    const functionInputs = func.inputs.slice().reverse();
+    const args = transaction.args.slice().reverse();
+    const hasSignatureTemplates = transaction.inputs.filter((input) => isUtxoP2PKH(input)).length;
+    const formattedBytecode = contract.artifact.debug
+        ? formatLibauthScript(bytecodeToScript(hexToBin(contract.artifact.debug.bytecode)), contract.artifact.debug.sourceMap, contract.artifact.source).split('\n')
+        : contract.artifact.bytecode.split(' ').map((asmElement) => {
+            if (isHex(asmElement)) {
+                return `<0x${asmElement}>`;
+            }
+            return asmElement;
+        });
+    const template = {
+        $schema: 'https://ide.bitauth.com/authentication-template-v0.schema.json',
+        description: `Imported from cashscript`,
+        name: contract.artifact.contractName,
+        supported: ['BCH_SPEC'],
+        version: 0,
+    };
+    // declaration of template variables and their types
+    template.entities = {
+        parameters: {
+            description: 'Contract creation and function parameters',
+            name: 'parameters',
+            scripts: [
+                'lock',
+                'unlock_lock',
+            ],
+            variables: merge([
+                ...functionInputs.map((input) => ({
+                    [snakeCase(input.name)]: {
+                        description: `"${input.name}" parameter of function "${func.name}"`,
+                        name: input.name,
+                        type: input.type === PrimitiveType.SIG ? 'Key' : 'WalletData',
+                    },
+                })),
+                {
+                    function_index: {
+                        description: 'Script function index to execute',
+                        name: 'function_index',
+                        type: 'WalletData',
+                    },
+                },
+                ...constructorInputs.map((input) => ({
+                    [snakeCase(input.name)]: {
+                        description: `"${input.name}" parameter of this contract`,
+                        name: input.name,
+                        type: 'WalletData',
+                    },
+                })),
+            ]),
+        }
+    };
+    // add extra variables for the p2pkh utxos spent together with our contract
+    if (hasSignatureTemplates) {
+        template.entities.parameters.scripts.push('p2pkh_placeholder_lock', 'p2pkh_placeholder_unlock');
+        template.entities.parameters.variables = {
+            ...template.entities.parameters.variables,
+            placeholder_key: {
+                description: 'placeholder_key',
+                name: 'placeholder_key',
+                type: 'Key',
+            },
+        };
+    }
+    template.scenarios = {
+        // single scenario to spend out transaction under test given the CashScript parameters provided
+        evaluate_function: {
+            name: 'Evaluate',
+            description: 'An example evaluation where this script execution passes.',
+            data: {
+                // encode values for the variables defined above in `entities` property
+                bytecode: merge([
+                    ...zip(functionInputs, args)
+                        .filter(([input]) => input.type !== PrimitiveType.SIG)
+                        .map(([input, arg]) => {
+                        const hex = binToHex(arg);
+                        const result = hex.length ? `0x${hex}` : hex;
+                        return {
+                            [snakeCase(input.name)]: result,
+                        };
+                    }),
+                    { function_index: functionIndex.toString() },
+                    ...constructorInputs.map((input, index) => {
+                        const hex = binToHex(encodeArgument(contractParameters[index], constructorInputs[index].type));
+                        const result = hex.length ? `0x${hex}` : hex;
+                        return {
+                            [snakeCase(input.name)]: result,
+                        };
+                    }),
+                ]),
+                currentBlockHeight: 2,
+                currentBlockTime: Math.round(+new Date() / 1000),
+                keys: {
+                    privateKeys: merge([
+                        ...zip(functionInputs, args)
+                            .filter(([input]) => input.type === PrimitiveType.SIG)
+                            .map(([input, arg]) => ({
+                            [snakeCase(input.name)]: binToHex(arg.privateKey),
+                        })),
+                        ...(hasSignatureTemplates
+                            ? [
+                                {
+                                    // placeholder will be replaced by a key for each respective P2PKH input spent
+                                    placeholder_key: '<Uint8Array: 0x0000000000000000000000000000000000000000000000000000000000000000>',
+                                },
+                            ]
+                            : []),
+                    ]),
+                },
+            },
+            transaction: createScenarioTransaction(libauthTransaction, transaction),
+            sourceOutputs: createScenarioSourceOutputs(transaction),
+        },
+    };
+    // definition of locking scripts and unlocking scripts with their respective bytecode
+    template.scripts = {
+        unlock_lock: {
+            // this unlocking script must pass our only scenario
+            passes: ['evaluate_function'],
+            name: 'unlock',
+            // unlocking script contains the CashScript function parameters and function selector
+            // we output these values as pushdata, comment will contain the type and the value of the variable
+            // example: '<timeout> // int = <0xa08601>'
+            script: [
+                `// "${func.name}" function parameters`,
+                ...(functionInputs.length
+                    ? zip(functionInputs, args).map(([input, arg]) => (input.type === PrimitiveType.SIG
+                        ? `<${snakeCase(input.name)}.schnorr_signature.all_outputs> // ${input.type}`
+                        : `<${snakeCase(input.name)}> // ${input.type} = <${`0x${binToHex(arg)}`}>`))
+                    : ['// none']),
+                '',
+                ...(contract.artifact.abi.length > 1
+                    ? [
+                        '// function index in contract',
+                        `<function_index> // int = <${functionIndex.toString()}>`,
+                        '',
+                    ]
+                    : []),
+            ].join('\n'),
+            unlocks: 'lock',
+        },
+        lock: {
+            lockingType: "p2sh20",
+            name: 'lock',
+            // locking script contains the CashScript contract parameters followed by the contract opcodes
+            // we output these values as pushdata, comment will contain the type and the value of the variable
+            // example: '<timeout> // int = <0xa08601>'
+            script: [
+                `// "${contract.artifact.contractName}" contract constructor parameters`,
+                ...(constructorInputs.length
+                    ? constructorInputs.map((input, index) => {
+                        const encoded = encodeArgument(contractParameters[index], constructorInputs[index].type);
+                        return `<${snakeCase(input.name)}> // ${input.type === 'bytes' ? `bytes${encoded.length}` : input.type} = <${`0x${binToHex(encoded)}`}>`;
+                    })
+                    : ['// none']),
+                '',
+                '// bytecode',
+                ...formattedBytecode,
+            ].join('\n'),
+        },
+    };
+    // add extra unlocking and locking script for P2PKH inputs spent alongside our contract
+    // this is needed for correct cross-referrences in the template
+    if (hasSignatureTemplates) {
+        template.scripts.p2pkh_placeholder_unlock = {
+            name: 'p2pkh_placeholder_unlock',
+            script: '<placeholder_key.schnorr_signature.all_outputs>\n<placeholder_key.public_key>',
+            unlocks: 'p2pkh_placeholder_lock',
+        };
+        template.scripts.p2pkh_placeholder_lock = {
+            lockingType: 'standard',
+            name: 'p2pkh_placeholder_lock',
+            script: 'OP_DUP\nOP_HASH160 <$(<placeholder_key.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(stringify(template)))));
+    return `https://ide.bitauth.com/import-template/${payload}`;
+};
+// internal util. instantiates the virtual machine and compiles the template into a program
+const createProgram = (template) => {
+    const configuration = authenticationTemplateToCompilerConfiguration(template);
+    const vm = createVirtualMachineBCHCHIPs();
+    const compiler = createCompiler(configuration);
+    const scenarioGeneration = compiler.generateScenario({
+        debug: true,
+        lockingScriptId: undefined,
+        unlockingScriptId: 'unlock_lock',
+        scenarioId: 'evaluate_function',
+    });
+    if (typeof scenarioGeneration === 'string'
+        || typeof scenarioGeneration.scenario === 'string') {
+        // eslint-disable-next-line
+        throw scenarioGeneration;
+    }
+    return { vm, program: scenarioGeneration.scenario.program };
+};
+// evaluates the fully defined template, throws upon error
+export const evaluateTemplate = (template) => {
+    const { vm, program } = createProgram(template);
+    const verifyResult = vm.verify(program);
+    if (typeof verifyResult === 'string') {
+        // eslint-disable-next-line
+        throw verifyResult;
+    }
+    return verifyResult;
+};
+// debugs the template, optionally logging the execution data
+export const debugTemplate = (template, artifact) => {
+    const { vm, program } = createProgram(template);
+    const debugResult = vm.debug(program);
+    for (const log of artifact.debug?.logs ?? []) {
+        // there might be 2 elements with same instruction pointer, first from unllocking script, second from locking
+        const state = debugResult
+            .filter((debugState) => debugState.ip === log.ip)
+            .slice().reverse()[0];
+        if (!state) {
+            throw Error(`Instruction pointer ${log.ip} points to a non-existing state of the program`);
+        }
+        let line = `${artifact.contractName}.cash:${log.line}`;
+        log.data.forEach((element) => {
+            let value;
+            if (typeof element === 'string') {
+                value = element;
+            }
+            else {
+                const stackItem = state.stack.slice().reverse()[element.stackIndex];
+                if (!stackItem) {
+                    throw Error(`Stack item at index ${element.stackIndex} not found at instruction pointer ${log.ip}`);
+                }
+                switch (element.type) {
+                    case PrimitiveType.BOOL:
+                        value = decodeBool(stackItem);
+                        break;
+                    case PrimitiveType.INT:
+                        value = decodeInt(stackItem);
+                        break;
+                    case PrimitiveType.STRING:
+                        value = decodeString(stackItem);
+                        break;
+                    default:
+                        value = `0x${binToHex(stackItem)}`;
+                        break;
+                }
+            }
+            line += ` ${value}`;
+        });
+        // actual log, do not delete :)
+        console.log(line);
+    }
+    const lastState = debugResult[debugResult.length - 1];
+    if (lastState.error) {
+        const requireMessage = (artifact.debug?.requireMessages ?? []).filter((message) => message.ip === lastState.ip)[0];
+        if (requireMessage) {
+            // eslint-disable-next-line
+            throw `${artifact.contractName}.cash:${requireMessage.line} Error in evaluating input index ${lastState.program.inputIndex} with the following message: ${requireMessage.message}.
+${lastState.error}`;
+        }
+        else {
+            // eslint-disable-next-line
+            throw `Error in evaluating input index ${lastState.program.inputIndex}.
+${lastState.error}`;
+        }
+    }
+    else {
+        // one last pass of verifications not covered by the above debugging
+        // checks for removed final verify
+        const evaluationResult = vm.verify(program);
+        if (typeof evaluationResult === 'string' && toRegExp([
+            AuthenticationErrorCommon.requiresCleanStack,
+            AuthenticationErrorCommon.nonEmptyControlStack,
+            AuthenticationErrorCommon.unsuccessfulEvaluation,
+        ]).test(evaluationResult)) {
+            const stackContents = lastState.stack.map(item => `0x${binToHex(item)}`).join(', ');
+            const stackContentsMessage = `\nStack contents after evaluation: ${lastState.stack.length ? stackContents : 'empty'}`;
+            const lastMessage = artifact.debug?.requireMessages.sort((a, b) => b.ip - a.ip)[0];
+            if (!lastMessage) {
+                // eslint-disable-next-line
+                throw evaluationResult + stackContentsMessage;
+            }
+            const instructionsLeft = lastState.instructions.slice(lastMessage.ip);
+            if (instructionsLeft.length === 0
+                || instructionsLeft.every(instruction => [Op.OP_NIP, Op.OP_ENDIF].includes(instruction.opcode))) {
+                // eslint-disable-next-line
+                throw `${artifact.contractName}.cash:${lastMessage.line} Error in evaluating input index ${lastState.program.inputIndex} with the following message: ${lastMessage.message}.
+${evaluationResult.replace(/Error in evaluating input index \d: /, '')}` + stackContentsMessage;
+            }
+            // eslint-disable-next-line
+            throw evaluationResult + stackContentsMessage;
+        }
+    }
+    return debugResult;
+};
+//# sourceMappingURL=LibauthTemplate.js.map

package/dist/{SignatureTemplate.d.ts → src/SignatureTemplate.d.ts}

@@ -2,7 +2,7 @@ import { Unlocker, HashType, SignatureAlgorithm } from './interfaces.js';
 export default class SignatureTemplate {
     private hashtype;
     private signatureAlgorithm;
-    private privateKey;
+    privateKey: Uint8Array;
     constructor(signer: Keypair | Uint8Array | string, hashtype?: HashType, signatureAlgorithm?: SignatureAlgorithm);
     generateSignature(payload: Uint8Array, bchForkId?: boolean): Uint8Array;
     getHashType(bchForkId?: boolean): number;

package/dist/{Transaction.d.ts → src/Transaction.d.ts}

@@ -1,23 +1,23 @@
-import { AbiFunction, Script } from '@cashscript/utils';
-import { Utxo, Recipient, TokenDetails, TransactionDetails } from './interfaces.js';
-import NetworkProvider from './network/NetworkProvider.js';
+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 { DebugResult } from './LibauthTemplate.js';
 export declare class Transaction {
-    private address;
-    private provider;
-    private redeemScript;
-    private abiFunction;
-    private args;
+    contract: Contract;
+    private unlocker;
+    abiFunction: AbiFunction;
+    args: (Uint8Array | SignatureTemplate)[];
     private selector?;
-    private inputs;
-    private outputs;
+    inputs: Utxo[];
+    outputs: Output[];
     private sequence;
     private locktime;
     private feePerByte;
     private hardcodedFee;
     private minChange;
     private tokenChange;
-    constructor(address: string, provider: NetworkProvider, redeemScript: Script, abiFunction: AbiFunction, args: (Uint8Array | SignatureTemplate)[], selector?: number | undefined);
+    constructor(contract: Contract, unlocker: Unlocker, abiFunction: AbiFunction, args: (Uint8Array | SignatureTemplate)[], selector?: number | undefined);
     from(input: Utxo): this;
     from(inputs: Utxo[]): this;
     fromP2PKH(input: Utxo, template: SignatureTemplate): this;
@@ -35,7 +35,8 @@ export declare class Transaction {
     build(): Promise<string>;
     send(): Promise<TransactionDetails>;
     send(raw: true): Promise<string>;
+    debug(): Promise<DebugResult>;
+    bitauthUri(): Promise<string>;
     private getTxDetails;
-    meep(): Promise<string>;
     private setInputsAndOutputs;
 }