xpi-ts 0.2.0

package/dist/lib/bitcore/encoding/base58check.js

@@ -0,0 +1,82 @@
+import { sha256 } from '@noble/hashes/sha256';
+const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const ALPHABET_MAP = {};
+for (let i = 0; i < ALPHABET.length; i++) {
+    ALPHABET_MAP[ALPHABET[i]] = i;
+}
+export class Base58Check {
+    static encode(buf) {
+        if (!Buffer.isBuffer(buf)) {
+            throw new Error('Input must be a Buffer');
+        }
+        const checksum = this.checksum(buf);
+        const payload = Buffer.concat([buf, checksum]);
+        return this.base58Encode(payload);
+    }
+    static decode(str) {
+        if (typeof str !== 'string') {
+            throw new Error('Input must be a string');
+        }
+        const buf = this.base58Decode(str);
+        if (buf.length < 4) {
+            throw new Error('Input string too short');
+        }
+        const data = buf.subarray(0, -4);
+        const checksum = buf.subarray(-4);
+        if (!this.validChecksum(data, checksum)) {
+            throw new Error('Invalid checksum');
+        }
+        return data;
+    }
+    static checksum(data) {
+        const hash1 = sha256(data);
+        const hash2 = sha256(hash1);
+        return Buffer.from(hash2).subarray(0, 4);
+    }
+    static validChecksum(data, checksum) {
+        const calculatedChecksum = this.checksum(data);
+        return calculatedChecksum.equals(checksum);
+    }
+    static base58Encode(buf) {
+        if (buf.length === 0)
+            return '';
+        let num = 0n;
+        for (let i = 0; i < buf.length; i++) {
+            num = num * 256n + BigInt(buf[i]);
+        }
+        let result = '';
+        while (num > 0n) {
+            result = ALPHABET[Number(num % 58n)] + result;
+            num = num / 58n;
+        }
+        for (let i = 0; i < buf.length && buf[i] === 0; i++) {
+            result = '1' + result;
+        }
+        return result;
+    }
+    static base58Decode(str) {
+        if (str.length === 0)
+            return Buffer.alloc(0);
+        let num = 0n;
+        let leadingZeros = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str[i];
+            if (ALPHABET_MAP[char] === undefined) {
+                throw new Error(`Invalid character: ${char}`);
+            }
+            num = num * 58n + BigInt(ALPHABET_MAP[char]);
+        }
+        for (let i = 0; i < str.length && str[i] === '1'; i++) {
+            leadingZeros++;
+        }
+        const bytes = [];
+        while (num > 0n) {
+            bytes.unshift(Number(num % 256n));
+            num = num / 256n;
+        }
+        for (let i = 0; i < leadingZeros; i++) {
+            bytes.unshift(0);
+        }
+        return Buffer.from(bytes);
+    }
+}

package/dist/lib/bitcore/encoding/bufferreader.d.ts

@@ -0,0 +1,34 @@
+import { BN } from '../crypto/bn.js';
+export interface BufferReaderData {
+    buf?: Buffer;
+    pos?: number;
+}
+export declare class BufferReader {
+    buf: Buffer;
+    pos: number;
+    constructor(buf?: Buffer | string | BufferReaderData);
+    static create(buf?: Buffer | string | BufferReaderData): BufferReader;
+    set(obj: BufferReaderData): BufferReader;
+    eof(): boolean;
+    finished(): boolean;
+    read(len: number): Buffer;
+    readAll(): Buffer;
+    readUInt8(): number;
+    readUInt16BE(): number;
+    readUInt16LE(): number;
+    readUInt32BE(): number;
+    readUInt32LE(): number;
+    readUInt48LE(): number;
+    readUInt56LEBN(): BN;
+    readInt32LE(): number;
+    readUInt64BEBN(): BN;
+    readUInt64LEBN(): BN;
+    readUInt32LEBN(): BN;
+    readVarintNum(): number;
+    readVarLengthBuffer(): Buffer;
+    readVarintBuf(): Buffer;
+    readVarintBN(): BN;
+    reverse(): BufferReader;
+    readReverse(len?: number): Buffer;
+}
+//# sourceMappingURL=bufferreader.d.ts.map

package/dist/lib/bitcore/encoding/bufferreader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bufferreader.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/encoding/bufferreader.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAA;AAGpC,MAAM,WAAW,gBAAgB;IAC/B,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAED,qBAAa,YAAY;IACvB,GAAG,EAAG,MAAM,CAAA;IACZ,GAAG,EAAE,MAAM,CAAI;gBAEH,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,gBAAgB;IA0BpD,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,gBAAgB,GAAG,YAAY;IAIrE,GAAG,CAAC,GAAG,EAAE,gBAAgB,GAAG,YAAY;IAMxC,GAAG,IAAI,OAAO;IAId,QAAQ,IAAI,OAAO;IAInB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAWzB,OAAO,IAAI,MAAM;IAMjB,SAAS,IAAI,MAAM;IAMnB,YAAY,IAAI,MAAM;IAMtB,YAAY,IAAI,MAAM;IAMtB,YAAY,IAAI,MAAM;IAMtB,YAAY,IAAI,MAAM;IAMtB,YAAY,IAAI,MAAM;IAMtB,cAAc,IAAI,EAAE;IAOpB,WAAW,IAAI,MAAM;IAMrB,cAAc,IAAI,EAAE;IAOpB,cAAc,IAAI,EAAE;IAqBpB,cAAc,IAAI,EAAE;IAMpB,aAAa,IAAI,MAAM;IA0BvB,mBAAmB,IAAI,MAAM;IAc7B,aAAa,IAAI,MAAM;IAcvB,YAAY,IAAI,EAAE;IAclB,OAAO,IAAI,YAAY;IASvB,WAAW,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM;CAQlC"}

package/dist/lib/bitcore/encoding/bufferreader.js

@@ -0,0 +1,198 @@
+import { Preconditions } from '../util/preconditions.js';
+import { BN } from '../crypto/bn.js';
+import { BufferUtil } from '../util/buffer.js';
+export class BufferReader {
+    buf;
+    pos = 0;
+    constructor(buf) {
+        if (buf === undefined) {
+            return;
+        }
+        if (Buffer.isBuffer(buf)) {
+            this.set({
+                buf: buf,
+            });
+        }
+        else if (typeof buf === 'string') {
+            const b = Buffer.from(buf, 'hex');
+            if (b.length * 2 !== buf.length) {
+                throw new TypeError('Invalid hex string');
+            }
+            this.set({
+                buf: b,
+            });
+        }
+        else if (typeof buf === 'object' && buf !== null) {
+            const obj = buf;
+            this.set(obj);
+        }
+        else {
+            throw new TypeError('Unrecognized argument for BufferReader');
+        }
+    }
+    static create(buf) {
+        return new BufferReader(buf);
+    }
+    set(obj) {
+        this.buf = obj.buf || this.buf || undefined;
+        this.pos = obj.pos || this.pos || 0;
+        return this;
+    }
+    eof() {
+        return this.pos >= this.buf.length;
+    }
+    finished() {
+        return this.eof();
+    }
+    read(len) {
+        Preconditions.checkArgument(len !== undefined, 'len', 'Must specify a length');
+        const buf = this.buf.slice(this.pos, this.pos + len);
+        this.pos = this.pos + len;
+        return buf;
+    }
+    readAll() {
+        const buf = this.buf.slice(this.pos, this.buf.length);
+        this.pos = this.buf.length;
+        return buf;
+    }
+    readUInt8() {
+        const val = this.buf.readUInt8(this.pos);
+        this.pos = this.pos + 1;
+        return val;
+    }
+    readUInt16BE() {
+        const val = this.buf.readUInt16BE(this.pos);
+        this.pos = this.pos + 2;
+        return val;
+    }
+    readUInt16LE() {
+        const val = this.buf.readUInt16LE(this.pos);
+        this.pos = this.pos + 2;
+        return val;
+    }
+    readUInt32BE() {
+        const val = this.buf.readUInt32BE(this.pos);
+        this.pos = this.pos + 4;
+        return val;
+    }
+    readUInt32LE() {
+        const val = this.buf.readUInt32LE(this.pos);
+        this.pos = this.pos + 4;
+        return val;
+    }
+    readUInt48LE() {
+        const val = this.buf.readUIntLE(this.pos, 6);
+        this.pos = this.pos + 6;
+        return val;
+    }
+    readUInt56LEBN() {
+        const buf = this.buf.slice(this.pos, this.pos + 7);
+        const bn = BN.fromBuffer(buf, { endian: 'little' });
+        this.pos = this.pos + 7;
+        return bn;
+    }
+    readInt32LE() {
+        const val = this.buf.readInt32LE(this.pos);
+        this.pos = this.pos + 4;
+        return val;
+    }
+    readUInt64BEBN() {
+        const buf = this.buf.slice(this.pos, this.pos + 8);
+        const bn = BN.fromBuffer(buf);
+        this.pos = this.pos + 8;
+        return bn;
+    }
+    readUInt64LEBN() {
+        const second = this.buf.readUInt32LE(this.pos);
+        const first = this.buf.readUInt32LE(this.pos + 4);
+        const combined = first * 0x100000000 + second;
+        let bn;
+        if (combined <= 0x1fffffffffffff) {
+            bn = new BN(combined);
+        }
+        else {
+            const data = Array.prototype.slice.call(this.buf, this.pos, this.pos + 8);
+            bn = new BN(Buffer.from(data), 'le');
+        }
+        this.pos = this.pos + 8;
+        return bn;
+    }
+    readUInt32LEBN() {
+        const value = this.buf.readUInt32LE(this.pos);
+        this.pos = this.pos + 4;
+        return new BN(value);
+    }
+    readVarintNum() {
+        const first = this.readUInt8();
+        switch (first) {
+            case 0xfd:
+                return this.readUInt16LE();
+            case 0xfe:
+                return this.readUInt32LE();
+            case 0xff: {
+                const bn = this.readUInt64LEBN();
+                const n = Number(bn);
+                if (n <= Math.pow(2, 53)) {
+                    return n;
+                }
+                else {
+                    throw new Error('number too large to retain precision - use readVarintBN');
+                }
+            }
+            default:
+                return first;
+        }
+    }
+    readVarLengthBuffer() {
+        const len = this.readVarintNum();
+        const buf = this.read(len);
+        Preconditions.checkState(buf.length === len, 'Invalid length while reading varlength buffer. ' +
+            'Expected to read: ' +
+            len +
+            ' and read ' +
+            buf.length);
+        return buf;
+    }
+    readVarintBuf() {
+        const first = this.buf.readUInt8(this.pos);
+        switch (first) {
+            case 0xfd:
+                return this.read(1 + 2);
+            case 0xfe:
+                return this.read(1 + 4);
+            case 0xff:
+                return this.read(1 + 8);
+            default:
+                return this.read(1);
+        }
+    }
+    readVarintBN() {
+        const first = this.readUInt8();
+        switch (first) {
+            case 0xfd:
+                return new BN(this.readUInt16LE());
+            case 0xfe:
+                return new BN(this.readUInt32LE());
+            case 0xff:
+                return this.readUInt64LEBN();
+            default:
+                return new BN(first);
+        }
+    }
+    reverse() {
+        const buf = Buffer.alloc(this.buf.length);
+        for (let i = 0; i < buf.length; i++) {
+            buf[i] = this.buf[this.buf.length - 1 - i];
+        }
+        this.buf = buf;
+        return this;
+    }
+    readReverse(len) {
+        if (len === undefined) {
+            len = this.buf.length;
+        }
+        const buf = this.buf.slice(this.pos, this.pos + len);
+        this.pos = this.pos + len;
+        return BufferUtil.reverse(buf);
+    }
+}

package/dist/lib/bitcore/encoding/bufferwriter.d.ts

@@ -0,0 +1,36 @@
+import { BN } from '../crypto/bn.js';
+export interface BufferWriterData {
+    bufs?: Buffer[];
+}
+export declare class BufferWriter {
+    bufs: Buffer[];
+    bufLen: number;
+    constructor(obj?: BufferWriterData);
+    static create(obj?: BufferWriterData): BufferWriter;
+    set(obj: BufferWriterData): BufferWriter;
+    toBuffer(): Buffer;
+    concat(): Buffer;
+    write(buf: Buffer): BufferWriter;
+    writeReverse(buf: Buffer): BufferWriter;
+    writeUInt8(n: number): BufferWriter;
+    writeUInt16BE(n: number): BufferWriter;
+    writeUInt16LE(n: number): BufferWriter;
+    writeUInt32BE(n: number): BufferWriter;
+    writeInt32LE(n: number): BufferWriter;
+    writeUInt32LE(n: number): BufferWriter;
+    writeUInt48LE(n: number): BufferWriter;
+    writeUInt56LE(n: number): BufferWriter;
+    writeUInt64BEBN(bn: BN): BufferWriter;
+    writeUInt56LEBN(bn: BN): BufferWriter;
+    writeUInt64LEBN(bn: BN): BufferWriter;
+    writeUInt64LEBigInt(value: bigint): BufferWriter;
+    writeUInt32LEBN(bn: BN): BufferWriter;
+    writeUInt32LENumber(value: number): BufferWriter;
+    writeVarintNum(n: number): BufferWriter;
+    writeVarintBN(bn: BN): BufferWriter;
+    writeVarLengthBuffer(buf: Buffer): BufferWriter;
+    static varintBufNum(n: number): Buffer;
+    static varintBufBN(bn: BN): Buffer;
+}
+export declare function BufferWriterFactory(obj?: BufferWriterData): BufferWriter;
+//# sourceMappingURL=bufferwriter.d.ts.map

package/dist/lib/bitcore/encoding/bufferwriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bufferwriter.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/encoding/bufferwriter.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAA;AAEpC,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;CAChB;AAED,qBAAa,YAAY;IACvB,IAAI,EAAE,MAAM,EAAE,CAAK;IACnB,MAAM,EAAE,MAAM,CAAI;gBAEN,GAAG,CAAC,EAAE,gBAAgB;IAUlC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,gBAAgB,GAAG,YAAY;IAInD,GAAG,CAAC,GAAG,EAAE,gBAAgB,GAAG,YAAY;IAMxC,QAAQ,IAAI,MAAM;IAIlB,MAAM,IAAI,MAAM;IAIhB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY;IAShC,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY;IASvC,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY;IAOnC,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY;IAOtC,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY;IAOtC,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY;IAOtC,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY;IAOrC,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY;IAOtC,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY;IAOtC,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY;IAOtC,eAAe,CAAC,EAAE,EAAE,EAAE,GAAG,YAAY;IAMrC,eAAe,CAAC,EAAE,EAAE,EAAE,GAAG,YAAY;IAMrC,eAAe,CAAC,EAAE,EAAE,EAAE,GAAG,YAAY;IAMrC,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY;IAKhD,eAAe,CAAC,EAAE,EAAE,EAAE,GAAG,YAAY;IAMrC,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY;IAKhD,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY;IAMvC,aAAa,CAAC,EAAE,EAAE,EAAE,GAAG,YAAY;IAMnC,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY;IAM/C,MAAM,CAAC,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAsBtC,MAAM,CAAC,WAAW,CAAC,EAAE,EAAE,EAAE,GAAG,MAAM;CAuBnC;AAGD,wBAAgB,mBAAmB,CAAC,GAAG,CAAC,EAAE,gBAAgB,GAAG,YAAY,CAExE"}

package/dist/lib/bitcore/encoding/bufferwriter.js

@@ -0,0 +1,189 @@
+import { BufferUtil } from '../util/buffer.js';
+import { BN } from '../crypto/bn.js';
+export class BufferWriter {
+    bufs = [];
+    bufLen = 0;
+    constructor(obj) {
+        this.bufLen = 0;
+        if (obj) {
+            this.set(obj);
+        }
+        else {
+            this.bufs = [];
+        }
+    }
+    static create(obj) {
+        return new BufferWriter(obj);
+    }
+    set(obj) {
+        this.bufs = obj.bufs || this.bufs || [];
+        this.bufLen = this.bufs.reduce((prev, buf) => prev + buf.length, 0);
+        return this;
+    }
+    toBuffer() {
+        return this.concat();
+    }
+    concat() {
+        return Buffer.concat(this.bufs, this.bufLen);
+    }
+    write(buf) {
+        if (!BufferUtil.isBuffer(buf)) {
+            throw new Error('Expected Buffer');
+        }
+        this.bufs.push(buf);
+        this.bufLen += buf.length;
+        return this;
+    }
+    writeReverse(buf) {
+        if (!BufferUtil.isBuffer(buf)) {
+            throw new Error('Expected Buffer');
+        }
+        this.bufs.push(BufferUtil.reverse(buf));
+        this.bufLen += buf.length;
+        return this;
+    }
+    writeUInt8(n) {
+        const buf = Buffer.alloc(1);
+        buf.writeUInt8(n, 0);
+        this.write(buf);
+        return this;
+    }
+    writeUInt16BE(n) {
+        const buf = Buffer.alloc(2);
+        buf.writeUInt16BE(n, 0);
+        this.write(buf);
+        return this;
+    }
+    writeUInt16LE(n) {
+        const buf = Buffer.alloc(2);
+        buf.writeUInt16LE(n, 0);
+        this.write(buf);
+        return this;
+    }
+    writeUInt32BE(n) {
+        const buf = Buffer.alloc(4);
+        buf.writeUInt32BE(n, 0);
+        this.write(buf);
+        return this;
+    }
+    writeInt32LE(n) {
+        const buf = Buffer.alloc(4);
+        buf.writeInt32LE(n, 0);
+        this.write(buf);
+        return this;
+    }
+    writeUInt32LE(n) {
+        const buf = Buffer.alloc(4);
+        buf.writeUInt32LE(n, 0);
+        this.write(buf);
+        return this;
+    }
+    writeUInt48LE(n) {
+        const buf = Buffer.alloc(6);
+        buf.writeUIntLE(n, 0, 6);
+        this.write(buf);
+        return this;
+    }
+    writeUInt56LE(n) {
+        const buf = Buffer.alloc(7);
+        buf.writeUIntLE(n, 0, 7);
+        this.write(buf);
+        return this;
+    }
+    writeUInt64BEBN(bn) {
+        const buf = bn.toBuffer({ size: 8 });
+        this.write(buf);
+        return this;
+    }
+    writeUInt56LEBN(bn) {
+        const buf = bn.toBuffer({ size: 7 });
+        this.writeReverse(buf);
+        return this;
+    }
+    writeUInt64LEBN(bn) {
+        const buf = bn.toBuffer({ size: 8 });
+        this.writeReverse(buf);
+        return this;
+    }
+    writeUInt64LEBigInt(value) {
+        const bn = new BN(value.toString());
+        return this.writeUInt64LEBN(bn);
+    }
+    writeUInt32LEBN(bn) {
+        const value = bn.toNumber();
+        this.writeUInt32LE(value);
+        return this;
+    }
+    writeUInt32LENumber(value) {
+        this.writeUInt32LE(value);
+        return this;
+    }
+    writeVarintNum(n) {
+        const buf = BufferWriter.varintBufNum(n);
+        this.write(buf);
+        return this;
+    }
+    writeVarintBN(bn) {
+        const buf = BufferWriter.varintBufBN(bn);
+        this.write(buf);
+        return this;
+    }
+    writeVarLengthBuffer(buf) {
+        this.writeVarintNum(buf.length);
+        this.write(buf);
+        return this;
+    }
+    static varintBufNum(n) {
+        let buf;
+        if (n < 253) {
+            buf = Buffer.alloc(1);
+            buf.writeUInt8(n, 0);
+        }
+        else if (n < 0x10000) {
+            buf = Buffer.alloc(1 + 2);
+            buf.writeUInt8(253, 0);
+            buf.writeUInt16LE(n, 1);
+        }
+        else if (n < 0x100000000) {
+            buf = Buffer.alloc(1 + 4);
+            buf.writeUInt8(254, 0);
+            buf.writeUInt32LE(n, 1);
+        }
+        else {
+            buf = Buffer.alloc(1 + 8);
+            buf.writeUInt8(255, 0);
+            buf.writeInt32LE(n & -1, 1);
+            buf.writeUInt32LE(Math.floor(n / 0x100000000), 5);
+        }
+        return buf;
+    }
+    static varintBufBN(bn) {
+        const n = bn.toNumber();
+        if (n < 253) {
+            const buf = Buffer.alloc(1);
+            buf.writeUInt8(n, 0);
+            return buf;
+        }
+        else if (n < 0x10000) {
+            const buf = Buffer.alloc(1 + 2);
+            buf.writeUInt8(253, 0);
+            buf.writeUInt16LE(n, 1);
+            return buf;
+        }
+        else if (n < 0x100000000) {
+            const buf = Buffer.alloc(1 + 4);
+            buf.writeUInt8(254, 0);
+            buf.writeUInt32LE(n, 1);
+            return buf;
+        }
+        else {
+            const bw = new BufferWriter();
+            bw.writeUInt8(255);
+            bw.writeUInt64LEBN(bn);
+            return bw.concat();
+        }
+    }
+}
+export function BufferWriterFactory(obj) {
+    return new BufferWriter(obj);
+}

package/dist/lib/bitcore/encoding/varint.d.ts

@@ -0,0 +1,20 @@
+import { BufferReader } from './bufferreader.js';
+import { BN } from '../crypto/bn.js';
+export interface VarintData {
+    buf?: Buffer;
+}
+export declare class Varint {
+    buf: Buffer;
+    constructor(buf?: Buffer | number | BN | VarintData);
+    set(obj: VarintData): Varint;
+    fromString(str: string): Varint;
+    toString(): string;
+    fromBuffer(buf: Buffer): Varint;
+    fromBufferReader(br: BufferReader): Varint;
+    fromBN(bn: BN): Varint;
+    fromNumber(num: number): Varint;
+    toBuffer(): Buffer;
+    toBN(): BN;
+    toNumber(): number;
+}
+//# sourceMappingURL=varint.d.ts.map

package/dist/lib/bitcore/encoding/varint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"varint.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/encoding/varint.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,EAAE,EAAE,MAAM,iBAAiB,CAAA;AAEpC,MAAM,WAAW,UAAU;IACzB,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAED,qBAAa,MAAM;IACjB,GAAG,EAAE,MAAM,CAAkB;gBAEjB,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,EAAE,GAAG,UAAU;IAenD,GAAG,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM;IAK5B,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAO/B,QAAQ,IAAI,MAAM;IAIlB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAK/B,gBAAgB,CAAC,EAAE,EAAE,YAAY,GAAG,MAAM;IAK1C,MAAM,CAAC,EAAE,EAAE,EAAE,GAAG,MAAM;IAKtB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAK/B,QAAQ,IAAI,MAAM;IAIlB,IAAI,IAAI,EAAE;IAIV,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/lib/bitcore/encoding/varint.js

@@ -0,0 +1,61 @@
+import { BufferWriter } from './bufferwriter.js';
+import { BufferReader } from './bufferreader.js';
+import { BN } from '../crypto/bn.js';
+export class Varint {
+    buf = Buffer.alloc(0);
+    constructor(buf) {
+        if (Buffer.isBuffer(buf)) {
+            this.buf = buf;
+        }
+        else if (typeof buf === 'number') {
+            const num = buf;
+            this.fromNumber(num);
+        }
+        else if (buf instanceof BN) {
+            const bn = buf;
+            this.fromBN(bn);
+        }
+        else if (buf) {
+            const obj = buf;
+            this.set(obj);
+        }
+    }
+    set(obj) {
+        this.buf = obj.buf || this.buf;
+        return this;
+    }
+    fromString(str) {
+        this.set({
+            buf: Buffer.from(str, 'hex'),
+        });
+        return this;
+    }
+    toString() {
+        return this.buf.toString('hex');
+    }
+    fromBuffer(buf) {
+        this.buf = buf;
+        return this;
+    }
+    fromBufferReader(br) {
+        this.buf = br.readVarintBuf();
+        return this;
+    }
+    fromBN(bn) {
+        this.buf = BufferWriter.varintBufBN(bn);
+        return this;
+    }
+    fromNumber(num) {
+        this.buf = new BufferWriter().writeVarintNum(num).concat();
+        return this;
+    }
+    toBuffer() {
+        return this.buf;
+    }
+    toBN() {
+        return new BufferReader(this.buf).readVarintBN();
+    }
+    toNumber() {
+        return new BufferReader(this.buf).readVarintNum();
+    }
+}

package/dist/lib/bitcore/errors.d.ts

@@ -0,0 +1,28 @@
+interface ErrorDefinition {
+    name: string;
+    message: string | ((...args: unknown[]) => string);
+    errors?: ErrorDefinition[];
+}
+export declare class BitcoreError extends Error {
+    constructor(message?: string);
+    static extend(spec: ErrorDefinition): Function;
+    static NotImplemented: new (message?: string) => BitcoreError;
+    static Script: {
+        InvalidBuffer: new (buffer: string) => BitcoreError;
+        UnrecognizedAddress: new (address: unknown) => BitcoreError;
+        CantDeriveAddress: new (script: string) => BitcoreError;
+        InvalidScriptString: new (script: string) => BitcoreError;
+    };
+    static Precondition: {
+        InvalidState: new (message: string) => BitcoreError;
+        InvalidArgument: new (argumentName: string, message?: string, docsPath?: string) => BitcoreError;
+        InvalidArgumentType: new (argument: unknown, type: string | Function, argumentName?: string) => BitcoreError;
+    };
+    static Transaction: {
+        Input: {
+            MissingScript: new () => BitcoreError;
+        };
+    };
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/lib/bitcore/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../lib/bitcore/errors.ts"],"names":[],"mappings":"AAoDA,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,MAAM,CAAC,CAAA;IAClD,MAAM,CAAC,EAAE,eAAe,EAAE,CAAA;CAC3B;AAoSD,qBAAa,YAAa,SAAQ,KAAK;gBACzB,OAAO,CAAC,EAAE,MAAM;IAM5B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,GAAG,QAAQ;IAK9C,MAAM,CAAC,cAAc,EAAE,KAAK,OAAO,CAAC,EAAE,MAAM,KAAK,YAAY,CAAA;IAC7D,MAAM,CAAC,MAAM,EAAE;QACb,aAAa,EAAE,KAAK,MAAM,EAAE,MAAM,KAAK,YAAY,CAAA;QACnD,mBAAmB,EAAE,KAAK,OAAO,EAAE,OAAO,KAAK,YAAY,CAAA;QAC3D,iBAAiB,EAAE,KAAK,MAAM,EAAE,MAAM,KAAK,YAAY,CAAA;QACvD,mBAAmB,EAAE,KAAK,MAAM,EAAE,MAAM,KAAK,YAAY,CAAA;KAC1D,CAAA;IACD,MAAM,CAAC,YAAY,EAAE;QACnB,YAAY,EAAE,KAAK,OAAO,EAAE,MAAM,KAAK,YAAY,CAAA;QACnD,eAAe,EAAE,KACf,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,MAAM,KACd,YAAY,CAAA;QACjB,mBAAmB,EAAE,KACnB,QAAQ,EAAE,OAAO,EACjB,IAAI,EAAE,MAAM,GAAG,QAAQ,EACvB,YAAY,CAAC,EAAE,MAAM,KAClB,YAAY,CAAA;KAClB,CAAA;IACD,MAAM,CAAC,WAAW,EAAE;QAClB,KAAK,EAAE;YACL,aAAa,EAAE,UAAU,YAAY,CAAA;SACtC,CAAA;KACF,CAAA;CACF"}