@btc-vision/transaction 1.0.99 → 1.0.101

package/src/generators/Generator.ts

@@ -22,7 +22,7 @@ export abstract class Generator {
      * The public key of the contract salt
      * @protected
      */
-    protected readonly contractSaltPubKey: Buffer;
+    protected readonly contractSaltPubKey?: Buffer;
 
     /**
      * The network to use
@@ -32,7 +32,7 @@ export abstract class Generator {
 
     protected constructor(
         senderPubKey: Buffer,
-        contractSaltPubKey: Buffer,
+        contractSaltPubKey?: Buffer,
         network: Network = networks.bitcoin,
     ) {
         this.senderPubKey = senderPubKey;

package/src/generators/builders/CalldataGenerator.ts

@@ -69,6 +69,8 @@ export class CalldataGenerator extends Generator {
         vaultPublicKeys: Buffer[] = [],
         minimumSignatures: number = 0,
     ): Buffer {
+        if (!this.contractSaltPubKey) throw new Error('Contract salt public key not set');
+
         const dataChunks: Buffer[][] = this.splitBufferIntoChunks(calldata);
         if (!dataChunks.length) throw new Error('No data chunks found');
 

package/src/generators/builders/CustomGenerator.ts

@@ -0,0 +1,30 @@
+import { Network, networks, script, Stack } from 'bitcoinjs-lib';
+import { Generator } from '../Generator.js';
+
+/**
+ * Class to generate bitcoin script for interaction transactions
+ */
+export class CustomGenerator extends Generator {
+    constructor(senderPubKey: Buffer, network: Network = networks.bitcoin) {
+        super(senderPubKey, undefined, network);
+    }
+
+    /**
+     * Compile an interaction bitcoin script
+     * @param compiledData - The compiled data
+     * @returns {Buffer} - The compiled script
+     * @throws {Error} - If something goes wrong
+     */
+    public compile(compiledData: (Buffer | Stack)[]): Buffer {
+        const asm = compiledData.flat();
+        const compiled = script.compile(asm);
+
+        /** Verify the validity of the script */
+        const decompiled = script.decompile(compiled);
+        if (!decompiled) {
+            throw new Error('Failed to decompile script??');
+        }
+
+        return compiled;
+    }
+}

package/src/generators/builders/DeploymentGenerator.ts

@@ -32,6 +32,8 @@ export class DeploymentGenerator extends Generator {
     }
 
     private getAsm(contractBytecode: Buffer, contractSalt: Buffer): (number | Buffer)[] {
+        if (!this.contractSaltPubKey) throw new Error('Contract salt public key not set');
+
         const dataChunks = this.splitBufferIntoChunks(contractBytecode);
 
         return [

package/src/metadata/tokens.ts

@@ -2,11 +2,11 @@ import { Address } from '@btc-vision/bsi-binary';
 import { ChainId } from '../network/ChainId.js';
 
 // Addresses Regtest
-export const FACTORY_ADDRESS_REGTEST: Address = 'bcrt1qxtpreq8zg7pp9wm550kjrhaa2r5kj6lhph9he5';
-export const POOL_ADDRESS_REGTEST: Address = 'bcrt1qqg2a8076rwuruzetdyquj8fh5jxtc22pmh9vep';
-export const WBTC_ADDRESS_REGTEST: Address = 'bcrt1qdr7sjgtnudda8zrfklw8l5cnrxum5hns7e46hf';
-export const MOTO_ADDRESS_REGTEST: Address = 'bcrt1q8reuxx9naek4mqesrfsgdpjv3q7a5g2llkh6ua';
-export const ROUTER_ADDRESS_REGTEST: Address = 'bcrt1qplnz54sca73t8a03nh494jatr9ffjg6ecarrj8';
+export const FACTORY_ADDRESS_REGTEST: Address = 'bcrt1q9pf9fnpch9z2qrp5e3dgr2avzu3mypq3km2k40';
+export const POOL_ADDRESS_REGTEST: Address = 'bcrt1qg87nx9v9ln3qyadcn0llekzjn0hx8js46ztwky';
+export const WBTC_ADDRESS_REGTEST: Address = 'bcrt1qy44f5630m4ap4mvmgqc44qh4vndaees9y30t0m';
+export const MOTO_ADDRESS_REGTEST: Address = 'bcrt1q5txqpm5sy0s2xsprvce4ddj0088nlq8lazkd6n';
+export const ROUTER_ADDRESS_REGTEST: Address = 'bcrt1q9yd6mk324k0q4krmlxjky0pk65ul6hkf4u35e6';
 
 // Addresses Testnet
 export const FACTORY_ADDRESS_TESTNET: Address = 'tb1qgev5kldhp5zvg6j8t9vl6x4phkrwn8nk9felxh';

package/src/opnet.ts

@@ -7,6 +7,8 @@ export * from './bytecode/Compressor.js';
 export * from './generators/Generator.js';
 export * from './generators/builders/CalldataGenerator.js';
 export * from './generators/builders/DeploymentGenerator.js';
+export * from './generators/builders/CustomGenerator.js';
+export * from './generators/builders/MultiSignGenerator.js';
 export * from './generators/Features.js';
 
 /** Address */
@@ -39,6 +41,9 @@ export * from './transaction/builders/TransactionBuilder.js';
 export * from './transaction/builders/WrapTransaction.js';
 export * from './transaction/builders/SharedInteractionTransaction.js';
 export * from './transaction/builders/DeploymentTransaction.js';
+export * from './transaction/builders/UnwrapTransaction.js';
+export * from './transaction/builders/CustomScriptTransaction.js';
+export * from './transaction/builders/MultiSignTransaction.js';
 
 /** wBTC */
 export * from './wbtc/WrappedGenerationParameters.js';
@@ -60,12 +65,7 @@ export * from './transaction/shared/TweakedTransaction.js';
 export * from './utxo/interfaces/BroadcastResponse.js';
 export * from './transaction/psbt/PSBTTypes.js';
 
-export * from './transaction/builders/MultiSignTransaction.js';
-export * from './generators/builders/MultiSignGenerator.js';
-
 export * from './transaction/shared/P2TR_MS.js';
-export * from './transaction/builders/UnwrapTransaction.js';
-
 export * from './wbtc/UnwrapGeneration.js';
 
 /** Consensus */

package/src/transaction/TransactionFactory.ts

@@ -21,6 +21,10 @@ import { UnwrapTransaction } from './builders/UnwrapTransaction.js';
 import { currentConsensus, currentConsensusConfig } from '../consensus/ConsensusConfig.js';
 import { TransactionBuilder } from './builders/TransactionBuilder.js';
 import { TransactionType } from './enums/TransactionType.js';
+import {
+    CustomScriptTransaction,
+    ICustomTransactionParameters,
+} from './builders/CustomScriptTransaction.js';
 
 export interface DeploymentResult {
     readonly transaction: [string, string];
@@ -71,6 +75,74 @@ export interface UnwrapResult {
 export class TransactionFactory {
     constructor() {}
 
+    /**
+     * @description Generate a transaction with a custom script.
+     * @returns {Promise<[string, string]>} - The signed transaction
+     */
+    public async createCustomScriptTransaction(
+        interactionParameters: ICustomTransactionParameters,
+    ): Promise<[string, string, UTXO[]]> {
+        if (!interactionParameters.to) {
+            throw new Error('Field "to" not provided.');
+        }
+
+        if (!interactionParameters.from) {
+            throw new Error('Field "from" not provided.');
+        }
+
+        const preTransaction: CustomScriptTransaction = new CustomScriptTransaction({
+            ...interactionParameters,
+            utxos: [interactionParameters.utxos[0]], // we simulate one input here.
+        });
+
+        // we don't sign that transaction, we just need the parameters.
+
+        await preTransaction.generateTransactionMinimalSignatures();
+
+        const parameters: IFundingTransactionParameters =
+            await preTransaction.getFundingTransactionParameters();
+
+        parameters.utxos = interactionParameters.utxos;
+        parameters.amount =
+            (await preTransaction.estimateTransactionFees()) + interactionParameters.priorityFee;
+
+        const feeEstimationFundingTransaction = await this.createFundTransaction({ ...parameters });
+        if (!feeEstimationFundingTransaction) {
+            throw new Error('Could not sign funding transaction.');
+        }
+
+        parameters.estimatedFees = feeEstimationFundingTransaction.estimatedFees;
+
+        const signedTransaction = await this.createFundTransaction(parameters);
+        if (!signedTransaction) {
+            throw new Error('Could not sign funding transaction.');
+        }
+
+        interactionParameters.utxos = this.getUTXOAsTransaction(
+            signedTransaction.tx,
+            interactionParameters.to,
+            0,
+        );
+
+        const newParams: ICustomTransactionParameters = {
+            ...interactionParameters,
+            utxos: this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0), // always 0
+            randomBytes: preTransaction.getRndBytes(),
+            nonWitnessUtxo: signedTransaction.tx.toBuffer(),
+            estimatedFees: preTransaction.estimatedFees,
+        };
+
+        const finalTransaction: CustomScriptTransaction = new CustomScriptTransaction(newParams);
+
+        // We have to regenerate using the new utxo
+        const outTx: Transaction = await finalTransaction.signTransaction();
+        return [
+            signedTransaction.tx.toHex(),
+            outTx.toHex(),
+            this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.from, 1), // always 1
+        ];
+    }
+
     /**
      * @description Generates the required transactions.
      * @returns {Promise<[string, string]>} - The signed transaction
@@ -132,7 +204,6 @@ export class TransactionFactory {
 
         // We have to regenerate using the new utxo
         const outTx: Transaction = await finalTransaction.signTransaction();
-
         return [
             signedTransaction.tx.toHex(),
             outTx.toHex(),
@@ -243,8 +314,6 @@ export class TransactionFactory {
         const parameters: IFundingTransactionParameters =
             await preTransaction.getFundingTransactionParameters();
 
-        console.log('wrap parameters', parameters);
-
         // We add the amount
         parameters.amount += childTransactionRequiredValue;
         parameters.utxos = fundingParameters.utxos;
@@ -300,15 +369,6 @@ export class TransactionFactory {
             this.maxPubKeySize(unwrapParameters.unwrapUTXOs),
         );
 
-        console.log(
-            'estimatedFees',
-            estimatedFees,
-            'estimatedGas',
-            estimatedGas,
-            'priority',
-            unwrapParameters.priorityFee,
-        );
-
         const fundingParameters: IFundingTransactionParameters = {
             ...unwrapParameters,
             amount: estimatedGas + estimatedFees,
@@ -402,8 +462,6 @@ export class TransactionFactory {
         parameters.amount =
             (await preTransaction.estimateTransactionFees()) + unwrapParameters.priorityFee;
 
-        console.log('parameters', parameters);
-
         const signedTransaction = await this.createFundTransaction(parameters);
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');

package/src/transaction/builders/CustomScriptTransaction.ts

@@ -0,0 +1,337 @@
+import { Taptree } from 'bitcoinjs-lib/src/types.js';
+import { TransactionType } from '../enums/TransactionType.js';
+import { TapLeafScript } from '../interfaces/Tap.js';
+import { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';
+import { Address } from '@btc-vision/bsi-binary';
+import { crypto as bitCrypto, Payment, Psbt, Signer, Stack } from 'bitcoinjs-lib';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { CustomGenerator } from '../../generators/builders/CustomGenerator.js';
+import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
+import { EcKeyPair } from '../../keypair/EcKeyPair.js';
+import { AddressGenerator } from '../../generators/AddressGenerator.js';
+import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
+import { PsbtInput } from 'bip174/src/lib/interfaces.js';
+
+export interface ICustomTransactionParameters extends SharedInteractionParameters {
+    readonly script: (Buffer | Stack)[];
+    readonly witnesses: Buffer[];
+
+    readonly to: Address;
+}
+
+/**
+ * Class for interaction transactions
+ * @class CustomScriptTransaction
+ */
+export class CustomScriptTransaction extends TransactionBuilder<TransactionType.CUSTOM_CODE> {
+    public type: TransactionType.CUSTOM_CODE = TransactionType.CUSTOM_CODE;
+
+    /**
+     * The contract address
+     * @protected
+     */
+    protected readonly _scriptAddress: Address;
+    /**
+     * The tap leaf script
+     * @private
+     */
+    protected tapLeafScript: TapLeafScript | null = null;
+    /**
+     * The target script redeem
+     * @private
+     */
+    private targetScriptRedeem: Payment | null = null;
+    /**
+     * The left over funds script redeem
+     * @private
+     */
+    private leftOverFundsScriptRedeem: Payment | null = null;
+    /**
+     * The compiled target script
+     * @private
+     */
+    private readonly compiledTargetScript: Buffer;
+    /**
+     * The script tree
+     * @private
+     */
+    private readonly scriptTree: Taptree;
+    /**
+     * The deployment bitcoin generator
+     * @private
+     */
+    private generator: CustomGenerator;
+
+    /**
+     * The contract seed
+     * @private
+     */
+    private readonly scriptSeed: Buffer;
+
+    /**
+     * The contract signer
+     * @private
+     */
+    private readonly contractSigner: Signer;
+
+    /**
+     * The contract salt random bytes
+     * @private
+     */
+    private readonly randomBytes: Buffer;
+
+    /**
+     * The witnesses
+     * @private
+     */
+    private readonly witnesses: Buffer[];
+
+    public constructor(parameters: ICustomTransactionParameters) {
+        super(parameters);
+
+        if (!parameters.script) throw new Error('Bitcoin script is required');
+        if (!parameters.witnesses) throw new Error('Witness(es) are required');
+
+        this.witnesses = parameters.witnesses;
+        this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
+
+        this.scriptSeed = this.getContractSeed();
+        this.contractSigner = EcKeyPair.fromSeedKeyPair(this.scriptSeed, this.network);
+
+        this.generator = new CustomGenerator(this.internalPubKeyToXOnly(), this.network);
+
+        this.compiledTargetScript = this.generator.compile(parameters.script);
+
+        this.scriptTree = this.getScriptTree();
+
+        this.internalInit();
+
+        this._scriptAddress = AddressGenerator.generatePKSH(this.scriptSeed, this.network);
+    }
+
+    /**
+     * @description Get the contract address (PKSH)
+     */
+    public get scriptAddress(): Address {
+        return this._scriptAddress;
+    }
+
+    /**
+     * @description Get the P2TR address
+     */
+    public get p2trAddress(): Address {
+        return this.to || this.getScriptAddress();
+    }
+
+    /**
+     * Get the random bytes used for the interaction
+     * @returns {Buffer} The random bytes
+     */
+    public getRndBytes(): Buffer {
+        return this.randomBytes;
+    }
+
+    /**
+     * Get the contract signer public key
+     * @protected
+     */
+    protected contractSignerXOnlyPubKey(): Buffer {
+        return toXOnly(this.contractSigner.publicKey);
+    }
+
+    /**
+     * Build the transaction
+     * @protected
+     */
+    protected override async buildTransaction(): Promise<void> {
+        if (!this.to) {
+            this.to = this.getScriptAddress();
+        }
+
+        const selectedRedeem = !!this.contractSigner
+            ? this.targetScriptRedeem
+            : this.leftOverFundsScriptRedeem;
+
+        if (!selectedRedeem) {
+            throw new Error('Left over funds script redeem is required');
+        }
+
+        if (!selectedRedeem.redeemVersion) {
+            throw new Error('Left over funds script redeem version is required');
+        }
+
+        if (!selectedRedeem.output) {
+            throw new Error('Left over funds script redeem output is required');
+        }
+
+        this.tapLeafScript = {
+            leafVersion: selectedRedeem.redeemVersion,
+            script: selectedRedeem.output,
+            controlBlock: this.getWitness(),
+        };
+
+        this.addInputsFromUTXO();
+
+        const amountSpent: bigint = this.getTransactionOPNetFee();
+        this.addOutput({
+            value: Number(amountSpent),
+            address: this.to,
+        });
+
+        await this.addRefundOutput(amountSpent);
+    }
+
+    /**
+     * Sign the inputs
+     * @param {Psbt} transaction The transaction to sign
+     * @protected
+     */
+    protected async signInputs(transaction: Psbt): Promise<void> {
+        if (!this.contractSigner) {
+            await super.signInputs(transaction);
+
+            return;
+        }
+
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            if (i === 0) {
+                // multi sig input
+                transaction.signInput(0, this.contractSigner);
+                transaction.signInput(0, this.getSignerKey());
+
+                transaction.finalizeInput(0, this.customFinalizer);
+            } else {
+                transaction.signInput(i, this.getSignerKey());
+                transaction.finalizeInput(i);
+            }
+        }
+    }
+
+    /**
+     * Get the tap output
+     * @protected
+     */
+    protected override generateScriptAddress(): Payment {
+        return {
+            internalPubkey: this.internalPubKeyToXOnly(),
+            network: this.network,
+            scriptTree: this.scriptTree,
+        };
+    }
+
+    /**
+     * Generate the tap data
+     * @protected
+     */
+    protected override generateTapData(): Payment {
+        const selectedRedeem = !!this.contractSigner
+            ? this.targetScriptRedeem
+            : this.leftOverFundsScriptRedeem;
+
+        if (!selectedRedeem) {
+            throw new Error('Left over funds script redeem is required');
+        }
+
+        if (!this.scriptTree) {
+            throw new Error('Script tree is required');
+        }
+
+        return {
+            internalPubkey: this.internalPubKeyToXOnly(),
+            network: this.network,
+            scriptTree: this.scriptTree,
+            redeem: selectedRedeem,
+        };
+    }
+
+    /**
+     * Generate the contract seed for the deployment
+     * @private
+     */
+    private getContractSeed(): Buffer {
+        return bitCrypto.hash256(this.randomBytes);
+    }
+
+    /**
+     * Finalize the transaction
+     * @param _inputIndex
+     * @param input
+     */
+    private customFinalizer = (_inputIndex: number, input: PsbtInput) => {
+        if (!this.tapLeafScript) {
+            throw new Error('Tap leaf script is required');
+        }
+
+        if (!input.tapScriptSig) {
+            throw new Error('Tap script signature is required');
+        }
+
+        const scriptSolution = this.witnesses;
+        const witness = scriptSolution
+            .concat(this.tapLeafScript.script)
+            .concat(this.tapLeafScript.controlBlock);
+
+        return {
+            finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness(witness),
+        };
+    };
+
+    /**
+     * Get the public keys for the redeem scripts
+     * @private
+     */
+    private getPubKeys(): Buffer[] {
+        const pubkeys = [this.signer.publicKey];
+
+        if (this.contractSigner) {
+            pubkeys.push(this.contractSigner.publicKey);
+        }
+
+        return pubkeys;
+    }
+
+    /**
+     * Generate the redeem scripts
+     * @private
+     */
+    private generateRedeemScripts(): void {
+        this.targetScriptRedeem = {
+            pubkeys: this.getPubKeys(),
+            output: this.compiledTargetScript,
+            redeemVersion: 192,
+        };
+
+        this.leftOverFundsScriptRedeem = {
+            pubkeys: this.getPubKeys(),
+            output: this.getLeafScript(),
+            redeemVersion: 192,
+        };
+    }
+
+    /**
+     * Get the second leaf script
+     * @private
+     */
+    private getLeafScript(): Buffer {
+        return TransactionBuilder.LOCK_LEAF_SCRIPT;
+    }
+
+    /**
+     * Get the script tree
+     * @private
+     */
+    private getScriptTree(): Taptree {
+        this.generateRedeemScripts();
+
+        return [
+            {
+                output: this.compiledTargetScript,
+                version: 192,
+            },
+            {
+                output: this.getLeafScript(),
+                version: 192,
+            },
+        ];
+    }
+}

package/src/transaction/enums/TransactionType.ts

@@ -6,4 +6,5 @@ export enum TransactionType {
     WBTC_WRAP = 4,
     WBTC_UNWRAP = 5,
     MULTI_SIG = 6,
+    CUSTOM_CODE = 7,
 }

package/docs/.nojekyll

@@ -1 +0,0 @@
-TypeDoc added this file to prevent GitHub Pages from using Jekyll. You can turn off this behavior by setting the `githubPages` option to false.

package/docs/assets/highlight.css

@@ -1,43 +0,0 @@
-:root {
-    --light-hl-0: #795E26;
-    --dark-hl-0: #DCDCAA;
-    --light-hl-1: #000000;
-    --dark-hl-1: #D4D4D4;
-    --light-hl-2: #A31515;
-    --dark-hl-2: #CE9178;
-    --light-code-background: #FFFFFF;
-    --dark-code-background: #1E1E1E;
-}
-
-@media (prefers-color-scheme: light) { :root {
-    --hl-0: var(--light-hl-0);
-    --hl-1: var(--light-hl-1);
-    --hl-2: var(--light-hl-2);
-    --code-background: var(--light-code-background);
-} }
-
-@media (prefers-color-scheme: dark) { :root {
-    --hl-0: var(--dark-hl-0);
-    --hl-1: var(--dark-hl-1);
-    --hl-2: var(--dark-hl-2);
-    --code-background: var(--dark-code-background);
-} }
-
-:root[data-theme='light'] {
-    --hl-0: var(--light-hl-0);
-    --hl-1: var(--light-hl-1);
-    --hl-2: var(--light-hl-2);
-    --code-background: var(--light-code-background);
-}
-
-:root[data-theme='dark'] {
-    --hl-0: var(--dark-hl-0);
-    --hl-1: var(--dark-hl-1);
-    --hl-2: var(--dark-hl-2);
-    --code-background: var(--dark-code-background);
-}
-
-.hl-0 { color: var(--hl-0); }
-.hl-1 { color: var(--hl-1); }
-.hl-2 { color: var(--hl-2); }
-pre, code { background: var(--code-background); }