@btc-vision/transaction 1.2.1 → 1.2.3

package/build/transaction/builders/SharedInteractionTransaction.js

@@ -1,9 +1,10 @@
 import { address, toXOnly } from '@btc-vision/bitcoin';
-import { TransactionBuilder } from './TransactionBuilder.js';
+import { MINIMUM_AMOUNT_CA, MINIMUM_AMOUNT_REWARD, TransactionBuilder } from './TransactionBuilder.js';
 import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
 import { Compressor } from '../../bytecode/Compressor.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
+import { ChallengeGenerator } from '../mineable/ChallengeGenerator.js';
 export class SharedInteractionTransaction extends TransactionBuilder {
     constructor(parameters) {
         super(parameters);
@@ -27,7 +28,9 @@ export class SharedInteractionTransaction extends TransactionBuilder {
         if (!parameters.calldata) {
             throw new Error('Calldata is required');
         }
+        this.preimage = parameters.preimage || BitcoinUtils.getSafeRandomValues(128);
         this.disableAutoRefund = parameters.disableAutoRefund || false;
+        this.rewardChallenge = ChallengeGenerator.generateMineableReward(this.preimage, this.network);
         this.calldata = Compressor.compress(parameters.calldata);
         this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
         this.scriptSigner = this.generateKeyPairFromSeed();
@@ -39,6 +42,9 @@ export class SharedInteractionTransaction extends TransactionBuilder {
     getRndBytes() {
         return this.randomBytes;
     }
+    getPreimage() {
+        return this.preimage;
+    }
     generateSecret() {
         if (!this.to)
             throw new Error('To address is required');
@@ -51,8 +57,6 @@ export class SharedInteractionTransaction extends TransactionBuilder {
         return EcKeyPair.fromSeedKeyPair(this.randomBytes, this.network);
     }
     async buildTransaction() {
-        if (!this.to)
-            throw new Error('To address is required');
         const selectedRedeem = this.scriptSigner
             ? this.targetScriptRedeem
             : this.leftOverFundsScriptRedeem;
@@ -73,15 +77,7 @@ export class SharedInteractionTransaction extends TransactionBuilder {
         if (!this.regenerated) {
             this.addInputsFromUTXO();
         }
-        const amountSpent = this.getTransactionOPNetFee();
-        this.addOutput({
-            value: Number(amountSpent),
-            address: this.to,
-        });
-        const amount = this.addOptionalOutputsAndGetAmount();
-        if (!this.disableAutoRefund) {
-            await this.addRefundOutput(amountSpent + amount);
-        }
+        await this.createMineableRewardOutputs();
     }
     async signInputs(transaction) {
         if (!this.scriptSigner) {
@@ -125,7 +121,6 @@ export class SharedInteractionTransaction extends TransactionBuilder {
         }
         return [
             this.contractSecret,
-            this.internalPubKeyToXOnly(),
             input.tapScriptSig[0].signature,
             input.tapScriptSig[1].signature,
         ];
@@ -159,6 +154,33 @@ export class SharedInteractionTransaction extends TransactionBuilder {
             }
         }
     }
+    async createMineableRewardOutputs() {
+        if (!this.to)
+            throw new Error('To address is required');
+        const amountSpent = this.getTransactionOPNetFee();
+        let amountToCA;
+        if (amountSpent > MINIMUM_AMOUNT_REWARD + MINIMUM_AMOUNT_CA) {
+            amountToCA = MINIMUM_AMOUNT_CA;
+        }
+        else {
+            amountToCA = amountSpent;
+        }
+        this.addOutput({
+            value: Number(amountToCA),
+            address: this.to,
+        });
+        if (amountToCA === MINIMUM_AMOUNT_CA &&
+            amountSpent - MINIMUM_AMOUNT_CA > MINIMUM_AMOUNT_REWARD) {
+            this.addOutput({
+                value: Number(amountSpent - amountToCA),
+                address: this.rewardChallenge.address,
+            });
+        }
+        const amount = this.addOptionalOutputsAndGetAmount();
+        if (!this.disableAutoRefund) {
+            await this.addRefundOutput(amountSpent + amount);
+        }
+    }
     async signInputsNonWalletBased(transaction) {
         for (let i = 0; i < transaction.data.inputs.length; i++) {
             if (i === 0) {

package/build/transaction/builders/TransactionBuilder.d.ts

@@ -6,6 +6,8 @@ import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { ECPairInterface } from 'ecpair';
 import { TweakedTransaction } from '../shared/TweakedTransaction.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
+export declare const MINIMUM_AMOUNT_REWARD: bigint;
+export declare const MINIMUM_AMOUNT_CA: bigint;
 export declare abstract class TransactionBuilder<T extends TransactionType> extends TweakedTransaction {
     static readonly LOCK_LEAF_SCRIPT: Buffer;
     static readonly MINIMUM_DUST: bigint;

package/build/transaction/builders/TransactionBuilder.js

@@ -4,6 +4,8 @@ import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { AddressVerificator } from '../../keypair/AddressVerificator.js';
 import { TweakedTransaction } from '../shared/TweakedTransaction.js';
 initEccLib(ecc);
+export const MINIMUM_AMOUNT_REWARD = 540n;
+export const MINIMUM_AMOUNT_CA = 330n;
 export class TransactionBuilder extends TweakedTransaction {
     constructor(parameters) {
         super(parameters);

package/build/transaction/enums/TransactionType.d.ts

@@ -3,8 +3,7 @@ export declare enum TransactionType {
     FUNDING = 1,
     DEPLOYMENT = 2,
     INTERACTION = 3,
-    WBTC_WRAP = 4,
-    WBTC_UNWRAP = 5,
-    MULTI_SIG = 6,
-    CUSTOM_CODE = 7
+    MULTI_SIG = 4,
+    CUSTOM_CODE = 5,
+    CHALLENGE_SOLUTION = 6
 }

package/build/transaction/enums/TransactionType.js

@@ -4,8 +4,7 @@ export var TransactionType;
     TransactionType[TransactionType["FUNDING"] = 1] = "FUNDING";
     TransactionType[TransactionType["DEPLOYMENT"] = 2] = "DEPLOYMENT";
     TransactionType[TransactionType["INTERACTION"] = 3] = "INTERACTION";
-    TransactionType[TransactionType["WBTC_WRAP"] = 4] = "WBTC_WRAP";
-    TransactionType[TransactionType["WBTC_UNWRAP"] = 5] = "WBTC_UNWRAP";
-    TransactionType[TransactionType["MULTI_SIG"] = 6] = "MULTI_SIG";
-    TransactionType[TransactionType["CUSTOM_CODE"] = 7] = "CUSTOM_CODE";
+    TransactionType[TransactionType["MULTI_SIG"] = 4] = "MULTI_SIG";
+    TransactionType[TransactionType["CUSTOM_CODE"] = 5] = "CUSTOM_CODE";
+    TransactionType[TransactionType["CHALLENGE_SOLUTION"] = 6] = "CHALLENGE_SOLUTION";
 })(TransactionType || (TransactionType = {}));

package/build/transaction/interfaces/ITransactionParameters.d.ts

@@ -17,9 +17,14 @@ export interface IFundingTransactionParameters extends ITransactionParameters {
     amount: bigint;
     splitInputsInto?: number;
 }
+export interface IChallengeSolutionTransactionParameters extends ITransactionParameters {
+    amount: bigint;
+    readonly challengeSolution: Buffer;
+}
 export interface SharedInteractionParameters extends ITransactionParameters {
     calldata?: Buffer;
     disableAutoRefund?: boolean;
+    readonly preimage?: Buffer;
     readonly randomBytes?: Buffer;
 }
 export interface IInteractionParameters extends SharedInteractionParameters {
@@ -30,4 +35,5 @@ export interface IDeploymentParameters extends Omit<ITransactionParameters, 'to'
     readonly bytecode: Buffer;
     readonly calldata?: Buffer;
     readonly randomBytes?: Buffer;
+    readonly preimage?: Buffer;
 }

package/build/transaction/mineable/ChallengeGenerator.d.ts

@@ -0,0 +1,9 @@
+import { Network } from '@btc-vision/bitcoin';
+export interface IMineableReward {
+    address: string;
+    p2shOutputScript: Buffer;
+    redeemScript: Buffer;
+}
+export declare class ChallengeGenerator {
+    static generateMineableReward(preimage1: Buffer, network: Network): IMineableReward;
+}

package/build/transaction/mineable/ChallengeGenerator.js

@@ -0,0 +1,28 @@
+import bitcoin from '@btc-vision/bitcoin';
+import { MineableReward } from '../../generators/builders/MineableReward.js';
+export class ChallengeGenerator {
+    static generateMineableReward(preimage1, network) {
+        const mineableReward = new MineableReward(Buffer.alloc(0), network);
+        const redeemScript = mineableReward.compile(preimage1);
+        const p2sh = bitcoin.payments.p2sh({
+            redeem: { output: redeemScript },
+            network,
+        });
+        const outputRedeem = p2sh.redeem?.output;
+        if (!outputRedeem) {
+            throw new Error('Output redeem is required');
+        }
+        if (!p2sh.address) {
+            throw new Error('P2SH address is required');
+        }
+        const p2shOutputScript = p2sh?.redeem?.output;
+        if (!p2shOutputScript) {
+            throw new Error('No redeem output');
+        }
+        return {
+            address: p2sh.address,
+            p2shOutputScript,
+            redeemScript: redeemScript,
+        };
+    }
+}

package/build/transaction/shared/TweakedTransaction.js

@@ -24,7 +24,7 @@ export class TweakedTransaction extends Logger {
         this.customFinalizerP2SH = (inputIndex, input, scriptA, isSegwit, isP2SH, isP2WSH) => {
             const inputDecoded = this.inputs[inputIndex];
             if (isP2SH && input.partialSig && inputDecoded && inputDecoded.redeemScript) {
-                const signatures = input.partialSig.map((sig) => sig.signature);
+                const signatures = input.partialSig.map((sig) => sig.signature) || [];
                 const scriptSig = script.compile([...signatures, inputDecoded.redeemScript]);
                 return {
                     finalScriptSig: scriptSig,

package/build/utxo/interfaces/IUTXO.d.ts

@@ -1,4 +1,4 @@
-import { ScriptPubKey } from '@btc-vision/bsi-bitcoin-rpc';
+import { ScriptPubKey } from '@btc-vision/bitcoin-rpc';
 export interface UTXO {
     readonly transactionId: string;
     readonly outputIndex: number;

package/build/verification/TapscriptVerificator.d.ts

@@ -4,6 +4,7 @@ export interface ContractAddressVerificationParams {
     readonly contractSaltPubKey: Buffer;
     readonly originalSalt: Buffer;
     readonly bytecode: Buffer;
+    readonly preimage: Buffer;
     readonly calldata?: Buffer;
     readonly network?: Network;
 }
@@ -12,6 +13,5 @@ export declare class TapscriptVerificator {
     static getContractAddress(params: ContractAddressVerificationParams): string | undefined;
     static verifyControlBlock(params: ContractAddressVerificationParams, controlBlock: Buffer): boolean;
     static getContractSeed(deployerPubKey: Buffer, bytecode: Buffer, saltHash: Buffer): Buffer;
-    static generateContractVirtualAddress(deployerPubKey: Buffer, bytecode: Buffer, saltHash: Buffer, network?: Network): string;
     static generateAddressFromScript(params: ContractAddressVerificationParams, scriptTree: Taptree): string | undefined;
 }

package/build/verification/TapscriptVerificator.js

@@ -1,12 +1,11 @@
 import { crypto as bitCrypto, networks, payments, toXOnly, } from '@btc-vision/bitcoin';
 import { DeploymentGenerator } from '../generators/builders/DeploymentGenerator.js';
 import { TransactionBuilder } from '../transaction/builders/TransactionBuilder.js';
-import { Address } from '../keypair/Address.js';
 export class TapscriptVerificator {
     static getContractAddress(params) {
         const network = params.network || networks.bitcoin;
         const scriptBuilder = new DeploymentGenerator(params.deployerPubKey, toXOnly(params.contractSaltPubKey), network);
-        const compiledTargetScript = scriptBuilder.compile(params.bytecode, params.originalSalt, params.calldata);
+        const compiledTargetScript = scriptBuilder.compile(params.bytecode, params.originalSalt, params.preimage, params.calldata);
         const scriptTree = [
             {
                 output: compiledTargetScript,
@@ -22,7 +21,7 @@ export class TapscriptVerificator {
     static verifyControlBlock(params, controlBlock) {
         const network = params.network || networks.bitcoin;
         const scriptBuilder = new DeploymentGenerator(params.deployerPubKey, toXOnly(params.contractSaltPubKey), network);
-        const compiledTargetScript = scriptBuilder.compile(params.bytecode, params.originalSalt, params.calldata);
+        const compiledTargetScript = scriptBuilder.compile(params.bytecode, params.originalSalt, params.preimage, params.calldata);
         const scriptTree = [
             {
                 output: compiledTargetScript,
@@ -55,11 +54,6 @@ export class TapscriptVerificator {
         const buf = Buffer.concat([deployerPubKey, saltHash, sha256OfBytecode]);
         return bitCrypto.hash256(buf);
     }
-    static generateContractVirtualAddress(deployerPubKey, bytecode, saltHash, network = networks.bitcoin) {
-        const virtualAddress = TapscriptVerificator.getContractSeed(deployerPubKey, bytecode, saltHash);
-        const address = new Address(virtualAddress);
-        return address.p2tr(network);
-    }
     static generateAddressFromScript(params, scriptTree) {
         const network = params.network || networks.bitcoin;
         const transactionData = {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.2.1",
+    "version": "1.2.3",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {
@@ -89,8 +89,8 @@
     "dependencies": {
         "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
         "@bitcoinerlab/secp256k1": "^1.1.1",
-        "@btc-vision/bitcoin": "^6.3.2",
-        "@btc-vision/bsi-bitcoin-rpc": "^1.0.29",
+        "@btc-vision/bitcoin": "^6.3.3",
+        "@btc-vision/bitcoin-rpc": "^1.0.0",
         "@btc-vision/logger": "^1.0.6",
         "@eslint/js": "^9.14.0",
         "@noble/secp256k1": "^2.1.0",

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.2.1';
+export const version = '1.2.3';

package/src/generators/Generator.ts

@@ -10,7 +10,7 @@ export abstract class Generator {
     /**
      * The magic number of OPNet
      */
-    public static readonly MAGIC: Buffer = Buffer.from('bsi', 'utf-8');
+    public static readonly MAGIC: Buffer = Buffer.from('op', 'utf-8');
 
     /**
      * The public key of the sender

package/src/generators/builders/CalldataGenerator.ts

@@ -56,18 +56,16 @@ export class CalldataGenerator extends Generator {
      * Compile an interaction bitcoin script
      * @param {Buffer} calldata - The calldata to use
      * @param {Buffer} contractSecret - The contract secret
+     * @param preimage
      * @param {number[]} [features=[]] - The features to use (optional)
-     * @param {Buffer[]} [vaultPublicKeys=[]] - The public keys of the vault (optional)
-     * @param {number} [minimumSignatures=0] - The minimum number of signatures (optional)
      * @returns {Buffer} - The compiled script
      * @throws {Error} - If something goes wrong
      */
     public compile(
         calldata: Buffer,
         contractSecret: Buffer,
+        preimage: Buffer,
         features: Features[] = [],
-        vaultPublicKeys: Buffer[] = [],
-        minimumSignatures: number = 0,
     ): Buffer {
         if (!this.contractSaltPubKey) throw new Error('Contract salt public key not set');
 
@@ -78,16 +76,20 @@ export class CalldataGenerator extends Generator {
             this.senderFirstByte,
             opcodes.OP_TOALTSTACK,
 
+            // CHALLENGE PREIMAGE FOR REWARD,
+            preimage,
+            opcodes.OP_TOALTSTACK,
+
             this.xSenderPubKey,
+            opcodes.OP_DUP,
+            opcodes.OP_HASH256,
+            crypto.hash256(this.xSenderPubKey),
+            opcodes.OP_EQUALVERIFY,
             opcodes.OP_CHECKSIGVERIFY,
 
             this.contractSaltPubKey,
             opcodes.OP_CHECKSIGVERIFY,
 
-            opcodes.OP_HASH160,
-            crypto.hash160(this.xSenderPubKey),
-            opcodes.OP_EQUALVERIFY,
-
             opcodes.OP_HASH160,
             crypto.hash160(contractSecret),
             opcodes.OP_EQUALVERIFY,
@@ -100,39 +102,6 @@ export class CalldataGenerator extends Generator {
             Generator.MAGIC,
         ];
 
-        // write pub keys, when requested.
-        if (vaultPublicKeys.length > 0) {
-            const pubKeyBuffer = CalldataGenerator.getPubKeyAsBuffer(vaultPublicKeys, this.network);
-            const pubKeyDataChunks: Buffer[][] = this.splitBufferIntoChunks(pubKeyBuffer);
-
-            compiledData = compiledData.concat(
-                ...[
-                    opcodes.OP_0, // provide opnet public keys
-                    ...pubKeyDataChunks,
-                ],
-            );
-
-            if (minimumSignatures) {
-                // verify that the minimum is not greater than 255
-                if (minimumSignatures > 255) {
-                    throw new Error('Minimum signatures cannot exceed 255');
-                }
-
-                // we use a 2 bytes buffer even if we limit to 255 so it does not use an opcode for the number
-                const minSigBuffer = Buffer.alloc(2);
-                minSigBuffer.writeUint16LE(minimumSignatures, 0);
-
-                compiledData = compiledData.concat(
-                    ...[
-                        opcodes.OP_1, // provide minimum signatures
-                        minSigBuffer,
-                    ],
-                );
-            } else {
-                throw new Error('Minimum signatures must be provided');
-            }
-        }
-
         const featureOpcodes = features.map((feature) => FeatureOpCodes[feature]); // Get the opcodes for the features
 
         // Write calldata

package/src/generators/builders/DeploymentGenerator.ts

@@ -14,11 +14,17 @@ export class DeploymentGenerator extends Generator {
      * Compile a bitcoin script representing a contract deployment
      * @param {Buffer} contractBytecode - The contract bytecode
      * @param {Buffer} contractSalt - The contract salt
+     * @param {Buffer} preimage - The preimage for reward
      * @param {Buffer} [calldata] - The calldata to be passed to the contract
      * @returns {Buffer} - The compiled script
      */
-    public compile(contractBytecode: Buffer, contractSalt: Buffer, calldata?: Buffer): Buffer {
-        const asm = this.getAsm(contractBytecode, contractSalt, calldata);
+    public compile(
+        contractBytecode: Buffer,
+        contractSalt: Buffer,
+        preimage: Buffer,
+        calldata?: Buffer,
+    ): Buffer {
+        const asm = this.getAsm(contractBytecode, contractSalt, preimage, calldata);
         const compiled = script.compile(asm);
 
         /**
@@ -35,27 +41,32 @@ export class DeploymentGenerator extends Generator {
     private getAsm(
         contractBytecode: Buffer,
         contractSalt: Buffer,
+        preimage: Buffer,
         calldata?: Buffer,
     ): (number | Buffer)[] {
         if (!this.contractSaltPubKey) throw new Error('Contract salt public key not set');
 
         const dataChunks: Buffer[][] = this.splitBufferIntoChunks(contractBytecode);
         const calldataChunks: Buffer[][] = calldata ? this.splitBufferIntoChunks(calldata) : [];
-
+        
         const compiledData = [
             this.senderFirstByte,
             opcodes.OP_TOALTSTACK,
 
+            // CHALLENGE PREIMAGE FOR REWARD,
+            preimage,
+            opcodes.OP_TOALTSTACK,
+
             this.xSenderPubKey,
+            opcodes.OP_DUP,
+            opcodes.OP_HASH256,
+            crypto.hash256(this.xSenderPubKey),
+            opcodes.OP_EQUALVERIFY,
             opcodes.OP_CHECKSIGVERIFY,
 
             this.contractSaltPubKey,
             opcodes.OP_CHECKSIGVERIFY,
 
-            opcodes.OP_HASH160,
-            crypto.hash160(this.xSenderPubKey),
-            opcodes.OP_EQUALVERIFY,
-
             opcodes.OP_HASH256,
             crypto.hash256(contractSalt),
             opcodes.OP_EQUALVERIFY,

package/src/generators/builders/LegacyCalldataGenerator.ts

@@ -1,4 +1,4 @@
-import { Network, networks, opcodes, script } from '@btc-vision/bitcoin';
+import { crypto, Network, networks, opcodes, script } from '@btc-vision/bitcoin';
 import { ECPairInterface } from 'ecpair';
 import { Compressor } from '../../bytecode/Compressor.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
@@ -70,6 +70,10 @@ export class LegacyCalldataGenerator extends Generator {
 
         let compiledData = [
             this.senderPubKey,
+            opcodes.OP_DUP,
+            opcodes.OP_HASH256,
+            crypto.hash256(this.senderPubKey),
+            opcodes.OP_EQUALVERIFY,
             opcodes.OP_CHECKSIGVERIFY,
 
             contractSecret,

package/src/generators/builders/MineableReward.ts

@@ -0,0 +1,63 @@
+import { Network, networks, opcodes, script } from '@btc-vision/bitcoin';
+import { Generator } from '../Generator.js';
+
+/**
+ * Class to generate bitcoin script for interaction transactions
+ */
+export class MineableReward extends Generator {
+    constructor(senderPubKey: Buffer, network: Network = networks.bitcoin) {
+        super(senderPubKey, Buffer.alloc(0), network);
+    }
+
+    /**
+     * Compile an interaction bitcoin script
+     * @param {Buffer} preimage1 - Preimage 1
+     * @returns {Buffer} - The compiled script
+     * @throws {Error} - If something goes wrong
+     */
+    public compile(preimage1: Buffer): Buffer {
+        let compiledData: (number | Buffer)[];
+
+        if (this.isTestnet()) {
+            compiledData = [
+                preimage1,
+                opcodes.OP_SHA1,
+                opcodes.OP_SHA1,
+                opcodes.OP_SWAP,
+                opcodes.OP_SHA1,
+                opcodes.OP_SHA1,
+                opcodes.OP_EQUAL,
+            ];
+        } else {
+            compiledData = [
+                preimage1,
+                opcodes.OP_SWAP,
+                opcodes.OP_2DUP,
+                opcodes.OP_EQUAL,
+                opcodes.OP_NOT,
+                opcodes.OP_VERIFY,
+                opcodes.OP_SHA1,
+                opcodes.OP_SHA1,
+                opcodes.OP_SWAP,
+                opcodes.OP_SHA1,
+                opcodes.OP_SHA1,
+                opcodes.OP_EQUAL,
+            ];
+        }
+
+        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;
+    }
+
+    private isTestnet(): boolean {
+        return this.network === networks.testnet || this.network === networks.regtest;
+    }
+}

package/src/opnet.ts

@@ -9,9 +9,12 @@ export * from './generators/builders/CustomGenerator.js';
 export * from './generators/builders/DeploymentGenerator.js';
 export * from './generators/builders/LegacyCalldataGenerator.js';
 export * from './generators/builders/MultiSignGenerator.js';
+export * from './generators/builders/MineableReward.js';
 export * from './generators/Features.js';
 export * from './generators/Generator.js';
 
+export * from './transaction/mineable/ChallengeGenerator.js';
+
 /** Address */
 export * from './generators/AddressGenerator.js';
 export * from './verification/TapscriptVerificator.js';
@@ -44,6 +47,7 @@ export * from './transaction/builders/InteractionTransaction.js';
 export * from './transaction/builders/MultiSignTransaction.js';
 export * from './transaction/builders/SharedInteractionTransaction.js';
 export * from './transaction/builders/TransactionBuilder.js';
+export * from './transaction/builders/ChallengeSolutionTransaction.js';
 
 /** Utils */
 export * from './utils/BitcoinUtils.js';
@@ -87,6 +91,7 @@ export * from './transaction/browser/extensions/UnisatSigner.js';
 export * from './transaction/browser/extensions/XverseSigner.js';
 export * from './transaction/browser/types/Unisat.js';
 export * from './transaction/browser/types/Xverse.js';
+export * from './transaction/browser/WalletConnection.js';
 
 export * from './metadata/tokens.js';
 export * from './transaction/browser/Web3Provider.js';

package/src/transaction/ContractAddress.ts

@@ -4,10 +4,14 @@ class ContractAddressBase {
     private readonly deriver: Secp256k1PointDeriver = new Secp256k1PointDeriver();
 
     public generateHybridKeyFromHash(input: Buffer): Buffer {
-        const p = this.deriver.findOrDeriveValidPoint(Buffer.copyBytesFrom(input), false);
+        const p = this.deriver.findOrDeriveValidPoint(this.cloneBuffer(input), false);
         const y = this.deriver.getCanonicalY(p.y1, p.y2);
         return Buffer.from(this.deriver.getHybridPublicKey(p.x, y));
     }
+
+    private cloneBuffer(buffer: Buffer): Buffer {
+        return Buffer.from(buffer);
+    }
 }
 
 export const ContractAddress = new ContractAddressBase();