@btc-vision/transaction 1.8.0-alpha.1 → 1.8.0-alpha.2

package/src/keypair/Address.ts

@@ -207,7 +207,8 @@ export class Address extends Uint8Array {
      */
     public static fromBigInt(value: bigint, tweakedValue?: bigint): Address {
         const address = Address.bigintToUint8Array(value);
-        const legacyAddress = tweakedValue ? Address.bigintToUint8Array(tweakedValue) : undefined;
+        const legacyAddress =
+            tweakedValue !== undefined ? Address.bigintToUint8Array(tweakedValue) : undefined;
 
         return new Address(address, legacyAddress);
     }
@@ -769,6 +770,7 @@ export class Address extends Uint8Array {
 
     public toTweakedHybridPublicKeyHex(): string {
         this.ensureLegacyProcessed();
+        this.ensureTweakedUncompressed();
         if (!this.#tweakedUncompressed) {
             throw new Error('Legacy public key not set');
         }
@@ -778,6 +780,7 @@ export class Address extends Uint8Array {
 
     public toTweakedHybridPublicKeyBuffer(): Buffer {
         this.ensureLegacyProcessed();
+        this.ensureTweakedUncompressed();
         if (!this.#tweakedUncompressed) {
             throw new Error('Legacy public key not set');
         }
@@ -785,6 +788,29 @@ export class Address extends Uint8Array {
         return this.#tweakedUncompressed;
     }
 
+    /**
+     * Lazily generates the tweaked uncompressed/hybrid key from the legacy public key.
+     * Only called when toTweakedHybridPublicKey* methods are accessed.
+     */
+    private ensureTweakedUncompressed(): void {
+        if (this.#tweakedUncompressed) return;
+
+        const key = this.#legacyPublicKey;
+        if (!key) return;
+
+        // Only attempt hybrid key generation for 32-byte keys that weren't processed through autoFormat
+        if (key.length === ADDRESS_BYTE_LENGTH && !this.#originalPublicKey) {
+            try {
+                const buf = Buffer.alloc(ADDRESS_BYTE_LENGTH);
+                buf.set(key);
+                this.#tweakedUncompressed = ContractAddress.generateHybridKeyFromHash(buf);
+            } catch {
+                // Hybrid key generation may fail for keys that aren't valid EC points
+                // (e.g., zero addresses). Leave #tweakedUncompressed undefined.
+            }
+        }
+    }
+
     /**
      * Sets the MLDSA key portion of the address.
      * @param {ArrayLike<number>} mldsaPublicKey - The MLDSA public key or its hash
@@ -837,11 +863,6 @@ export class Address extends Uint8Array {
         // Length validation already done in constructor
 
         if (pending.length === ADDRESS_BYTE_LENGTH) {
-            // 32-byte input: already tweaked x-only, just generate hybrid
-            const buf = Buffer.alloc(ADDRESS_BYTE_LENGTH);
-            buf.set(pending);
-
-            this.#tweakedUncompressed = ContractAddress.generateHybridKeyFromHash(buf);
             this.#legacyPublicKey = pending;
         } else {
             // 33 or 65 bytes: full autoFormat processing with EC operations

package/src/transaction/builders/MultiSignTransaction.ts

@@ -227,7 +227,7 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
                 input.tapScriptSig = (input.tapScriptSig || []).concat(partialSignatures);
             }
 
-            delete input.finalScriptWitness;
+            Reflect.deleteProperty(input, 'finalScriptWitness');
 
             const signHashTypes: number[] = MultiSignTransaction.signHashTypesArray
                 ? [MultiSignTransaction.calculateSignHash(MultiSignTransaction.signHashTypesArray)]
@@ -397,7 +397,7 @@ export class MultiSignTransaction extends TransactionBuilder<TransactionType.MUL
                     );
                 }
 
-                delete input.finalScriptWitness;
+                Reflect.deleteProperty(input, 'finalScriptWitness');
 
                 psbt.finalizeInput(
                     i,

package/src/transaction/shared/TweakedTransaction.ts

@@ -948,18 +948,18 @@ export abstract class TweakedTransaction extends Logger {
             if (isP2WPKH(redeemOutput)) {
                 // P2SH-P2WPKH
                 // Use witnessUtxo + redeemScript
-                delete input.nonWitnessUtxo; // ensure we do NOT have nonWitnessUtxo
+                Reflect.deleteProperty(input, 'nonWitnessUtxo'); // ensure we do NOT have nonWitnessUtxo
                 // witnessScript is not needed
             } else if (isP2WSHScript(redeemOutput)) {
                 // P2SH-P2WSH
                 // Use witnessUtxo + redeemScript + witnessScript
-                delete input.nonWitnessUtxo; // ensure we do NOT have nonWitnessUtxo
+                Reflect.deleteProperty(input, 'nonWitnessUtxo'); // ensure we do NOT have nonWitnessUtxo
 
                 this.processP2WSHInput(utxo, input, i);
             } else {
                 // Legacy P2SH
                 // Use nonWitnessUtxo
-                delete input.witnessUtxo; // ensure we do NOT have witnessUtxo
+                Reflect.deleteProperty(input, 'witnessUtxo'); // ensure we do NOT have witnessUtxo
             }
         }
 

package/src/utils/lengths.ts

@@ -1,4 +1,6 @@
 export const ADDRESS_BYTE_LENGTH: number = 32;
+export const EXTENDED_ADDRESS_BYTE_LENGTH: number = 64;
+export const SCHNORR_SIGNATURE_BYTE_LENGTH: number = 64;
 export const SELECTOR_BYTE_LENGTH: number = 4;
 
 export const U256_BYTE_LENGTH: number = 32;
@@ -11,7 +13,7 @@ export const U8_BYTE_LENGTH: number = 1;
 export const I256_BYTE_LENGTH: number = 32;
 export const I128_BYTE_LENGTH: number = 16;
 export const I64_BYTE_LENGTH: number = 8;
-export const number_BYTE_LENGTH: number = 4;
+export const I32_BYTE_LENGTH: number = 4;
 export const I16_BYTE_LENGTH: number = 2;
 export const I8_BYTE_LENGTH: number = 1;
 

package/src/utils/types.ts

@@ -8,11 +8,14 @@ export type MemorySlotData<T> = T;
 export type PointerStorage = DeterministicMap<MemorySlotPointer, MemorySlotData<bigint>>;
 export type BlockchainStorage = DeterministicMap<string, PointerStorage>;
 
+export type i8 = number;
+export type i16 = number;
 export type i32 = number;
+export type i64 = bigint;
+
 export type u8 = number;
 export type u16 = number;
 export type u32 = number;
-
 export type u64 = bigint;
 
 export type Selector = number;

package/test/binary-reader-writer.test.ts

@@ -0,0 +1,457 @@
+import { describe, expect, it } from 'vitest';
+import { Address, BinaryReader, BinaryWriter, ExtendedAddressMap } from '../src/opnet.js';
+
+describe('BinaryReader/BinaryWriter', () => {
+    // Helper to create an Address with both MLDSA and tweaked keys
+    const createFullAddress = (mldsaValue: bigint, tweakedValue: bigint): Address => {
+        return Address.fromBigInt(mldsaValue, tweakedValue);
+    };
+
+    describe('Signed Integer Methods', () => {
+        describe('i8', () => {
+            it('should write and read positive i8', () => {
+                const writer = new BinaryWriter();
+                writer.writeI8(127);
+                writer.writeI8(0);
+                writer.writeI8(1);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI8()).toBe(127);
+                expect(reader.readI8()).toBe(0);
+                expect(reader.readI8()).toBe(1);
+            });
+
+            it('should write and read negative i8', () => {
+                const writer = new BinaryWriter();
+                writer.writeI8(-128);
+                writer.writeI8(-1);
+                writer.writeI8(-50);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI8()).toBe(-128);
+                expect(reader.readI8()).toBe(-1);
+                expect(reader.readI8()).toBe(-50);
+            });
+
+            it('should throw on out of range i8', () => {
+                const writer = new BinaryWriter();
+                expect(() => writer.writeI8(128)).toThrow();
+                expect(() => writer.writeI8(-129)).toThrow();
+            });
+        });
+
+        describe('i16', () => {
+            it('should write and read positive i16 big-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI16(32767);
+                writer.writeI16(256);
+                writer.writeI16(0);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI16()).toBe(32767);
+                expect(reader.readI16()).toBe(256);
+                expect(reader.readI16()).toBe(0);
+            });
+
+            it('should write and read negative i16 big-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI16(-32768);
+                writer.writeI16(-1);
+                writer.writeI16(-256);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI16()).toBe(-32768);
+                expect(reader.readI16()).toBe(-1);
+                expect(reader.readI16()).toBe(-256);
+            });
+
+            it('should write and read i16 little-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI16(12345, false);
+                writer.writeI16(-12345, false);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI16(false)).toBe(12345);
+                expect(reader.readI16(false)).toBe(-12345);
+            });
+
+            it('should throw on out of range i16', () => {
+                const writer = new BinaryWriter();
+                expect(() => writer.writeI16(32768)).toThrow();
+                expect(() => writer.writeI16(-32769)).toThrow();
+            });
+        });
+
+        describe('i32', () => {
+            it('should write and read positive i32 big-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI32(2147483647);
+                writer.writeI32(65536);
+                writer.writeI32(0);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI32()).toBe(2147483647);
+                expect(reader.readI32()).toBe(65536);
+                expect(reader.readI32()).toBe(0);
+            });
+
+            it('should write and read negative i32 big-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI32(-2147483648);
+                writer.writeI32(-1);
+                writer.writeI32(-65536);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI32()).toBe(-2147483648);
+                expect(reader.readI32()).toBe(-1);
+                expect(reader.readI32()).toBe(-65536);
+            });
+
+            it('should write and read i32 little-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI32(123456789, false);
+                writer.writeI32(-123456789, false);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI32(false)).toBe(123456789);
+                expect(reader.readI32(false)).toBe(-123456789);
+            });
+
+            it('should throw on out of range i32', () => {
+                const writer = new BinaryWriter();
+                expect(() => writer.writeI32(2147483648)).toThrow();
+                expect(() => writer.writeI32(-2147483649)).toThrow();
+            });
+        });
+
+        describe('i64', () => {
+            it('should write and read positive i64 big-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI64(9223372036854775807n);
+                writer.writeI64(4294967296n);
+                writer.writeI64(0n);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI64()).toBe(9223372036854775807n);
+                expect(reader.readI64()).toBe(4294967296n);
+                expect(reader.readI64()).toBe(0n);
+            });
+
+            it('should write and read negative i64 big-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI64(-9223372036854775808n);
+                writer.writeI64(-1n);
+                writer.writeI64(-4294967296n);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI64()).toBe(-9223372036854775808n);
+                expect(reader.readI64()).toBe(-1n);
+                expect(reader.readI64()).toBe(-4294967296n);
+            });
+
+            it('should write and read i64 little-endian', () => {
+                const writer = new BinaryWriter();
+                writer.writeI64(1234567890123456789n, false);
+                writer.writeI64(-1234567890123456789n, false);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                expect(reader.readI64(false)).toBe(1234567890123456789n);
+                expect(reader.readI64(false)).toBe(-1234567890123456789n);
+            });
+
+            it('should throw on out of range i64', () => {
+                const writer = new BinaryWriter();
+                expect(() => writer.writeI64(9223372036854775808n)).toThrow();
+                expect(() => writer.writeI64(-9223372036854775809n)).toThrow();
+            });
+        });
+    });
+
+    describe('Extended Address Methods', () => {
+        describe('readExtendedAddress / writeExtendedAddress', () => {
+            it('should write and read extended address', () => {
+                const writer = new BinaryWriter();
+                const address = createFullAddress(123n, 456n);
+
+                writer.writeExtendedAddress(address);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddress();
+
+                expect(result.toBigInt()).toBe(123n);
+                expect(result.tweakedToBigInt()).toBe(456n);
+            });
+
+            it('should write and read multiple extended addresses', () => {
+                const writer = new BinaryWriter();
+                const addr1 = createFullAddress(100n, 200n);
+                const addr2 = createFullAddress(300n, 400n);
+                const addr3 = createFullAddress(500n, 600n);
+
+                writer.writeExtendedAddress(addr1);
+                writer.writeExtendedAddress(addr2);
+                writer.writeExtendedAddress(addr3);
+
+                const reader = new BinaryReader(writer.getBuffer());
+
+                const result1 = reader.readExtendedAddress();
+                expect(result1.toBigInt()).toBe(100n);
+                expect(result1.tweakedToBigInt()).toBe(200n);
+
+                const result2 = reader.readExtendedAddress();
+                expect(result2.toBigInt()).toBe(300n);
+                expect(result2.tweakedToBigInt()).toBe(400n);
+
+                const result3 = reader.readExtendedAddress();
+                expect(result3.toBigInt()).toBe(500n);
+                expect(result3.tweakedToBigInt()).toBe(600n);
+            });
+
+            it('should handle zero addresses', () => {
+                const writer = new BinaryWriter();
+                const address = createFullAddress(0n, 0n);
+
+                writer.writeExtendedAddress(address);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddress();
+
+                expect(result.toBigInt()).toBe(0n);
+                expect(result.tweakedToBigInt()).toBe(0n);
+            });
+
+            it('should handle max value addresses', () => {
+                const writer = new BinaryWriter();
+                const maxValue = 2n ** 256n - 1n;
+                const address = createFullAddress(maxValue, maxValue);
+
+                writer.writeExtendedAddress(address);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddress();
+
+                expect(result.toBigInt()).toBe(maxValue);
+                expect(result.tweakedToBigInt()).toBe(maxValue);
+            });
+        });
+
+        describe('readExtendedAddressArray / writeExtendedAddressArray', () => {
+            it('should write and read empty array', () => {
+                const writer = new BinaryWriter();
+                writer.writeExtendedAddressArray([]);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddressArray();
+
+                expect(result).toEqual([]);
+            });
+
+            it('should write and read array of extended addresses', () => {
+                const writer = new BinaryWriter();
+                const addresses = [
+                    createFullAddress(1n, 2n),
+                    createFullAddress(3n, 4n),
+                    createFullAddress(5n, 6n),
+                ];
+
+                writer.writeExtendedAddressArray(addresses);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddressArray();
+
+                expect(result.length).toBe(3);
+                expect(result[0].toBigInt()).toBe(1n);
+                expect(result[0].tweakedToBigInt()).toBe(2n);
+                expect(result[1].toBigInt()).toBe(3n);
+                expect(result[1].tweakedToBigInt()).toBe(4n);
+                expect(result[2].toBigInt()).toBe(5n);
+                expect(result[2].tweakedToBigInt()).toBe(6n);
+            });
+
+            it('should handle large arrays', () => {
+                const writer = new BinaryWriter();
+                const addresses: Address[] = [];
+                for (let i = 0; i < 100; i++) {
+                    addresses.push(createFullAddress(BigInt(i), BigInt(i * 2)));
+                }
+
+                writer.writeExtendedAddressArray(addresses);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddressArray();
+
+                expect(result.length).toBe(100);
+                for (let i = 0; i < 100; i++) {
+                    expect(result[i].toBigInt()).toBe(BigInt(i));
+                    expect(result[i].tweakedToBigInt()).toBe(BigInt(i * 2));
+                }
+            });
+        });
+    });
+
+    describe('ExtendedAddressMapU256 Methods', () => {
+        describe('readExtendedAddressMapU256 / writeExtendedAddressMapU256', () => {
+            it('should write and read empty map', () => {
+                const writer = new BinaryWriter();
+                const map = new ExtendedAddressMap<bigint>();
+
+                writer.writeExtendedAddressMapU256(map);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddressMapU256();
+
+                expect(result.size).toBe(0);
+            });
+
+            it('should write and read map with entries', () => {
+                const writer = new BinaryWriter();
+                const map = new ExtendedAddressMap<bigint>();
+
+                const addr1 = createFullAddress(100n, 200n);
+                const addr2 = createFullAddress(300n, 400n);
+
+                map.set(addr1, 1000n);
+                map.set(addr2, 2000n);
+
+                writer.writeExtendedAddressMapU256(map);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddressMapU256();
+
+                expect(result.size).toBe(2);
+            });
+
+            it('should handle large u256 values', () => {
+                const writer = new BinaryWriter();
+                const map = new ExtendedAddressMap<bigint>();
+
+                const addr = createFullAddress(1n, 2n);
+                const largeValue = 2n ** 256n - 1n;
+
+                map.set(addr, largeValue);
+
+                writer.writeExtendedAddressMapU256(map);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readExtendedAddressMapU256();
+
+                expect(result.size).toBe(1);
+            });
+        });
+    });
+
+    describe('Schnorr Signature Methods', () => {
+        describe('readSchnorrSignature / writeSchnorrSignature', () => {
+            it('should write and read Schnorr signature', () => {
+                const writer = new BinaryWriter();
+                const address = createFullAddress(12345n, 67890n);
+                const signature = new Uint8Array(64);
+                for (let i = 0; i < 64; i++) {
+                    signature[i] = i;
+                }
+
+                writer.writeSchnorrSignature(address, signature);
+
+                const reader = new BinaryReader(writer.getBuffer());
+                const result = reader.readSchnorrSignature();
+
+                expect(result.address.toBigInt()).toBe(12345n);
+                expect(result.address.tweakedToBigInt()).toBe(67890n);
+                expect(result.signature.length).toBe(64);
+                for (let i = 0; i < 64; i++) {
+                    expect(result.signature[i]).toBe(i);
+                }
+            });
+
+            it('should throw on invalid signature length', () => {
+                const writer = new BinaryWriter();
+                const address = createFullAddress(1n, 2n);
+                const invalidSignature = new Uint8Array(32); // Should be 64
+
+                expect(() => writer.writeSchnorrSignature(address, invalidSignature)).toThrow();
+            });
+
+            it('should handle multiple signatures', () => {
+                const writer = new BinaryWriter();
+
+                const sig1 = new Uint8Array(64).fill(1);
+                const sig2 = new Uint8Array(64).fill(2);
+
+                writer.writeSchnorrSignature(createFullAddress(1n, 2n), sig1);
+                writer.writeSchnorrSignature(createFullAddress(3n, 4n), sig2);
+
+                const reader = new BinaryReader(writer.getBuffer());
+
+                const result1 = reader.readSchnorrSignature();
+                expect(result1.address.toBigInt()).toBe(1n);
+                expect(result1.signature[0]).toBe(1);
+
+                const result2 = reader.readSchnorrSignature();
+                expect(result2.address.toBigInt()).toBe(3n);
+                expect(result2.signature[0]).toBe(2);
+            });
+        });
+    });
+
+    describe('Mixed Operations', () => {
+        it('should handle mixed data types in sequence', () => {
+            const writer = new BinaryWriter();
+
+            // Write various types
+            writer.writeI8(-50);
+            writer.writeI16(-1000);
+            writer.writeI32(-100000);
+            writer.writeI64(-10000000000n);
+            writer.writeExtendedAddress(createFullAddress(111n, 222n));
+            writer.writeU256(999n);
+
+            const reader = new BinaryReader(writer.getBuffer());
+
+            expect(reader.readI8()).toBe(-50);
+            expect(reader.readI16()).toBe(-1000);
+            expect(reader.readI32()).toBe(-100000);
+            expect(reader.readI64()).toBe(-10000000000n);
+
+            const addr = reader.readExtendedAddress();
+            expect(addr.toBigInt()).toBe(111n);
+            expect(addr.tweakedToBigInt()).toBe(222n);
+
+            expect(reader.readU256()).toBe(999n);
+        });
+
+        it('should correctly track buffer position', () => {
+            const writer = new BinaryWriter();
+
+            writer.writeI8(1);
+            writer.writeI16(2);
+            writer.writeI32(3);
+            writer.writeI64(4n);
+            writer.writeExtendedAddress(createFullAddress(5n, 6n));
+
+            const buffer = writer.getBuffer();
+            // i8: 1 byte, i16: 2 bytes, i32: 4 bytes, i64: 8 bytes, extended address: 64 bytes
+            expect(buffer.length).toBe(1 + 2 + 4 + 8 + 64);
+        });
+    });
+
+    describe('Error Handling', () => {
+        it('should throw when reading beyond buffer', () => {
+            const writer = new BinaryWriter();
+            writer.writeI8(1);
+
+            const reader = new BinaryReader(writer.getBuffer());
+            reader.readI8();
+
+            expect(() => reader.readI8()).toThrow();
+        });
+
+        it('should throw when reading extended address from insufficient buffer', () => {
+            const writer = new BinaryWriter();
+            writer.writeU256(1n); // Only 32 bytes
+
+            const reader = new BinaryReader(writer.getBuffer());
+
+            expect(() => reader.readExtendedAddress()).toThrow();
+        });
+    });
+});

package/test/derivePath.test.ts

@@ -419,7 +419,7 @@ describe('Mnemonic.deriveOPWallet', () => {
         });
     });
 
-    describe('deriveMultipleOPWallet', () => {
+    describe('deriveMultipleUnisat', () => {
         it('should derive multiple wallets', () => {
             const mnemonic = new Mnemonic(
                 testMnemonic,
@@ -428,7 +428,7 @@ describe('Mnemonic.deriveOPWallet', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallets = mnemonic.deriveMultipleOPWallet(AddressTypes.P2TR, 5);
+            const wallets = mnemonic.deriveMultipleUnisat(AddressTypes.P2TR, 5);
 
             expect(wallets.length).toBe(5);
             expect(wallets[0].p2tr).toBeDefined();
@@ -443,7 +443,7 @@ describe('Mnemonic.deriveOPWallet', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallets = mnemonic.deriveMultipleOPWallet(AddressTypes.P2TR, 3);
+            const wallets = mnemonic.deriveMultipleUnisat(AddressTypes.P2TR, 3);
 
             const addresses = wallets.map((w) => w.p2tr);
             const uniqueAddresses = new Set(addresses);
@@ -459,7 +459,7 @@ describe('Mnemonic.deriveOPWallet', () => {
                 MLDSASecurityLevel.LEVEL2,
             );
 
-            const wallets = mnemonic.deriveMultipleOPWallet(AddressTypes.P2TR, 2, 5);
+            const wallets = mnemonic.deriveMultipleUnisat(AddressTypes.P2TR, 2, 5);
             const wallet5 = mnemonic.deriveOPWallet(AddressTypes.P2TR, 5);
 
             expect(wallets[0].p2tr).toBe(wallet5.p2tr);