@btc-vision/transaction 1.0.113 → 1.0.114

package/browser/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.0.113";
+export declare const version = "1.0.114";

package/browser/abi/ABICoder.d.ts

@@ -0,0 +1,31 @@
+export declare enum ABIDataTypes {
+    UINT8 = "UINT8",
+    UINT16 = "UINT16",
+    UINT32 = "UINT32",
+    UINT64 = "UINT64",
+    BOOL = "BOOL",
+    ADDRESS = "ADDRESS",
+    STRING = "STRING",
+    BYTES32 = "BYTES32",
+    UINT256 = "UINT256",
+    TUPLE = "TUPLE",
+    BYTES = "BYTES",
+    ADDRESS_UINT256_TUPLE = "ADDRESS_UINT256_TUPLE",
+    ARRAY_OF_ADDRESSES = "ARRAY_OF_ADDRESSES",
+    ARRAY_OF_UINT256 = "ARRAY_OF_UINT256",
+    ARRAY_OF_UINT64 = "ARRAY_OF_UINT64",
+    ARRAY_OF_UINT32 = "ARRAY_OF_UINT32",
+    ARRAY_OF_UINT16 = "ARRAY_OF_UINT16",
+    ARRAY_OF_UINT8 = "ARRAY_OF_UINT8",
+    ARRAY_OF_STRING = "ARRAY_OF_STRING",
+    ARRAY_OF_BYTES = "ARRAY_OF_BYTES"
+}
+export declare class ABICoder {
+    decodeData(data: Uint8Array, types: ABIDataTypes[]): unknown[];
+    encodePointer(key: string): bigint;
+    encodePointerHash(pointer: number, sub: bigint): Uint8Array;
+    encodeSelector(selectorIdentifier: string): string;
+    numericSelectorToHex(selector: number): string;
+    private bigIntToUint8Array;
+    private sha256;
+}

package/browser/buffer/BinaryReader.d.ts

@@ -0,0 +1,37 @@
+import { BufferLike, i32, Selector, u16, u32, u8 } from '../utils/types.js';
+import { Address } from '../keypair/Address.js';
+import { AddressMap } from '../deterministic/AddressMap.js';
+export declare class BinaryReader {
+    private buffer;
+    private currentOffset;
+    constructor(bytes: BufferLike);
+    static stringCompare(a: string, b: string): number;
+    static bigintCompare(a: bigint, b: bigint): number;
+    static numberCompare(a: number, b: number): number;
+    setBuffer(bytes: BufferLike): void;
+    readAddressArray(): Address[];
+    readU256Array(): bigint[];
+    readU64Array(): bigint[];
+    readU32Array(): u32[];
+    readU16Array(): u16[];
+    readU8Array(): u8[];
+    readStringArray(): string[];
+    readBytesArray(): Uint8Array[];
+    readBytesWithLength(maxLength?: number): Uint8Array;
+    readTuple(): bigint[];
+    readU8(): u8;
+    readU16(): u16;
+    readU32(le?: boolean): u32;
+    readU64(): bigint;
+    readAddressValueTuple(): AddressMap<bigint>;
+    readU256(): bigint;
+    readBytes(length: u32, zeroStop?: boolean): Uint8Array;
+    readString(length: u16): string;
+    readSelector(): Selector;
+    readStringWithLength(): string;
+    readBoolean(): boolean;
+    readAddress(): Address;
+    getOffset(): u16;
+    setOffset(offset: u16): void;
+    verifyEnd(size: i32): void;
+}

package/browser/buffer/BinaryWriter.d.ts

@@ -0,0 +1,46 @@
+import { 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 declare class BinaryWriter {
+    private currentOffset;
+    private buffer;
+    constructor(length?: number);
+    writeU8(value: u8): void;
+    writeU16(value: u16): void;
+    writeU32(value: u32, le?: boolean): void;
+    writeU64(value: u64): void;
+    writeSelector(value: Selector): void;
+    writeBoolean(value: boolean): void;
+    writeU256(bigIntValue: bigint): void;
+    writeBytes(value: Uint8Array | Buffer): void;
+    writeString(value: string): void;
+    writeAddress(value: Address): void;
+    writeStringWithLength(value: string): void;
+    getBuffer(clear?: boolean): Uint8Array;
+    reset(): void;
+    writeTuple(values: bigint[]): void;
+    toBytesReader(): BinaryReader;
+    getOffset(): u32;
+    setOffset(offset: u32): void;
+    clear(): void;
+    allocSafe(size: u32): void;
+    writeABISelector(name: string, selector: Selector): void;
+    writeAddressValueTupleMap(map: AddressMap<bigint>): void;
+    writeLimitedAddressBytesMap(map: AddressMap<Uint8Array[]>): void;
+    writeBytesWithLength(value: Uint8Array): void;
+    writeAddressArray(value: Address[]): void;
+    writeU32Array(value: u32[]): void;
+    writeU256Array(value: bigint[]): void;
+    writeStringArray(value: string[]): void;
+    writeU16Array(value: u16[]): void;
+    writeU8Array(value: u8[]): void;
+    writeU64Array(value: bigint[]): void;
+    writeBytesArray(value: Uint8Array[]): void;
+    writeSelectorArray(value: Selector[]): void;
+    private getChecksum;
+    private writeMethodSelectorMap;
+    private fromAddress;
+    private resize;
+    private getDefaultBuffer;
+}

package/browser/deterministic/AddressMap.d.ts

@@ -0,0 +1,10 @@
+import { i32 } from '../utils/types.js';
+import { Address } from '../keypair/Address.js';
+import { Map } from './Map.js';
+export declare class AddressMap<V> extends Map<Address, V> {
+    set(key: Address, value: V): void;
+    indexOf(address: Address): i32;
+    has(key: Address): boolean;
+    get(key: Address): V;
+    delete(key: Address): boolean;
+}

package/browser/deterministic/AddressSet.d.ts

@@ -0,0 +1,13 @@
+import { i32 } from '../utils/types.js';
+import { Address } from '../keypair/Address.js';
+export declare class AddressSet {
+    private keys;
+    constructor(keys?: Address[]);
+    add(address: Address): void;
+    contains(address: Address): boolean;
+    remove(address: Address): void;
+    size(): i32;
+    clone(): AddressSet;
+    clear(): void;
+    combine(set: AddressSet): AddressSet;
+}

package/browser/deterministic/DeterministicMap.d.ts

@@ -0,0 +1,17 @@
+export declare class DeterministicMap<K, V> {
+    #private;
+    private compareFn;
+    private map;
+    constructor(compareFn: (a: K, b: K) => number);
+    get size(): number;
+    static fromMap<K, V>(map: Map<K, V>, compareFn: (a: K, b: K) => number): DeterministicMap<K, V>;
+    set(key: K, value: V): void;
+    get(key: K): V | undefined;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    forEach(callback: (value: V, key: K, map: DeterministicMap<K, V>) => void): void;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+}

package/browser/deterministic/DeterministicSet.d.ts

@@ -0,0 +1,13 @@
+export declare class DeterministicSet<T> {
+    private compareFn;
+    private elements;
+    constructor(compareFn: (a: T, b: T) => number);
+    add(value: T): void;
+    delete(value: T): boolean;
+    has(value: T): boolean;
+    clear(): void;
+    forEach(callback: (value: T, set: DeterministicSet<T>) => void): void;
+    static fromSet<T>(set: Set<T>, compareFn: (a: T, b: T) => number): DeterministicSet<T>;
+    get size(): number;
+    [Symbol.iterator](): IterableIterator<T>;
+}

package/browser/deterministic/Map.d.ts

@@ -0,0 +1,14 @@
+import { i32 } from '../utils/types.js';
+export declare class Map<K, V> {
+    protected _keys: K[];
+    protected _values: V[];
+    get size(): i32;
+    keys(): K[];
+    values(): V[];
+    set(key: K, value: V): void;
+    indexOf(key: K): i32;
+    get(key: K): V;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+}

package/browser/event/NetEvent.d.ts

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

package/browser/generators/AddressGenerator.d.ts

@@ -1,5 +1,8 @@
 import { Network } from 'bitcoinjs-lib';
 export declare class AddressGenerator {
     static generatePKSH(sha256Hash: Buffer, network: Network): string;
+    static generateTaprootAddress(pubKey: Buffer, network: {
+        bech32: string;
+    }): string;
     private static toSegwitAddress;
 }