@btc-vision/transaction 1.3.4 → 1.3.6

package/src/generators/Generator.ts

@@ -1,5 +1,8 @@
 import { Network, networks, toXOnly } from '@btc-vision/bitcoin';
 import { BinaryWriter } from '../buffer/BinaryWriter.js';
+import { AccessListFeature, Feature, Features } from './Features.js';
+import { Address } from '../keypair/Address.js';
+import { Compressor } from '../bytecode/Compressor.js';
 
 /** Bitcoin Script Generator */
 export abstract class Generator {
@@ -48,13 +51,22 @@ export abstract class Generator {
         this.xSenderPubKey = toXOnly(senderPubKey);
     }
 
-    public get senderFirstByte(): Buffer {
-        return Buffer.from([this.senderPubKey[0], 0, 0, 0]);
+    public buildHeader(features: Features[]): Buffer {
+        let flags: number = 0;
+
+        for (const feature of features) {
+            flags |= feature;
+        }
+
+        const bytesU24 = Buffer.alloc(3);
+        bytesU24.writeUIntBE(flags, 0, 3);
+
+        return Buffer.from([this.senderPubKey[0], ...bytesU24]);
     }
 
-    public getHeader(maxPriority: bigint): Buffer {
-        const writer = new BinaryWriter(8 + 4);
-        writer.writeBytes(this.senderFirstByte);
+    public getHeader(maxPriority: bigint, features: Features[] = []): Buffer {
+        const writer = new BinaryWriter(12);
+        writer.writeBytes(this.buildHeader(features));
         writer.writeU64(maxPriority);
 
         return Buffer.from(writer.getBuffer());
@@ -92,4 +104,41 @@ export abstract class Generator {
 
         return chunks;
     }
+
+    protected encodeFeature(feature: Feature<Features>): Buffer[][] {
+        switch (feature.opcode) {
+            case Features.ACCESS_LIST:
+                return this.splitBufferIntoChunks(
+                    this.encodeAccessListFeature(feature as AccessListFeature),
+                );
+            default:
+                throw new Error(`Unknown feature type: ${feature.opcode}`);
+        }
+    }
+
+    private encodeAccessListFeature(feature: AccessListFeature): Buffer {
+        const writer = new BinaryWriter();
+
+        writer.writeU16(Object.keys(feature.data).length);
+
+        for (const contract in feature.data) {
+            const parsedContract = Address.fromString(contract);
+            const data = feature.data[contract];
+
+            writer.writeAddress(parsedContract);
+            writer.writeU32(data.length);
+
+            for (const pointer of data) {
+                const pointerBuffer = Buffer.from(pointer, 'base64');
+
+                if (pointerBuffer.length !== 32) {
+                    throw new Error(`Invalid pointer length: ${pointerBuffer.length}`);
+                }
+
+                writer.writeBytes(pointerBuffer);
+            }
+        }
+
+        return Compressor.compress(Buffer.from(writer.getBuffer()));
+    }
 }

package/src/generators/builders/CalldataGenerator.ts

@@ -2,9 +2,8 @@ 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';
-import { FeatureOpCodes, Features } from '../Features.js';
+import { Feature, Features } from '../Features.js';
 import { Generator } from '../Generator.js';
-import { BinaryWriter } from '../../buffer/BinaryWriter.js';
 
 /**
  * Class to generate bitcoin script for interaction transactions
@@ -59,7 +58,7 @@ export class CalldataGenerator extends Generator {
      * @param {Buffer} contractSecret - The contract secret
      * @param preimage
      * @param maxPriority - Amount of satoshis to spend max on priority fee
-     * @param {number[]} [features=[]] - The features to use (optional)
+     * @param {Feature<Features>[]} features - The features to use
      * @returns {Buffer} - The compiled script
      * @throws {Error} - If something goes wrong
      */
@@ -68,15 +67,25 @@ export class CalldataGenerator extends Generator {
         contractSecret: Buffer,
         preimage: Buffer,
         maxPriority: bigint,
-        features: Features[] = [],
+        features: Feature<Features>[] = [],
     ): 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');
 
-        let compiledData = [
-            this.getHeader(maxPriority),
+        const featuresList: Features[] = [];
+        const featureData: (number | Buffer | Buffer[])[] = [];
+        for (let i = 0; i < features.length; i++) {
+            const feature = features[i];
+            featuresList.push(feature.opcode);
+
+            const data = this.encodeFeature(feature);
+            featureData.push(...data);
+        }
+
+        let compiledData: (number | Buffer | Buffer[])[] = [
+            this.getHeader(maxPriority, featuresList),
             opcodes.OP_TOALTSTACK,
 
             // CHALLENGE PREIMAGE FOR REWARD,
@@ -105,11 +114,9 @@ export class CalldataGenerator extends Generator {
             Generator.MAGIC,
         ];
 
-        const featureOpcodes = features.map((feature) => FeatureOpCodes[feature]); // Get the opcodes for the features
-
         // Write calldata
         compiledData = compiledData.concat(
-            ...featureOpcodes,
+            ...featureData,
             ...[opcodes.OP_1NEGATE, ...dataChunks, opcodes.OP_ELSE, opcodes.OP_1, opcodes.OP_ENDIF],
         );
 

package/src/generators/builders/DeploymentGenerator.ts

@@ -1,5 +1,6 @@
 import { crypto, Network, networks, opcodes, script } from '@btc-vision/bitcoin';
 import { Generator } from '../Generator.js';
+import { Feature, Features } from '../Features.js';
 
 export class DeploymentGenerator extends Generator {
     constructor(
@@ -46,14 +47,28 @@ export class DeploymentGenerator extends Generator {
         preimage: Buffer,
         maxPriority: bigint,
         calldata?: Buffer,
+        features?: Feature<Features>[],
     ): (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 featuresList: Features[] = [];
+        const featureData: (number | Buffer | Buffer[])[] = [];
+
+        if (features) {
+            for (let i = 0; i < features.length; i++) {
+                const feature = features[i];
+                featuresList.push(feature.opcode);
+
+                const data = this.encodeFeature(feature);
+                featureData.push(...data);
+            }
+        }
+
         const compiledData = [
-            this.getHeader(maxPriority),
+            this.getHeader(maxPriority, featuresList),
             opcodes.OP_TOALTSTACK,
 
             // CHALLENGE PREIMAGE FOR REWARD,
@@ -80,6 +95,7 @@ export class DeploymentGenerator extends Generator {
             opcodes.OP_IF,
 
             Generator.MAGIC,
+            ...featureData,
             opcodes.OP_0,
             ...calldataChunks,
             opcodes.OP_1NEGATE,

package/src/generators/builders/LegacyCalldataGenerator.ts

@@ -2,8 +2,8 @@ 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';
-import { FeatureOpCodes, Features } from '../Features.js';
 import { Generator } from '../Generator.js';
+import { Feature, Features } from '../Features.js';
 
 /**
  * Class to generate bitcoin script for interaction transactions
@@ -63,13 +63,23 @@ export class LegacyCalldataGenerator extends Generator {
         contractSecret: Buffer,
         preimage: Buffer,
         maxPriority: bigint,
-        features: Features[] = [],
+        features: Feature<Features>[] = [],
     ): Buffer {
         const dataChunks: Buffer[][] = this.splitBufferIntoChunks(calldata);
         if (!dataChunks.length) throw new Error('No data chunks found');
 
+        const featuresList: Features[] = [];
+        const featureData: (number | Buffer | Buffer[])[] = [];
+        for (let i = 0; i < features.length; i++) {
+            const feature = features[i];
+            featuresList.push(feature.opcode);
+
+            const data = this.encodeFeature(feature);
+            featureData.push(...data);
+        }
+
         let compiledData = [
-            this.getHeader(maxPriority),
+            this.getHeader(maxPriority, featuresList),
             opcodes.OP_TOALTSTACK,
 
             // CHALLENGE PREIMAGE FOR REWARD,
@@ -94,11 +104,9 @@ export class LegacyCalldataGenerator extends Generator {
             Generator.MAGIC,
         ];
 
-        const featureOpcodes = features.map((feature) => FeatureOpCodes[feature]); // Get the opcodes for the features
-
         // Write calldata
         compiledData = compiledData.concat(
-            ...featureOpcodes,
+            ...featureData,
             ...[opcodes.OP_1NEGATE, ...dataChunks, opcodes.OP_ELSE, opcodes.OP_1, opcodes.OP_ENDIF],
         );
 

package/src/opnet.ts

@@ -1,3 +1,5 @@
+import { Unisat } from './transaction/browser/types/Unisat.js';
+
 export { version } from './_version.js';
 
 /** Bytecode */
@@ -97,3 +99,10 @@ export * from './transaction/browser/Web3Provider.js';
 
 export * from './keypair/Secp256k1PointDeriver.js';
 export * from './transaction/ContractAddress.js';
+
+declare global {
+    interface Window {
+        unisat?: Unisat;
+        opnet?: Unisat;
+    }
+}

package/src/transaction/TransactionFactory.ts

@@ -19,7 +19,11 @@ import {
 } from './interfaces/ITransactionParameters.js';
 import { PSBTTypes } from './psbt/PSBTTypes.js';
 import { ChallengeSolutionTransaction } from './builders/ChallengeSolutionTransaction.js';
-import { InteractionParametersWithoutSigner } from './browser/Web3Provider.js';
+import {
+    IDeploymentParametersWithoutSigner,
+    InteractionParametersWithoutSigner,
+} from './browser/Web3Provider.js';
+import { WindowWithWallets } from './browser/extensions/UnisatSigner.js';
 
 export interface DeploymentResult {
     readonly transaction: [string, string];
@@ -174,26 +178,7 @@ export class TransactionFactory {
             throw new Error('Field "signer" not provided, OP_WALLET not detected.');
         }
 
-        const inputs = (interactionParameters.optionalInputs || []).map((input) => {
-            let nonWitness = input.nonWitnessUtxo;
-            if (
-                nonWitness &&
-                !(nonWitness instanceof Uint8Array) &&
-                typeof nonWitness === 'object'
-            ) {
-                nonWitness = Buffer.from(
-                    Uint8Array.from(
-                        Object.values(input.nonWitnessUtxo as unknown as Record<number, number>),
-                    ),
-                );
-            }
-
-            return {
-                ...input,
-                nonWitnessUtxo: nonWitness,
-            };
-        });
-
+        const inputs = this.parseOptionalInputs(interactionParameters.optionalInputs);
         const preTransaction: InteractionTransaction = new InteractionTransaction({
             ...interactionParameters,
             utxos: [interactionParameters.utxos[0]], // we simulate one input here.
@@ -277,21 +262,46 @@ export class TransactionFactory {
     public async signDeployment(
         deploymentParameters: IDeploymentParameters,
     ): Promise<DeploymentResult> {
-        const preTransaction: DeploymentTransaction = new DeploymentTransaction(
-            deploymentParameters,
-        );
+        const opWalletDeployment = await this.detectDeploymentOPWallet(deploymentParameters);
+        if (opWalletDeployment) {
+            return opWalletDeployment;
+        }
 
-        // Initial generation
-        await preTransaction.signTransaction();
+        if (!('signer' in deploymentParameters)) {
+            throw new Error('Field "signer" not provided, OP_WALLET not detected.');
+        }
+
+        const inputs = this.parseOptionalInputs(deploymentParameters.optionalInputs);
+        const preTransaction: DeploymentTransaction = new DeploymentTransaction({
+            ...deploymentParameters,
+            utxos: [deploymentParameters.utxos[0]], // we simulate one input here.
+            optionalInputs: inputs,
+        });
+
+        // we don't sign that transaction, we just need the parameters.
+        await preTransaction.generateTransactionMinimalSignatures();
 
         const parameters: IFundingTransactionParameters =
             await preTransaction.getFundingTransactionParameters();
 
+        parameters.utxos = deploymentParameters.utxos;
         parameters.amount =
             (await preTransaction.estimateTransactionFees()) +
             this.getPriorityFee(deploymentParameters) +
             preTransaction.getOptionalOutputValue();
 
+        const feeEstimationFundingTransaction = await this.createFundTransaction({
+            ...parameters,
+            optionalOutputs: [],
+            optionalInputs: [],
+        });
+
+        if (!feeEstimationFundingTransaction) {
+            throw new Error('Could not sign funding transaction.');
+        }
+
+        parameters.estimatedFees = feeEstimationFundingTransaction.estimatedFees;
+
         const fundingTransaction: FundingTransaction = new FundingTransaction({
             ...parameters,
             optionalInputs: [],
@@ -316,12 +326,12 @@ export class TransactionFactory {
 
         const newParams: IDeploymentParameters = {
             ...deploymentParameters,
-            utxos: [newUtxo],
+            utxos: [newUtxo], // always 0
             randomBytes: preTransaction.getRndBytes(),
             preimage: preTransaction.getPreimage(),
             nonWitnessUtxo: signedTransaction.toBuffer(),
-            optionalOutputs: [],
-            optionalInputs: [],
+            estimatedFees: preTransaction.estimatedFees,
+            optionalInputs: inputs,
         };
 
         const finalTransaction: DeploymentTransaction = new DeploymentTransaction(newParams);
@@ -420,14 +430,41 @@ export class TransactionFactory {
         return utxos;
     }
 
+    private parseOptionalInputs(optionalInputs?: UTXO[]): UTXO[] {
+        return (optionalInputs || []).map((input) => {
+            let nonWitness = input.nonWitnessUtxo;
+            if (
+                nonWitness &&
+                !(nonWitness instanceof Uint8Array) &&
+                typeof nonWitness === 'object'
+            ) {
+                nonWitness = Buffer.from(
+                    Uint8Array.from(
+                        Object.values(input.nonWitnessUtxo as unknown as Record<number, number>),
+                    ),
+                );
+            }
+
+            return {
+                ...input,
+                nonWitnessUtxo: nonWitness,
+            };
+        });
+    }
+
     private async detectInteractionOPWallet(
         interactionParameters: IInteractionParameters | InteractionParametersWithoutSigner,
     ): Promise<InteractionResponse | null> {
-        if (typeof window === 'undefined' || !window || !window.opnet || !window.opnet.web3) {
+        if (typeof window === 'undefined') {
+            return null;
+        }
+
+        const _window = window as WindowWithWallets;
+        if (!_window || !_window.opnet || !_window.opnet.web3) {
             return null;
         }
 
-        const opnet = window.opnet.web3;
+        const opnet = _window.opnet.web3;
         const interaction = await opnet.signInteraction({
             ...interactionParameters,
 
@@ -442,6 +479,33 @@ export class TransactionFactory {
         return interaction;
     }
 
+    private async detectDeploymentOPWallet(
+        deploymentParameters: IDeploymentParameters | IDeploymentParametersWithoutSigner,
+    ): Promise<DeploymentResult | null> {
+        if (typeof window === 'undefined') {
+            return null;
+        }
+
+        const _window = window as WindowWithWallets;
+        if (!_window || !_window.opnet || !_window.opnet.web3) {
+            return null;
+        }
+
+        const opnet = _window.opnet.web3;
+        const deployment = await opnet.deployContract({
+            ...deploymentParameters,
+
+            // @ts-expect-error no, this is ok
+            signer: undefined,
+        });
+
+        if (!deployment) {
+            throw new Error('Could not sign interaction transaction.');
+        }
+
+        return deployment;
+    }
+
     private async _createChallengeSolution(
         parameters: IChallengeSolutionTransactionParameters,
     ): Promise<ChallengeSolutionResponse> {

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

@@ -14,11 +14,9 @@ import { canSignNonTaprootInput, isTaprootInput } from '../../../signer/SignerUt
 import { CustomKeypair } from '../BrowserSignerBase.js';
 import { PsbtSignatureOptions, SignatureType, Unisat, UnisatNetwork } from '../types/Unisat.js';
 
-declare global {
-    interface Window {
-        unisat?: Unisat;
-        opnet?: Unisat;
-    }
+export interface WindowWithWallets {
+    unisat?: Unisat;
+    opnet?: Unisat;
 }
 
 export class UnisatSigner extends CustomKeypair {
@@ -85,7 +83,7 @@ export class UnisatSigner extends CustomKeypair {
     public get unisat(): Unisat {
         if (!window) throw new Error('Window not found');
 
-        const module = window.unisat;
+        const module = (window as WindowWithWallets).unisat;
         if (!module) {
             throw new Error('Unisat extension not found');
         }

package/src/transaction/builders/DeploymentTransaction.ts

@@ -118,7 +118,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
             this.verifyCalldata();
         }
 
-        if(!parameters.preimage) throw new Error('Preimage is required');
+        if (!parameters.preimage) throw new Error('Preimage is required');
 
         this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
         this.preimage = parameters.preimage;
@@ -274,7 +274,11 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
             if (i === 0) {
                 transaction.finalizeInput(i, this.customFinalizer);
             } else {
-                transaction.finalizeInput(i);
+                try {
+                    transaction.finalizeInput(i, this.customFinalizerP2SH);
+                } catch (e) {
+                    transaction.finalizeInput(i);
+                }
             }
         }
     }
@@ -305,7 +309,12 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
                 transaction.finalizeInput(0, this.customFinalizer);
             } else {
                 transaction.signInput(i, this.getSignerKey());
-                transaction.finalizeInput(i);
+
+                try {
+                    transaction.finalizeInput(i, this.customFinalizerP2SH);
+                } catch (e) {
+                    transaction.finalizeInput(i);
+                }
             }
         }
     }

package/src/transaction/builders/InteractionTransaction.ts

@@ -3,6 +3,7 @@ import { TransactionType } from '../enums/TransactionType.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { IInteractionParameters } from '../interfaces/ITransactionParameters.js';
 import { SharedInteractionTransaction } from './SharedInteractionTransaction.js';
+import { Feature, Features } from '../../generators/Features.js';
 
 /**
  * Class for interaction transactions
@@ -32,9 +33,23 @@ export class InteractionTransaction extends SharedInteractionTransaction<Transac
             this.contractSecret,
             this.preimage,
             this.priorityFee,
+            this.generateFeatures(parameters),
         );
 
         this.scriptTree = this.getScriptTree();
         this.internalInit();
     }
+
+    private generateFeatures(parameters: IInteractionParameters): Feature<Features>[] {
+        const features: Feature<Features>[] = [];
+
+        if (parameters.loadedStorage) {
+            features.push({
+                opcode: Features.ACCESS_LIST,
+                data: parameters.loadedStorage,
+            });
+        }
+
+        return features;
+    }
 }

package/src/transaction/interfaces/ITransactionParameters.ts

@@ -3,6 +3,10 @@ import { ITweakedTransactionData } from '../shared/TweakedTransaction.js';
 import { ChainId } from '../../network/ChainId.js';
 import { PsbtOutputExtended } from '@btc-vision/bitcoin';
 
+export interface LoadedStorage {
+    [key: string]: string[];
+}
+
 export interface ITransactionParameters extends ITweakedTransactionData {
     readonly from?: string;
     readonly to?: string;
@@ -11,7 +15,7 @@ export interface ITransactionParameters extends ITweakedTransactionData {
 
     nonWitnessUtxo?: Buffer;
     estimatedFees?: bigint;
-    
+
     optionalInputs?: UTXO[];
     optionalOutputs?: PsbtOutputExtended[];
 
@@ -40,6 +44,8 @@ export interface SharedInteractionParameters extends ITransactionParameters {
 
     readonly preimage: Buffer;
     readonly randomBytes?: Buffer;
+
+    readonly loadedStorage?: LoadedStorage;
 }
 
 export interface IInteractionParameters extends SharedInteractionParameters {

package/src/transaction/shared/TweakedTransaction.ts

@@ -802,11 +802,10 @@ export abstract class TweakedTransaction extends Logger {
             if (this.tapLeafScript) {
                 input.tapLeafScript = [this.tapLeafScript];
             }
-        }
 
-        // If the first input and we have a global nonWitnessUtxo not yet set
-        if (i === 0 && this.nonWitnessUtxo) {
-            input.nonWitnessUtxo = this.nonWitnessUtxo;
+            if (this.nonWitnessUtxo) {
+                input.nonWitnessUtxo = this.nonWitnessUtxo;
+            }
         }
 
         /*if (utxo.nonWitnessUtxo && extra) {