@btc-vision/bitcoin 6.5.6 → 7.0.0-alpha.0

package/browser/ecc_lib.d.ts

@@ -1,3 +0,0 @@
-import { TinySecp256k1Interface } from './types.js';
-export declare function initEccLib(eccLib: TinySecp256k1Interface | undefined): void;
-export declare function getEccLib(): TinySecp256k1Interface;

package/browser/hooks/AdvancedSignatureManager.d.ts

@@ -1,16 +0,0 @@
-export interface CacheEntry {
-    pubKey: string;
-    dataRef: WeakRef<Buffer>;
-    signature: Buffer;
-}
-export declare class AdvancedSignatureManager {
-    private static instance;
-    private cacheBySigner;
-    private registry;
-    private constructor();
-    static getInstance(): AdvancedSignatureManager;
-    addSignature(pubKey: string, data: Buffer, signature: Buffer): Buffer;
-    getSignature(pubKey: string, data: Buffer): Buffer | undefined;
-    clearCache(): void;
-    clearCacheForSigner(pubKey: string): void;
-}

package/browser/hooks/HookedSigner.d.ts

@@ -1,4 +0,0 @@
-import { BIP32Interface } from '@btc-vision/bip32';
-import { ECPairInterface } from 'ecpair';
-import { Signer, SignerAlternative, SignerAsync } from '../psbt.js';
-export declare function hookSigner(keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface): void;

package/browser/hooks/SignatureManager.d.ts

@@ -1,13 +0,0 @@
-export interface CacheEntry {
-    length: number;
-    dataRef: WeakRef<Buffer>;
-    signature: Buffer;
-}
-export declare class SignatureManager {
-    private cacheByLength;
-    private registry;
-    constructor();
-    addSignature(data: Buffer, signature: Buffer): Buffer;
-    getSignature(data: Buffer): Buffer | undefined;
-    clearCache(): void;
-}

package/browser/payments/lazy.d.ts

@@ -1,2 +0,0 @@
-export declare function prop<T extends object>(object: T, name: string, f: () => T[keyof T]): void;
-export declare function value<T>(f: () => T): () => T;

package/browser/typeforce.d.ts

@@ -1,38 +0,0 @@
-/**
- * Type definitions for typeforce library
- */
-
-/**
- * Typeforce type validator - validates that a value matches a given type.
- */
-type TypeforceValidator = (value: unknown) => boolean;
-
-/**
- * Interface representing the typeforce library's API.
- */
-interface TypeforceLib {
-    (type: unknown, value: unknown): void;
-    Number: TypeforceValidator;
-    Array: TypeforceValidator;
-    Boolean: TypeforceValidator;
-    String: TypeforceValidator;
-    Buffer: TypeforceValidator;
-    Hex: TypeforceValidator;
-    Null: TypeforceValidator;
-    Function: TypeforceValidator;
-    UInt8: TypeforceValidator;
-    UInt32: TypeforceValidator;
-    UInt53: TypeforceValidator;
-    BufferN: (n: number) => TypeforceValidator;
-    maybe: (type: unknown) => TypeforceValidator;
-    tuple: (...types: unknown[]) => TypeforceValidator;
-    oneOf: (...types: unknown[]) => TypeforceValidator;
-    arrayOf: (type: unknown) => TypeforceValidator;
-    Object: TypeforceValidator;
-    anyOf: (...types: unknown[]) => TypeforceValidator;
-}
-
-declare module 'typeforce' {
-    const typeforce: TypeforceLib;
-    export = typeforce;
-}

package/build/bufferutils.d.ts

@@ -1,34 +0,0 @@
-import * as varuint from 'varuint-bitcoin';
-export { varuint };
-export declare function readUInt64LE(buffer: Buffer, offset: number): number;
-export declare function writeUInt64LE(buffer: Buffer, value: number, offset: number): number;
-export declare function reverseBuffer(buffer: Buffer): Buffer;
-export declare function cloneBuffer(buffer: Buffer): Buffer;
-export declare class BufferWriter {
-    buffer: Buffer;
-    offset: number;
-    constructor(buffer: Buffer, offset?: number);
-    static withCapacity(size: number): BufferWriter;
-    writeUInt8(i: number): void;
-    writeInt32(i: number): void;
-    writeUInt32(i: number): void;
-    writeUInt64(i: number): void;
-    writeVarInt(i: number): void;
-    writeSlice(slice: Buffer): void;
-    writeVarSlice(slice: Buffer): void;
-    writeVector(vector: Buffer[]): void;
-    end(): Buffer;
-}
-export declare class BufferReader {
-    buffer: Buffer;
-    offset: number;
-    constructor(buffer: Buffer, offset?: number);
-    readUInt8(): number;
-    readInt32(): number;
-    readUInt32(): number;
-    readUInt64(): number;
-    readVarInt(): number;
-    readSlice(n: number): Buffer;
-    readVarSlice(): Buffer;
-    readVector(): Buffer[];
-}

package/build/bufferutils.js

@@ -1,141 +0,0 @@
-import * as varuint from 'varuint-bitcoin';
-import * as types from './types.js';
-const { typeforce } = types;
-export { varuint };
-function verifuint(value, max) {
-    if (typeof value !== 'number')
-        throw new Error('cannot write a non-number as a number');
-    if (value < 0)
-        throw new Error('specified a negative value for writing an unsigned value');
-    if (value > max)
-        throw new Error('RangeError: value out of range');
-    if (Math.floor(value) !== value)
-        throw new Error('value has a fractional component');
-}
-export function readUInt64LE(buffer, offset) {
-    const a = buffer.readUInt32LE(offset);
-    let b = buffer.readUInt32LE(offset + 4);
-    b *= 0x100000000;
-    verifuint(b + a, 0x001fffffffffffff);
-    return b + a;
-}
-export function writeUInt64LE(buffer, value, offset) {
-    verifuint(value, 0x001fffffffffffff);
-    buffer.writeInt32LE(value & -1, offset);
-    buffer.writeUInt32LE(Math.floor(value / 0x100000000), offset + 4);
-    return offset + 8;
-}
-export function reverseBuffer(buffer) {
-    if (buffer.length < 1)
-        return buffer;
-    let j = buffer.length - 1;
-    let tmp = 0;
-    for (let i = 0; i < buffer.length / 2; i++) {
-        tmp = buffer[i];
-        buffer[i] = buffer[j];
-        buffer[j] = tmp;
-        j--;
-    }
-    return buffer;
-}
-export function cloneBuffer(buffer) {
-    const clone = Buffer.allocUnsafe(buffer.length);
-    buffer.copy(clone);
-    return clone;
-}
-export class BufferWriter {
-    constructor(buffer, offset = 0) {
-        this.buffer = buffer;
-        this.offset = offset;
-        typeforce(types.tuple(types.Buffer, types.UInt32), [buffer, offset]);
-    }
-    static withCapacity(size) {
-        return new BufferWriter(Buffer.alloc(size));
-    }
-    writeUInt8(i) {
-        this.offset = this.buffer.writeUInt8(i, this.offset);
-    }
-    writeInt32(i) {
-        this.offset = this.buffer.writeInt32LE(i, this.offset);
-    }
-    writeUInt32(i) {
-        this.offset = this.buffer.writeUInt32LE(i, this.offset);
-    }
-    writeUInt64(i) {
-        this.offset = writeUInt64LE(this.buffer, i, this.offset);
-    }
-    writeVarInt(i) {
-        const encode = varuint.encode(i, this.buffer, this.offset);
-        this.offset += encode.bytes;
-    }
-    writeSlice(slice) {
-        if (this.buffer.length < this.offset + slice.length) {
-            throw new Error('Cannot write slice out of bounds');
-        }
-        this.offset += slice.copy(this.buffer, this.offset);
-    }
-    writeVarSlice(slice) {
-        this.writeVarInt(slice.length);
-        this.writeSlice(slice);
-    }
-    writeVector(vector) {
-        this.writeVarInt(vector.length);
-        vector.forEach((buf) => this.writeVarSlice(buf));
-    }
-    end() {
-        if (this.buffer.length === this.offset) {
-            return this.buffer;
-        }
-        throw new Error(`buffer size ${this.buffer.length}, offset ${this.offset}`);
-    }
-}
-export class BufferReader {
-    constructor(buffer, offset = 0) {
-        this.buffer = buffer;
-        this.offset = offset;
-        typeforce(types.tuple(types.Buffer, types.UInt32), [buffer, offset]);
-    }
-    readUInt8() {
-        const result = this.buffer.readUInt8(this.offset);
-        this.offset++;
-        return result;
-    }
-    readInt32() {
-        const result = this.buffer.readInt32LE(this.offset);
-        this.offset += 4;
-        return result;
-    }
-    readUInt32() {
-        const result = this.buffer.readUInt32LE(this.offset);
-        this.offset += 4;
-        return result;
-    }
-    readUInt64() {
-        const result = readUInt64LE(this.buffer, this.offset);
-        this.offset += 8;
-        return result;
-    }
-    readVarInt() {
-        const vi = varuint.decode(this.buffer, this.offset);
-        this.offset += vi.bytes;
-        return vi.numberValue || 0;
-    }
-    readSlice(n) {
-        if (this.buffer.length < this.offset + n) {
-            throw new Error('Cannot read slice out of bounds');
-        }
-        const result = Buffer.from(this.buffer.subarray(this.offset, this.offset + n));
-        this.offset += n;
-        return result;
-    }
-    readVarSlice() {
-        return this.readSlice(this.readVarInt());
-    }
-    readVector() {
-        const count = this.readVarInt();
-        const vector = [];
-        for (let i = 0; i < count; i++)
-            vector.push(this.readVarSlice());
-        return vector;
-    }
-}

package/build/ecc_lib.d.ts

@@ -1,3 +0,0 @@
-import { TinySecp256k1Interface } from './types.js';
-export declare function initEccLib(eccLib: TinySecp256k1Interface | undefined): void;
-export declare function getEccLib(): TinySecp256k1Interface;

package/build/ecc_lib.js

@@ -1,61 +0,0 @@
-const _ECCLIB_CACHE = {};
-export function initEccLib(eccLib) {
-    if (!eccLib) {
-        _ECCLIB_CACHE.eccLib = eccLib;
-    }
-    else if (eccLib !== _ECCLIB_CACHE.eccLib) {
-        verifyEcc(eccLib);
-        _ECCLIB_CACHE.eccLib = eccLib;
-    }
-}
-export function getEccLib() {
-    if (!_ECCLIB_CACHE.eccLib)
-        throw new Error('No ECC Library provided. You must call initEccLib() with a valid TinySecp256k1Interface instance');
-    return _ECCLIB_CACHE.eccLib;
-}
-const h = (hex) => Buffer.from(hex, 'hex');
-function verifyEcc(ecc) {
-    assert(typeof ecc.isXOnlyPoint === 'function');
-    assert(ecc.isXOnlyPoint(h('79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798')));
-    assert(ecc.isXOnlyPoint(h('fffffffffffffffffffffffffffffffffffffffffffffffffffffffeeffffc2e')));
-    assert(ecc.isXOnlyPoint(h('f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9')));
-    assert(ecc.isXOnlyPoint(h('0000000000000000000000000000000000000000000000000000000000000001')));
-    assert(!ecc.isXOnlyPoint(h('0000000000000000000000000000000000000000000000000000000000000000')));
-    assert(!ecc.isXOnlyPoint(h('fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f')));
-    assert(typeof ecc.xOnlyPointAddTweak === 'function');
-    tweakAddVectors.forEach((t) => {
-        const r = ecc.xOnlyPointAddTweak(h(t.pubkey), h(t.tweak));
-        if (t.result === null) {
-            assert(r === null);
-        }
-        else {
-            assert(r !== null);
-            assert(r.parity === t.parity);
-            assert(Buffer.from(r.xOnlyPubkey).equals(h(t.result)));
-        }
-    });
-}
-function assert(bool) {
-    if (!bool)
-        throw new Error('ecc library invalid');
-}
-const tweakAddVectors = [
-    {
-        pubkey: '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
-        tweak: 'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140',
-        parity: -1,
-        result: null,
-    },
-    {
-        pubkey: '1617d38ed8d8657da4d4761e8057bc396ea9e4b9d29776d4be096016dbd2509b',
-        tweak: 'a8397a935f0dfceba6ba9618f6451ef4d80637abf4e6af2669fbc9de6a8fd2ac',
-        parity: 1,
-        result: 'e478f99dab91052ab39a33ea35fd5e6e4933f4d28023cd597c9a1f6760346adf',
-    },
-    {
-        pubkey: '2c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991',
-        tweak: '823c3cd2142744b075a87eade7e1b8678ba308d566226a0056ca2b7a76f86b47',
-        parity: 0,
-        result: '9534f8dc8c6deda2dc007655981c78b49c5d96c778fbf363462a11ec9dfd948c',
-    },
-];

package/build/hooks/AdvancedSignatureManager.d.ts

@@ -1,16 +0,0 @@
-export interface CacheEntry {
-    pubKey: string;
-    dataRef: WeakRef<Buffer>;
-    signature: Buffer;
-}
-export declare class AdvancedSignatureManager {
-    private static instance;
-    private cacheBySigner;
-    private registry;
-    private constructor();
-    static getInstance(): AdvancedSignatureManager;
-    addSignature(pubKey: string, data: Buffer, signature: Buffer): Buffer;
-    getSignature(pubKey: string, data: Buffer): Buffer | undefined;
-    clearCache(): void;
-    clearCacheForSigner(pubKey: string): void;
-}

package/build/hooks/AdvancedSignatureManager.js

@@ -1,52 +0,0 @@
-export class AdvancedSignatureManager {
-    constructor() {
-        this.cacheBySigner = new Map();
-        this.registry = new FinalizationRegistry((entry) => {
-            const set = this.cacheBySigner.get(entry.pubKey);
-            if (set) {
-                set.delete(entry);
-                if (set.size === 0) {
-                    this.cacheBySigner.delete(entry.pubKey);
-                }
-            }
-        });
-    }
-    static getInstance() {
-        if (!AdvancedSignatureManager.instance) {
-            AdvancedSignatureManager.instance = new AdvancedSignatureManager();
-        }
-        return AdvancedSignatureManager.instance;
-    }
-    addSignature(pubKey, data, signature) {
-        const entry = {
-            pubKey,
-            dataRef: new WeakRef(data),
-            signature,
-        };
-        if (!this.cacheBySigner.has(pubKey)) {
-            this.cacheBySigner.set(pubKey, new Set());
-        }
-        const set = this.cacheBySigner.get(pubKey);
-        set.add(entry);
-        this.registry.register(data, entry);
-        return signature;
-    }
-    getSignature(pubKey, data) {
-        const set = this.cacheBySigner.get(pubKey);
-        if (!set)
-            return undefined;
-        for (const entry of set) {
-            const cachedData = entry.dataRef.deref();
-            if (cachedData && cachedData.equals(data)) {
-                return entry.signature;
-            }
-        }
-        return undefined;
-    }
-    clearCache() {
-        this.cacheBySigner.clear();
-    }
-    clearCacheForSigner(pubKey) {
-        this.cacheBySigner.delete(pubKey);
-    }
-}

package/build/hooks/HookedSigner.d.ts

@@ -1,4 +0,0 @@
-import { BIP32Interface } from '@btc-vision/bip32';
-import { ECPairInterface } from 'ecpair';
-import { Signer, SignerAlternative, SignerAsync } from '../psbt.js';
-export declare function hookSigner(keyPair: Signer | SignerAlternative | SignerAsync | BIP32Interface | ECPairInterface): void;

package/build/hooks/HookedSigner.js

@@ -1,64 +0,0 @@
-import { SignatureManager } from './SignatureManager.js';
-import { AdvancedSignatureManager } from './AdvancedSignatureManager.js';
-const advancedSignatureManager = AdvancedSignatureManager.getInstance();
-function getPublicKey(keyPair) {
-    if (keyPair.publicKey && Buffer.isBuffer(keyPair.publicKey)) {
-        return keyPair.publicKey.toString('hex');
-    }
-}
-function hookKeyPair(keyPair) {
-    const oldSign = keyPair.sign;
-    if (oldSign) {
-        keyPair.sign = new Proxy(oldSign, {
-            apply: function (target, thisArg, argumentsList) {
-                const publicKey = getPublicKey(keyPair);
-                const hash = argumentsList[0];
-                if (publicKey) {
-                    let possibleSignature = advancedSignatureManager.getSignature(publicKey, hash);
-                    if (!possibleSignature) {
-                        possibleSignature = advancedSignatureManager.addSignature(publicKey, hash, Reflect.apply(target, thisArg, argumentsList));
-                    }
-                    return possibleSignature;
-                }
-                else {
-                    let possibleSignature = keyPair.signatureManager.getSignature(hash);
-                    if (!possibleSignature) {
-                        possibleSignature = keyPair.signatureManager.addSignature(hash, Reflect.apply(target, thisArg, argumentsList));
-                    }
-                    return possibleSignature;
-                }
-            },
-        });
-    }
-    const oldSignSchnorr = keyPair.signSchnorr;
-    if (oldSignSchnorr) {
-        keyPair.signSchnorr = new Proxy(oldSignSchnorr, {
-            apply: function (target, thisArg, argumentsList) {
-                const publicKey = getPublicKey(keyPair);
-                const hash = argumentsList[0];
-                if (publicKey) {
-                    let possibleSignature = advancedSignatureManager.getSignature(publicKey, hash);
-                    if (!possibleSignature) {
-                        possibleSignature = advancedSignatureManager.addSignature(publicKey, hash, Reflect.apply(target, thisArg, argumentsList));
-                    }
-                    return possibleSignature;
-                }
-                else {
-                    let possibleSignature = keyPair.signatureManager.getSignature(hash);
-                    if (!possibleSignature) {
-                        possibleSignature = keyPair.signatureManager.addSignature(hash, Reflect.apply(target, thisArg, argumentsList));
-                    }
-                    return possibleSignature;
-                }
-            },
-        });
-    }
-}
-export function hookSigner(keyPair) {
-    const newKeypair = keyPair;
-    if (!newKeypair.hasHook) {
-        newKeypair.hasHook = true;
-        newKeypair.signatureManager = new SignatureManager();
-        hookKeyPair(newKeypair);
-    }
-}

package/build/hooks/SignatureManager.d.ts

@@ -1,13 +0,0 @@
-export interface CacheEntry {
-    length: number;
-    dataRef: WeakRef<Buffer>;
-    signature: Buffer;
-}
-export declare class SignatureManager {
-    private cacheByLength;
-    private registry;
-    constructor();
-    addSignature(data: Buffer, signature: Buffer): Buffer;
-    getSignature(data: Buffer): Buffer | undefined;
-    clearCache(): void;
-}

package/build/hooks/SignatureManager.js

@@ -1,45 +0,0 @@
-export class SignatureManager {
-    constructor() {
-        this.cacheByLength = new Map();
-        this.registry = new FinalizationRegistry((entry) => {
-            const set = this.cacheByLength.get(entry.length);
-            if (set) {
-                set.delete(entry);
-                if (set.size === 0) {
-                    this.cacheByLength.delete(entry.length);
-                }
-            }
-        });
-    }
-    addSignature(data, signature) {
-        const length = data.length;
-        const entry = {
-            length,
-            dataRef: new WeakRef(data),
-            signature,
-        };
-        if (!this.cacheByLength.has(length)) {
-            this.cacheByLength.set(length, new Set());
-        }
-        const set = this.cacheByLength.get(length);
-        set.add(entry);
-        this.registry.register(data, entry);
-        return signature;
-    }
-    getSignature(data) {
-        const length = data.length;
-        const set = this.cacheByLength.get(length);
-        if (!set)
-            return undefined;
-        for (const entry of set) {
-            const cachedData = entry.dataRef.deref();
-            if (cachedData && cachedData.equals(data)) {
-                return entry.signature;
-            }
-        }
-        return undefined;
-    }
-    clearCache() {
-        this.cacheByLength.clear();
-    }
-}

package/build/payments/lazy.d.ts

@@ -1,2 +0,0 @@
-export declare function prop<T extends object>(object: T, name: string, f: () => T[keyof T]): void;
-export declare function value<T>(f: () => T): () => T;

package/build/payments/lazy.js

@@ -1,28 +0,0 @@
-export function prop(object, name, f) {
-    Object.defineProperty(object, name, {
-        configurable: true,
-        enumerable: true,
-        get() {
-            const _value = f.call(this);
-            this[name] = _value;
-            return _value;
-        },
-        set(_value) {
-            Object.defineProperty(this, name, {
-                configurable: true,
-                enumerable: true,
-                value: _value,
-                writable: true,
-            });
-        },
-    });
-}
-export function value(f) {
-    let _value;
-    return () => {
-        if (_value !== undefined)
-            return _value;
-        _value = f();
-        return _value;
-    };
-}