@btc-vision/transaction 1.0.93 → 1.0.94

package/browser/transaction/browser/Web3Provider.d.ts

@@ -1,6 +1,10 @@
-import { IInteractionParameters } from '../interfaces/ITransactionParameters.js';
+import { IDeploymentParameters, IInteractionParameters, IUnwrapParameters, IWrapParameters } from '../interfaces/ITransactionParameters.js';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
+import { DeploymentResult, UnwrapResult, WrapResult } from '../TransactionFactory';
 export type InteractionParametersWithoutSigner = Omit<IInteractionParameters, 'signer'>;
+export type IWrapParametersWithoutSigner = Omit<IWrapParameters, 'signer'>;
+export type IUnwrapParametersSigner = Omit<IUnwrapParameters, 'signer'>;
+export type IDeploymentParametersWithoutSigner = Omit<IDeploymentParameters, 'signer' | 'network'>;
 export interface BroadcastTransactionOptions {
     raw: string;
     psbt: boolean;
@@ -15,5 +19,8 @@ export interface BroadcastedTransaction {
 export interface Web3Provider {
     signInteraction(interactionParameters: InteractionParametersWithoutSigner): Promise<[string, string, UTXO[]]>;
     signAndBroadcastInteraction(interactionParameters: InteractionParametersWithoutSigner): Promise<[BroadcastedTransaction, BroadcastedTransaction, UTXO[]]>;
+    deployContract(params: IDeploymentParametersWithoutSigner): Promise<DeploymentResult>;
     broadcast(transactions: BroadcastTransactionOptions[]): Promise<BroadcastedTransaction[]>;
+    wrap(wrapParameters: IWrapParametersWithoutSigner): Promise<WrapResult>;
+    unwrap(unwrapParameters: IUnwrapParametersSigner): Promise<UnwrapResult>;
 }

package/browser/transaction/browser/extensions/UnisatSigner.d.ts

@@ -6,6 +6,7 @@ import { Address } from '@btc-vision/bsi-binary';
 declare global {
     interface Window {
         unisat?: Unisat;
+        opnet?: Unisat;
     }
 }
 export declare class UnisatSigner extends CustomKeypair {

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.0.93";
+export declare const version = "1.0.94";

package/build/_version.js

@@ -1 +1 @@
-export const version = '1.0.93';
+export const version = '1.0.94';

package/build/generators/builders/DeploymentGeneratorV2.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Network } from 'bitcoinjs-lib';
+import { Generator } from '../Generator.js';
+export declare class DeploymentGeneratorV2 extends Generator {
+    static readonly DATA_CHUNK_SIZE: number;
+    constructor(senderPubKey: Buffer, contractSaltPubKey: Buffer, network?: Network);
+    compile(contractBytecode: Buffer, contractSalt: Buffer): {
+        compiled: Buffer;
+        chunks: Buffer[];
+    };
+    protected splitBufferIntoChunks(buffer: Buffer, chunkSize?: number): Array<Buffer[]>;
+    private getAsm;
+}

package/build/generators/builders/DeploymentGeneratorV2.js

@@ -0,0 +1,57 @@
+import { crypto, networks, opcodes, script } from 'bitcoinjs-lib';
+import { Generator } from '../Generator.js';
+export class DeploymentGeneratorV2 extends Generator {
+    static DATA_CHUNK_SIZE = 80;
+    constructor(senderPubKey, contractSaltPubKey, network = networks.bitcoin) {
+        super(senderPubKey, contractSaltPubKey, network);
+    }
+    compile(contractBytecode, contractSalt) {
+        const dataChunks = this.splitBufferIntoChunks(contractBytecode);
+        const asm = this.getAsm(dataChunks, contractSalt);
+        const compiled = script.compile(asm);
+        const decompiled = script.decompile(compiled);
+        if (!decompiled) {
+            throw new Error('Failed to decompile script??');
+        }
+        return {
+            compiled,
+            chunks: dataChunks.flat(),
+        };
+    }
+    splitBufferIntoChunks(buffer, chunkSize = DeploymentGeneratorV2.DATA_CHUNK_SIZE) {
+        const chunks = [];
+        for (let i = 0; i < buffer.length; i += chunkSize) {
+            const dataLength = Math.min(chunkSize, buffer.length - i);
+            const buf2 = Buffer.alloc(dataLength);
+            for (let j = 0; j < dataLength; j++) {
+                buf2.writeUInt8(buffer[i + j], j);
+            }
+            chunks.push([buf2]);
+        }
+        return chunks;
+    }
+    getAsm(dataChunks, contractSalt) {
+        const partA = [
+            this.senderPubKey,
+            opcodes.OP_CHECKSIGVERIFY,
+            this.contractSaltPubKey,
+            opcodes.OP_CHECKSIGVERIFY,
+            opcodes.OP_HASH160,
+            crypto.hash160(this.senderPubKey),
+            opcodes.OP_EQUALVERIFY,
+            opcodes.OP_HASH256,
+            crypto.hash256(contractSalt),
+            opcodes.OP_EQUALVERIFY,
+        ];
+        let i = 1;
+        for (const chunk of dataChunks) {
+            if (i % 80 === 0 && i !== 0) {
+                partA.push(...[opcodes.OP_SHA1, crypto.sha1(chunk[0]), opcodes.OP_EQUALVERIFY]);
+            }
+            partA.push(...[opcodes.OP_TOALTSTACK]);
+            i++;
+        }
+        partA.push(...[opcodes.OP_1]);
+        return partA.flat();
+    }
+}

package/build/transaction/browser/Web3Provider.d.ts

@@ -1,6 +1,10 @@
-import { IInteractionParameters } from '../interfaces/ITransactionParameters.js';
+import { IDeploymentParameters, IInteractionParameters, IUnwrapParameters, IWrapParameters } from '../interfaces/ITransactionParameters.js';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
+import { DeploymentResult, UnwrapResult, WrapResult } from '../TransactionFactory';
 export type InteractionParametersWithoutSigner = Omit<IInteractionParameters, 'signer'>;
+export type IWrapParametersWithoutSigner = Omit<IWrapParameters, 'signer'>;
+export type IUnwrapParametersSigner = Omit<IUnwrapParameters, 'signer'>;
+export type IDeploymentParametersWithoutSigner = Omit<IDeploymentParameters, 'signer' | 'network'>;
 export interface BroadcastTransactionOptions {
     raw: string;
     psbt: boolean;
@@ -15,5 +19,8 @@ export interface BroadcastedTransaction {
 export interface Web3Provider {
     signInteraction(interactionParameters: InteractionParametersWithoutSigner): Promise<[string, string, UTXO[]]>;
     signAndBroadcastInteraction(interactionParameters: InteractionParametersWithoutSigner): Promise<[BroadcastedTransaction, BroadcastedTransaction, UTXO[]]>;
+    deployContract(params: IDeploymentParametersWithoutSigner): Promise<DeploymentResult>;
     broadcast(transactions: BroadcastTransactionOptions[]): Promise<BroadcastedTransaction[]>;
+    wrap(wrapParameters: IWrapParametersWithoutSigner): Promise<WrapResult>;
+    unwrap(unwrapParameters: IUnwrapParametersSigner): Promise<UnwrapResult>;
 }

package/build/transaction/browser/extensions/UnisatSigner.d.ts

@@ -6,6 +6,7 @@ import { Address } from '@btc-vision/bsi-binary';
 declare global {
     interface Window {
         unisat?: Unisat;
+        opnet?: Unisat;
     }
 }
 export declare class UnisatSigner extends CustomKeypair {

package/build/transaction/browser/extensions/UnisatSigner.js

@@ -67,7 +67,7 @@ export class UnisatSigner extends CustomKeypair {
                 this._network = networks.regtest;
                 break;
             default:
-                throw new Error('Invalid network');
+                throw new Error(`Invalid network: ${network}`);
         }
         const publicKey = await this.unisat.getPublicKey();
         this._publicKey = Buffer.from(publicKey, 'hex');

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

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import { TransactionType } from '../enums/TransactionType.js';
+import { IDeploymentParameters } from '../interfaces/ITransactionParameters.js';
+import { Payment, Psbt } from 'bitcoinjs-lib';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { TapLeafScript } from '../interfaces/Tap.js';
+import { Address } from '@btc-vision/bsi-binary';
+export declare class DeploymentTransactionV2 extends TransactionBuilder<TransactionType.DEPLOYMENT> {
+    type: TransactionType.DEPLOYMENT;
+    protected readonly _contractAddress: Address;
+    protected tapLeafScript: TapLeafScript | null;
+    private targetScriptRedeem;
+    private leftOverFundsScriptRedeem;
+    private readonly compiledTargetScript;
+    private readonly scriptTree;
+    private deploymentGenerator;
+    private readonly contractSeed;
+    private readonly bytecode;
+    private readonly contractSigner;
+    private readonly randomBytes;
+    constructor(parameters: IDeploymentParameters);
+    get contractAddress(): Address;
+    get p2trAddress(): Address;
+    getRndBytes(): Buffer;
+    protected contractSignerXOnlyPubKey(): Buffer;
+    protected buildTransaction(): Promise<void>;
+    protected signInputs(transaction: Psbt): Promise<void>;
+    protected generateScriptAddress(): Payment;
+    protected generateTapData(): Payment;
+    private getContractSeed;
+    private customFinalizer;
+    private getPubKeys;
+    private generateRedeemScripts;
+    private getLeafScript;
+    private getScriptTree;
+}

package/build/transaction/builders/DeploymentTransactionV2.js

@@ -0,0 +1,192 @@
+import { TransactionType } from '../enums/TransactionType.js';
+import { crypto as bitCrypto } from 'bitcoinjs-lib';
+import { TransactionBuilder } from './TransactionBuilder.js';
+import { toXOnly } from 'bitcoinjs-lib/src/psbt/bip371.js';
+import { EcKeyPair } from '../../keypair/EcKeyPair.js';
+import { BitcoinUtils } from '../../utils/BitcoinUtils.js';
+import { Compressor } from '../../bytecode/Compressor.js';
+import { AddressGenerator } from '../../generators/AddressGenerator.js';
+import { DeploymentGeneratorV2 } from '../../generators/builders/DeploymentGeneratorV2.js';
+export class DeploymentTransactionV2 extends TransactionBuilder {
+    type = TransactionType.DEPLOYMENT;
+    _contractAddress;
+    tapLeafScript = null;
+    targetScriptRedeem = null;
+    leftOverFundsScriptRedeem = null;
+    compiledTargetScript;
+    scriptTree;
+    deploymentGenerator;
+    contractSeed;
+    bytecode;
+    contractSigner;
+    randomBytes;
+    constructor(parameters) {
+        super(parameters);
+        this.bytecode = Compressor.compress(parameters.bytecode);
+        if (!this.bytecode)
+            throw new Error('Bytecode is required');
+        this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
+        this.contractSeed = this.getContractSeed();
+        this.contractSigner = EcKeyPair.fromSeedKeyPair(this.contractSeed, this.network);
+        this.deploymentGenerator = new DeploymentGeneratorV2(this.internalPubKeyToXOnly(), this.contractSignerXOnlyPubKey(), this.network);
+        this.compiledTargetScript = this.deploymentGenerator.compile(this.bytecode, this.randomBytes);
+        this.scriptTree = this.getScriptTree();
+        this.internalInit();
+        this._contractAddress = AddressGenerator.generatePKSH(this.contractSeed, this.network);
+    }
+    get contractAddress() {
+        return this._contractAddress;
+    }
+    get p2trAddress() {
+        return this.to || this.getScriptAddress();
+    }
+    getRndBytes() {
+        return this.randomBytes;
+    }
+    contractSignerXOnlyPubKey() {
+        return toXOnly(this.contractSigner.publicKey);
+    }
+    async buildTransaction() {
+        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 = this.getTransactionOPNetFee();
+        this.addOutput({
+            value: Number(amountSpent),
+            address: this.to,
+        });
+        await this.addRefundOutput(amountSpent);
+    }
+    async signInputs(transaction) {
+        if (!this.contractSigner) {
+            await super.signInputs(transaction);
+            return;
+        }
+        for (let i = 0; i < transaction.data.inputs.length; i++) {
+            if (i === 0) {
+                transaction.signInput(0, this.contractSigner);
+                transaction.signInput(0, this.getSignerKey());
+                transaction.finalizeInput(0, this.customFinalizer);
+            }
+            else {
+                transaction.signInput(i, this.getSignerKey());
+                transaction.finalizeInput(i);
+            }
+        }
+    }
+    generateScriptAddress() {
+        return {
+            internalPubkey: this.internalPubKeyToXOnly(),
+            network: this.network,
+            scriptTree: this.scriptTree,
+        };
+    }
+    generateTapData() {
+        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,
+        };
+    }
+    getContractSeed() {
+        if (!this.bytecode) {
+            throw new Error('Bytecode is required');
+        }
+        const deployerPubKey = this.internalPubKeyToXOnly();
+        const salt = bitCrypto.hash256(this.randomBytes);
+        const sha256OfBytecode = bitCrypto.hash256(this.bytecode);
+        const buf = Buffer.concat([deployerPubKey, salt, sha256OfBytecode]);
+        return bitCrypto.hash256(buf);
+    }
+    customFinalizer = (_inputIndex, input) => {
+        if (!this.tapLeafScript) {
+            throw new Error('Tap leaf script is required');
+        }
+        if (!input.tapScriptSig) {
+            throw new Error('Tap script signature is required');
+        }
+        const chunks = this.compiledTargetScript.chunks
+            .slice(0, this.compiledTargetScript.chunks.length)
+            .reverse();
+        const scriptSolution = [
+            ...chunks,
+            this.randomBytes,
+            this.internalPubKeyToXOnly(),
+            input.tapScriptSig[0].signature,
+            input.tapScriptSig[1].signature,
+        ];
+        console.log('length', scriptSolution.length);
+        const witness = scriptSolution
+            .concat(this.tapLeafScript.script)
+            .concat(this.tapLeafScript.controlBlock);
+        return {
+            finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness(witness),
+        };
+    };
+    getPubKeys() {
+        const pubkeys = [this.signer.publicKey];
+        if (this.contractSigner) {
+            pubkeys.push(this.contractSigner.publicKey);
+        }
+        return pubkeys;
+    }
+    generateRedeemScripts() {
+        this.targetScriptRedeem = {
+            pubkeys: this.getPubKeys(),
+            output: this.compiledTargetScript.compiled,
+            redeemVersion: 192,
+        };
+        this.leftOverFundsScriptRedeem = {
+            pubkeys: this.getPubKeys(),
+            output: this.getLeafScript(),
+            redeemVersion: 192,
+        };
+    }
+    getLeafScript() {
+        return TransactionBuilder.LOCK_LEAF_SCRIPT;
+    }
+    getScriptTree() {
+        if (!this.bytecode) {
+            throw new Error('Contract bytecode is required');
+        }
+        this.generateRedeemScripts();
+        return [
+            {
+                output: this.compiledTargetScript.compiled,
+                version: 192,
+            },
+            {
+                output: this.getLeafScript(),
+                version: 192,
+            },
+        ];
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "type": "module",
-    "version": "1.0.93",
+    "version": "1.0.94",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.0.93';
+export const version = '1.0.94';

package/src/generators/Generator.ts

@@ -1,75 +1,75 @@
-import { Network, networks } from 'bitcoinjs-lib';
-
-/** Bitcoin Script Generator */
-export abstract class Generator {
-    /**
-     * The maximum size of a data chunk
-     */
-    public static readonly DATA_CHUNK_SIZE: number = 512;
-
-    /**
-     * The magic number of OPNet
-     */
-    public static readonly MAGIC: Buffer = Buffer.from('bsi', 'utf-8');
-
-    /**
-     * The public key of the sender
-     * @protected
-     */
-    protected readonly senderPubKey: Buffer;
-
-    /**
-     * The public key of the contract salt
-     * @protected
-     */
-    protected readonly contractSaltPubKey: Buffer;
-
-    /**
-     * The network to use
-     * @protected
-     */
-    protected readonly network: Network = networks.bitcoin;
-
-    protected constructor(
-        senderPubKey: Buffer,
-        contractSaltPubKey: Buffer,
-        network: Network = networks.bitcoin,
-    ) {
-        this.senderPubKey = senderPubKey;
-        this.contractSaltPubKey = contractSaltPubKey;
-        this.network = network;
-    }
-
-    /**
-     * Compile the script
-     * @param args - The arguments to use when compiling the script
-     * @returns {Buffer} - The compiled script
-     */
-    public abstract compile(...args: unknown[]): Buffer;
-
-    /**
-     * Split a buffer into chunks
-     * @param {Buffer} buffer - The buffer to split
-     * @param {number} chunkSize - The size of each chunk
-     * @protected
-     * @returns {Array<Buffer[]>} - The chunks
-     */
-    protected splitBufferIntoChunks(
-        buffer: Buffer,
-        chunkSize: number = Generator.DATA_CHUNK_SIZE,
-    ): Array<Buffer[]> {
-        const chunks: Array<Buffer[]> = [];
-        for (let i = 0; i < buffer.length; i += chunkSize) {
-            const dataLength = Math.min(chunkSize, buffer.length - i);
-
-            const buf2 = Buffer.alloc(dataLength);
-            for (let j = 0; j < dataLength; j++) {
-                buf2.writeUInt8(buffer[i + j], j);
-            }
-
-            chunks.push([buf2]);
-        }
-
-        return chunks;
-    }
-}
+import { Network, networks } from 'bitcoinjs-lib';
+
+/** Bitcoin Script Generator */
+export abstract class Generator {
+    /**
+     * The maximum size of a data chunk
+     */
+    public static readonly DATA_CHUNK_SIZE: number = 512;
+
+    /**
+     * The magic number of OPNet
+     */
+    public static readonly MAGIC: Buffer = Buffer.from('bsi', 'utf-8');
+
+    /**
+     * The public key of the sender
+     * @protected
+     */
+    protected readonly senderPubKey: Buffer;
+
+    /**
+     * The public key of the contract salt
+     * @protected
+     */
+    protected readonly contractSaltPubKey: Buffer;
+
+    /**
+     * The network to use
+     * @protected
+     */
+    protected readonly network: Network = networks.bitcoin;
+
+    protected constructor(
+        senderPubKey: Buffer,
+        contractSaltPubKey: Buffer,
+        network: Network = networks.bitcoin,
+    ) {
+        this.senderPubKey = senderPubKey;
+        this.contractSaltPubKey = contractSaltPubKey;
+        this.network = network;
+    }
+
+    /**
+     * Compile the script
+     * @param args - The arguments to use when compiling the script
+     * @returns {Buffer} - The compiled script
+     */
+    public abstract compile(...args: unknown[]): Buffer;
+
+    /**
+     * Split a buffer into chunks
+     * @param {Buffer} buffer - The buffer to split
+     * @param {number} chunkSize - The size of each chunk
+     * @protected
+     * @returns {Array<Buffer[]>} - The chunks
+     */
+    protected splitBufferIntoChunks(
+        buffer: Buffer,
+        chunkSize: number = Generator.DATA_CHUNK_SIZE,
+    ): Array<Buffer[]> {
+        const chunks: Array<Buffer[]> = [];
+        for (let i = 0; i < buffer.length; i += chunkSize) {
+            const dataLength = Math.min(chunkSize, buffer.length - i);
+
+            const buf2 = Buffer.alloc(dataLength);
+            for (let j = 0; j < dataLength; j++) {
+                buf2.writeUInt8(buffer[i + j], j);
+            }
+
+            chunks.push([buf2]);
+        }
+
+        return chunks;
+    }
+}