@btc-vision/transaction 1.0.112 → 1.0.114

package/src/buffer/BinaryWriter.ts

@@ -0,0 +1,331 @@
+import { BufferHelper } from '../utils/BufferHelper.js';
+import { ADDRESS_BYTE_LENGTH, i32, Selector, u16, u32, u64, u8 } from '../utils/types.js';
+import { Address } from '../keypair/Address.js';
+import { BinaryReader } from './BinaryReader.js';
+import { AddressMap } from '../deterministic/AddressMap.js';
+
+export class BinaryWriter {
+    private currentOffset: u32 = 0;
+    private buffer: DataView;
+
+    constructor(length: number = 0) {
+        this.buffer = this.getDefaultBuffer(length);
+    }
+
+    public writeU8(value: u8): void {
+        if (value > 255) throw new Error('Value is too large.');
+
+        this.allocSafe(1);
+        this.buffer.setUint8(this.currentOffset++, value);
+    }
+
+    public writeU16(value: u16): void {
+        if (value > 65535) throw new Error('Value is too large.');
+
+        this.allocSafe(2);
+        this.buffer.setUint16(this.currentOffset, value, true);
+        this.currentOffset += 2;
+    }
+
+    public writeU32(value: u32, le: boolean = true): void {
+        if (value > 4294967295) throw new Error('Value is too large.');
+
+        this.allocSafe(4);
+        this.buffer.setUint32(this.currentOffset, value, le);
+        this.currentOffset += 4;
+    }
+
+    public writeU64(value: u64): void {
+        if (value > 18446744073709551615n) throw new Error('Value is too large.');
+
+        this.allocSafe(8);
+        this.buffer.setBigUint64(this.currentOffset, value, true);
+        this.currentOffset += 8;
+    }
+
+    public writeSelector(value: Selector): void {
+        this.writeU32(value, false);
+    }
+
+    public writeBoolean(value: boolean): void {
+        this.writeU8(value ? 1 : 0);
+    }
+
+    public writeU256(bigIntValue: bigint): void {
+        if (
+            bigIntValue >
+            115792089237316195423570985008687907853269984665640564039457584007913129639935n
+        ) {
+            throw new Error('Value is too large.');
+        }
+
+        this.allocSafe(32);
+
+        const bytesToHex = BufferHelper.valueToUint8Array(bigIntValue);
+        if (bytesToHex.byteLength !== 32) {
+            console.log('Invalid u256 value:', bytesToHex);
+
+            throw new Error(`Invalid u256 value: ${bigIntValue}`);
+        }
+
+        for (let i = 0; i < bytesToHex.byteLength; i++) {
+            this.writeU8(bytesToHex[i]);
+        }
+    }
+
+    public writeBytes(value: Uint8Array | Buffer): void {
+        this.allocSafe(value.byteLength);
+
+        for (let i = 0; i < value.byteLength; i++) {
+            this.writeU8(value[i]);
+        }
+    }
+
+    public writeString(value: string): void {
+        this.allocSafe(value.length);
+
+        for (let i: i32 = 0; i < value.length; i++) {
+            this.writeU8(value.charCodeAt(i));
+        }
+    }
+
+    public writeAddress(value: Address): void {
+        const bytes = this.fromAddress(value);
+        this.writeBytes(bytes);
+    }
+
+    public writeStringWithLength(value: string): void {
+        this.allocSafe(value.length + 2);
+
+        this.writeU16(value.length);
+        this.writeString(value);
+    }
+
+    public getBuffer(clear: boolean = true): Uint8Array {
+        const buf = new Uint8Array(this.buffer.byteLength);
+        for (let i: u32 = 0; i < this.buffer.byteLength; i++) {
+            buf[i] = this.buffer.getUint8(i);
+        }
+
+        if (clear) this.clear();
+
+        return buf;
+    }
+
+    public reset(): void {
+        this.currentOffset = 0;
+        this.buffer = this.getDefaultBuffer(4);
+    }
+
+    public writeTuple(values: bigint[]): void {
+        this.allocSafe(4 + values.length * 32);
+        this.writeU32(values.length);
+
+        for (let i = 0; i < values.length; i++) {
+            this.writeU256(values[i]);
+        }
+    }
+
+    public toBytesReader(): BinaryReader {
+        return new BinaryReader(this.getBuffer());
+    }
+
+    public getOffset(): u32 {
+        return this.currentOffset;
+    }
+
+    public setOffset(offset: u32): void {
+        this.currentOffset = offset;
+    }
+
+    public clear(): void {
+        this.currentOffset = 0;
+        this.buffer = this.getDefaultBuffer();
+    }
+
+    public allocSafe(size: u32): void {
+        if (this.currentOffset + size > this.buffer.byteLength) {
+            this.resize(size);
+        }
+    }
+
+    public writeABISelector(name: string, selector: Selector): void {
+        this.writeStringWithLength(name);
+        this.writeSelector(selector);
+    }
+
+    public writeAddressValueTupleMap(map: AddressMap<bigint>): void {
+        if (map.size > 65535) throw new Error('Map size is too large');
+
+        this.writeU16(map.size);
+
+        const keys = Array.from(map.keys());
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const value = map.get(key);
+
+            if (value === null || value === undefined) throw new Error('Value not found');
+
+            this.writeAddress(key);
+            this.writeU256(value);
+        }
+    }
+
+    public writeLimitedAddressBytesMap(map: AddressMap<Uint8Array[]>): void {
+        if (map.size > 8) throw new Error('Too many contract calls');
+
+        this.writeU8(map.size);
+
+        const keys: Address[] = Array.from(map.keys());
+        for (let i: i32 = 0; i < keys.length; i++) {
+            const address: Address = keys[i];
+            const calls: Uint8Array[] | undefined = map.get(address);
+
+            if (!calls) throw new Error('Calls not found');
+            if (calls.length > 10) throw new Error('Too many calls.');
+
+            this.writeAddress(address);
+            this.writeU8(calls.length);
+
+            for (let j: i32 = 0; j < calls.length; j++) {
+                this.writeBytesWithLength(calls[j]);
+            }
+        }
+    }
+
+    public writeBytesWithLength(value: Uint8Array): void {
+        this.writeU32(value.length);
+        this.writeBytes(value);
+    }
+
+    public writeAddressArray(value: Address[]): void {
+        if (value.length > 65535) throw new Error('Array size is too large');
+
+        this.writeU16(value.length);
+
+        for (let i = 0; i < value.length; i++) {
+            this.writeAddress(value[i]);
+        }
+    }
+
+    public writeU32Array(value: u32[]): void {
+        if (value.length > 65535) throw new Error('Array size is too large');
+
+        this.writeU16(value.length);
+
+        for (let i = 0; i < value.length; i++) {
+            this.writeU32(value[i]);
+        }
+    }
+
+    public writeU256Array(value: bigint[]): void {
+        if (value.length > 65535) throw new Error('Array size is too large');
+
+        this.writeU16(value.length);
+
+        for (let i = 0; i < value.length; i++) {
+            this.writeU256(value[i]);
+        }
+    }
+
+    public writeStringArray(value: string[]): void {
+        if (value.length > 65535) throw new Error('Array size is too large');
+
+        this.writeU16(value.length);
+
+        for (let i = 0; i < value.length; i++) {
+            this.writeStringWithLength(value[i]);
+        }
+    }
+
+    public writeU16Array(value: u16[]): void {
+        if (value.length > 65535) throw new Error('Array size is too large');
+
+        this.writeU16(value.length);
+
+        for (let i = 0; i < value.length; i++) {
+            this.writeU16(value[i]);
+        }
+    }
+
+    public writeU8Array(value: u8[]): void {
+        if (value.length > 65535) throw new Error('Array size is too large');
+
+        this.writeU16(value.length);
+
+        for (let i = 0; i < value.length; i++) {
+            this.writeU8(value[i]);
+        }
+    }
+
+    public writeU64Array(value: bigint[]): void {
+        if (value.length > 65535) throw new Error('Array size is too large');
+
+        this.writeU16(value.length);
+
+        for (let i = 0; i < value.length; i++) {
+            this.writeU64(value[i]);
+        }
+    }
+
+    public writeBytesArray(value: Uint8Array[]): void {
+        if (value.length > 65535) throw new Error('Array size is too large');
+
+        this.writeU16(value.length);
+
+        for (let i = 0; i < value.length; i++) {
+            this.writeBytesWithLength(value[i]);
+        }
+    }
+
+    public writeSelectorArray(value: Selector[]): void {
+        if (value.length > 65535) throw new Error('Array size is too large');
+
+        this.writeU16(value.length);
+
+        for (let i = 0; i < value.length; i++) {
+            this.writeSelector(value[i]);
+        }
+    }
+
+    private getChecksum(): u32 {
+        let checksum: u32 = 0;
+        for (let i = 0; i < this.buffer.byteLength; i++) {
+            checksum += this.buffer.getUint8(i);
+        }
+
+        return checksum % 2 ** 32;
+    }
+
+    private writeMethodSelectorMap(value: Set<Selector>): void {
+        this.writeU16(value.size);
+
+        value.forEach((selector: Selector, _value: Selector, _set: Set<Selector>): void => {
+            this.writeSelector(selector);
+        });
+    }
+
+    private fromAddress(pubKey: Address): Uint8Array {
+        if (pubKey.byteLength > ADDRESS_BYTE_LENGTH) {
+            throw new Error(
+                `Address is too long ${pubKey.byteLength} > ${ADDRESS_BYTE_LENGTH} bytes`,
+            );
+        }
+
+        return pubKey;
+    }
+
+    private resize(size: u32): void {
+        const buf: Uint8Array = new Uint8Array(this.buffer.byteLength + size);
+
+        for (let i: i32 = 0; i < this.buffer.byteLength; i++) {
+            buf[i] = this.buffer.getUint8(i);
+        }
+
+        this.buffer = new DataView(buf.buffer);
+    }
+
+    private getDefaultBuffer(length: number = 0): DataView {
+        return new DataView(new ArrayBuffer(length));
+    }
+}

package/src/deterministic/AddressMap.ts

@@ -0,0 +1,57 @@
+import { i32 } from '../utils/types.js';
+import { Address } from '../keypair/Address.js';
+import { Map } from './Map.js';
+
+export class AddressMap<V> extends Map<Address, V> {
+    public set(key: Address, value: V): void {
+        const index: i32 = this._keys.indexOf(key);
+        if (index == -1) {
+            this._keys.push(key);
+            this._values.push(value);
+        } else {
+            this._values[index] = value;
+        }
+    }
+
+    public indexOf(address: Address): i32 {
+        for (let i: i32 = 0; i < this._keys.length; i++) {
+            const key = this._keys[i];
+
+            if (address.equals(key)) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    public has(key: Address): boolean {
+        for (let i: i32 = 0; i < this._keys.length; i++) {
+            if (key.equals(this._keys[i])) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public get(key: Address): V {
+        const index: i32 = this.indexOf(key);
+        if (index == -1) {
+            throw new Error('Key not found in map');
+        }
+        return this._values[index];
+    }
+
+    public delete(key: Address): boolean {
+        const index: i32 = this.indexOf(key);
+        if (index == -1) {
+            return false;
+        }
+
+        this._keys.splice(index, 1);
+        this._values.splice(index, 1);
+
+        return true;
+    }
+}

package/src/deterministic/AddressSet.ts

@@ -0,0 +1,62 @@
+import { i32 } from '../utils/types.js';
+import { Address } from '../keypair/Address.js';
+
+export class AddressSet {
+    private keys: Address[];
+
+    public constructor(keys: Address[] = []) {
+        this.keys = keys;
+    }
+
+    public add(address: Address): void {
+        if (!this.contains(address)) {
+            this.keys.push(address);
+        }
+    }
+
+    public contains(address: Address): boolean {
+        for (let i = 0; i < this.keys.length; i++) {
+            if (this.keys[i].equals(address)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public remove(address: Address): void {
+        const index = this.keys.findIndex((key) => key.equals(address));
+
+        if (index !== -1) {
+            this.keys.splice(index, 1);
+        }
+    }
+
+    public size(): i32 {
+        return this.keys.length;
+    }
+
+    public clone(): AddressSet {
+        const clone = new AddressSet();
+
+        for (let i = 0; i < this.keys.length; i++) {
+            clone.add(this.keys[i]);
+        }
+
+        return clone;
+    }
+
+    public clear(): void {
+        this.keys = [];
+    }
+
+    public combine(set: AddressSet): AddressSet {
+        const clone = this.clone();
+
+        for (let i = 0; i < set.keys.length; i++) {
+            clone.add(set.keys[i]);
+        }
+
+        return clone;
+    }
+}

package/src/deterministic/DeterministicMap.ts

@@ -0,0 +1,88 @@
+export class DeterministicMap<K, V> {
+    private map: Map<K, V>;
+    #keys: K[];
+
+    constructor(private compareFn: (a: K, b: K) => number) {
+        this.map = new Map<K, V>();
+        this.#keys = [];
+    }
+
+    public get size(): number {
+        return this.map.size;
+    }
+
+    public static fromMap<K, V>(
+        map: Map<K, V>,
+        compareFn: (a: K, b: K) => number,
+    ): DeterministicMap<K, V> {
+        const deterministicMap = new DeterministicMap<K, V>(compareFn);
+        for (const [key, value] of map) {
+            deterministicMap.set(key, value);
+        }
+        return deterministicMap;
+    }
+
+    public set(key: K, value: V): void {
+        if (!this.map.has(key)) {
+            this.#keys.push(key);
+            this.#keys.sort(this.compareFn);
+        }
+        this.map.set(key, value);
+    }
+
+    public get(key: K): V | undefined {
+        return this.map.get(key);
+    }
+
+    public keys(): IterableIterator<K> {
+        return this.#keys.values();
+    }
+
+    public values(): IterableIterator<V> {
+        const values: V[] = [];
+
+        for (let i = 0; i < this.#keys.length; i++) {
+            const key = this.#keys[i];
+            const value = this.map.get(key);
+
+            if (value) {
+                values.push(value);
+            } else {
+                throw new Error('Value not found');
+            }
+        }
+
+        return values.values();
+    }
+
+    public has(key: K): boolean {
+        return this.map.has(key);
+    }
+
+    public delete(key: K): boolean {
+        if (this.map.has(key)) {
+            this.map.delete(key);
+            this.#keys = this.#keys.filter((k) => k !== key);
+            return true;
+        }
+        return false;
+    }
+
+    public clear(): void {
+        this.map.clear();
+        this.#keys = [];
+    }
+
+    public forEach(callback: (value: V, key: K, map: DeterministicMap<K, V>) => void): void {
+        for (const key of this.#keys) {
+            const value = this.map.get(key) as V;
+            callback(value, key, this);
+        }
+    }
+
+    *[Symbol.iterator](): IterableIterator<[K, V]> {
+        for (const key of this.#keys) {
+            yield [key, this.map.get(key) as V];
+        }
+    }
+}

package/src/deterministic/DeterministicSet.ts

@@ -0,0 +1,56 @@
+export class DeterministicSet<T> {
+    private elements: T[];
+
+    constructor(private compareFn: (a: T, b: T) => number) {
+        this.elements = [];
+    }
+
+    public add(value: T): void {
+        if (!this.elements.includes(value)) {
+            this.elements.push(value);
+            this.elements.sort(this.compareFn);
+        }
+    }
+
+    public delete(value: T): boolean {
+        const index = this.elements.indexOf(value);
+        if (index === -1) {
+            return false;
+        }
+
+        this.elements.splice(index, 1);
+        return true;
+    }
+
+    public has(value: T): boolean {
+        return this.elements.includes(value);
+    }
+
+    public clear(): void {
+        this.elements = [];
+    }
+
+    public forEach(callback: (value: T, set: DeterministicSet<T>) => void): void {
+        for (const value of this.elements) {
+            callback(value, this);
+        }
+    }
+
+    public static fromSet<T>(set: Set<T>, compareFn: (a: T, b: T) => number): DeterministicSet<T> {
+        const deterministicSet = new DeterministicSet<T>(compareFn);
+        for (const value of set) {
+            deterministicSet.add(value);
+        }
+        return deterministicSet;
+    }
+
+    public get size(): number {
+        return this.elements.length;
+    }
+
+    *[Symbol.iterator](): IterableIterator<T> {
+        for (const value of this.elements) {
+            yield value;
+        }
+    }
+}

package/src/deterministic/Map.ts

@@ -0,0 +1,66 @@
+import { i32 } from '../utils/types.js';
+
+export class Map<K, V> {
+    protected _keys: K[] = [];
+    protected _values: V[] = [];
+
+    public get size(): i32 {
+        return this._keys.length;
+    }
+
+    public keys(): K[] {
+        return this._keys;
+    }
+
+    public values(): V[] {
+        return this._values;
+    }
+
+    public set(key: K, value: V): void {
+        const index: i32 = this.indexOf(key);
+        if (index == -1) {
+            this._keys.push(key);
+            this._values.push(value);
+        } else {
+            this._values[index] = value;
+        }
+    }
+
+    public indexOf(key: K): i32 {
+        for (let i: i32 = 0; i < this._keys.length; i++) {
+            if (this._keys[i] == key) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    public get(key: K): V {
+        const index: i32 = this.indexOf(key);
+        if (index == -1) {
+            throw new Error('Key not found in map');
+        }
+        return this._values[index];
+    }
+
+    public has(key: K): boolean {
+        return this.indexOf(key) != -1;
+    }
+
+    public delete(key: K): boolean {
+        const index: i32 = this.indexOf(key);
+        if (index == -1) {
+            return false;
+        }
+
+        this._keys.splice(index, 1);
+        this._values.splice(index, 1);
+        return true;
+    }
+
+    public clear(): void {
+        this._keys = [];
+        this._values = [];
+    }
+}

package/src/event/NetEvent.ts

@@ -0,0 +1,6 @@
+export class NetEvent {
+    public constructor(
+        public readonly eventType: string,
+        public readonly eventData: Uint8Array,
+    ) {}
+}

package/src/generators/AddressGenerator.ts

@@ -1,4 +1,4 @@
-import { bech32 } from 'bech32';
+import { bech32, bech32m } from 'bech32';
 import { initEccLib, Network } from 'bitcoinjs-lib';
 import * as ecc from '@bitcoinerlab/secp256k1';
 import { ripemd160 } from 'bitcoinjs-lib/src/crypto.js';
@@ -14,6 +14,20 @@ export class AddressGenerator {
         return this.toSegwitAddress(pkh, network);
     }
 
+    // Generate a valid Taproot address from a public key
+    public static generateTaprootAddress(pubKey: Buffer, network: { bech32: string }): string {
+        if (pubKey.length !== 32) throw new Error('Invalid public key length');
+
+        // Convert the public key to words
+        const words = bech32m.toWords(pubKey);
+
+        // Prepend the witness version (0x01 for Taproot)
+        words.unshift(0x01);
+
+        // Encode using Bech32m
+        return bech32m.encode(network.bech32, words);
+    }
+
     // Convert a hash to a SegWit address
     private static toSegwitAddress(pkh: Buffer, network: Network): string {
         const words = bech32.toWords(pkh);