xpi-ts 0.2.0

package/dist/lib/bitcore/block/blockheader.d.ts

@@ -0,0 +1,82 @@
+import { BufferReader } from '../encoding/bufferreader.js';
+import { BufferWriter } from '../encoding/bufferwriter.js';
+import { BN } from '../crypto/bn.js';
+export interface BlockHeaderData {
+    prevHash?: Buffer | string;
+    bits?: number;
+    time?: number;
+    timestamp?: number;
+    reserved?: number;
+    nonce?: BN;
+    version?: number;
+    size?: BN;
+    height?: number;
+    epochBlock?: Buffer | string;
+    merkleRoot?: Buffer | string;
+    extendedMetadata?: Buffer | string;
+    hash?: string;
+}
+export interface BlockHeaderObject {
+    hash: string;
+    prevHash: string;
+    bits: number;
+    time: number;
+    reserved: number;
+    nonce: string;
+    version: number;
+    size: number;
+    height: number;
+    epochBlock: string;
+    merkleRoot: string;
+    extendedMetadata: string;
+}
+export declare class BlockHeader {
+    static readonly Constants: {
+        START_OF_HEADER: number;
+        MAX_TIME_OFFSET: number;
+        LARGEST_HASH: BN;
+    };
+    static readonly START_OF_HEADER = 0;
+    static readonly MAX_TIME_OFFSET: number;
+    static readonly LARGEST_HASH: bigint;
+    prevHash: Buffer;
+    bits: number;
+    time: number;
+    timestamp: number;
+    reserved: number;
+    nonce: BN;
+    version: number;
+    size: BN;
+    height: number;
+    epochBlock: Buffer;
+    merkleRoot: Buffer;
+    extendedMetadata: Buffer;
+    private _id?;
+    constructor(arg?: BlockHeaderData | BlockHeader);
+    private static _from;
+    private static _fromObject;
+    static fromObject(obj: BlockHeaderData): BlockHeader;
+    static fromRawBlock(data: Buffer | string): BlockHeader;
+    static fromBuffer(buf: Buffer): BlockHeader;
+    static fromString(str: string): BlockHeader;
+    private static _fromBufferReader;
+    static fromBufferReader(br: BufferReader): BlockHeader;
+    toObject(): BlockHeaderObject;
+    toJSON: () => BlockHeaderObject;
+    toBuffer(): Buffer;
+    toString(): string;
+    toBufferWriter(bw?: BufferWriter): BufferWriter;
+    getTargetDifficulty(bits?: number): BN;
+    getDifficulty(): number;
+    private _getHash;
+    private _timeToBytes;
+    private _sizeToBytes;
+    private _getLayer3Hash;
+    private _getLayer2Hash;
+    get hash(): string;
+    get id(): string;
+    validTimestamp(): boolean;
+    validProofOfWork(): boolean;
+    inspect(): string;
+}
+//# sourceMappingURL=blockheader.d.ts.map

package/dist/lib/bitcore/block/blockheader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blockheader.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/block/blockheader.ts"],"names":[],"mappings":"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"}

package/dist/lib/bitcore/block/blockheader.js

@@ -0,0 +1,323 @@
+import { Preconditions } from '../util/preconditions.js';
+import { BufferUtil } from '../util/buffer.js';
+import { BufferReader } from '../encoding/bufferreader.js';
+import { BufferWriter } from '../encoding/bufferwriter.js';
+import { Hash } from '../crypto/hash.js';
+import { JSUtil } from '../util/js.js';
+import { BN } from '../crypto/bn.js';
+const GENESIS_BITS = 0x1d00ffff;
+export class BlockHeader {
+    static Constants = {
+        START_OF_HEADER: 0,
+        MAX_TIME_OFFSET: 2 * 60 * 60,
+        LARGEST_HASH: new BN('10000000000000000000000000000000000000000000000000000000000000000', 'hex'),
+    };
+    static START_OF_HEADER = 0;
+    static MAX_TIME_OFFSET = 2 * 60 * 60;
+    static LARGEST_HASH = BigInt('0x10000000000000000000000000000000000000000000000000000000000000000');
+    prevHash;
+    bits;
+    time;
+    timestamp;
+    reserved;
+    nonce;
+    version;
+    size;
+    height;
+    epochBlock;
+    merkleRoot;
+    extendedMetadata;
+    _id;
+    constructor(arg) {
+        if (arg instanceof BlockHeader) {
+            return arg;
+        }
+        this.prevHash = Buffer.alloc(32);
+        this.bits = 0;
+        this.time = 0;
+        this.timestamp = 0;
+        this.reserved = 0;
+        this.nonce = new BN(0);
+        this.version = 0;
+        this.size = new BN(0);
+        this.height = 0;
+        this.epochBlock = Buffer.alloc(32);
+        this.merkleRoot = Buffer.alloc(32);
+        this.extendedMetadata = Buffer.alloc(32);
+        if (arg && typeof arg === 'object') {
+            const info = BlockHeader._from(arg);
+            this.prevHash = info.prevHash;
+            this.bits = info.bits;
+            this.time = info.time;
+            this.timestamp = info.time;
+            this.reserved = info.reserved || 0;
+            this.nonce = info.nonce;
+            this.version = info.version;
+            this.size = info.size;
+            this.height = info.height;
+            this.epochBlock = info.epochBlock;
+            this.merkleRoot = info.merkleRoot;
+            this.extendedMetadata = info.extendedMetadata;
+            if (info.hash) {
+                Preconditions.checkState(this.hash === info.hash, 'Argument object hash property does not match block hash.');
+            }
+        }
+    }
+    static _from(arg) {
+        let info = {};
+        if (Buffer.isBuffer(arg)) {
+            info = BlockHeader._fromBufferReader(new BufferReader(arg));
+        }
+        else if (typeof arg === 'string' && JSUtil.isHexa(arg)) {
+            const buf = Buffer.from(arg, 'hex');
+            info = BlockHeader._fromBufferReader(new BufferReader(buf));
+        }
+        else if (typeof arg === 'object' && arg !== null) {
+            info = BlockHeader._fromObject(arg);
+        }
+        else {
+            throw new TypeError('Unrecognized argument for BlockHeader');
+        }
+        return info;
+    }
+    static _fromObject(data) {
+        Preconditions.checkArgument(typeof data === 'object' && data !== null, 'data is required');
+        let prevHash = data.prevHash;
+        let merkleRoot = data.merkleRoot;
+        let epochBlock = data.epochBlock;
+        let extendedMetadata = data.extendedMetadata;
+        let nonce = data.nonce;
+        let size = data.size;
+        if (typeof data.prevHash === 'string') {
+            prevHash = BufferUtil.reverse(Buffer.from(data.prevHash, 'hex'));
+        }
+        else if (!Buffer.isBuffer(data.prevHash)) {
+            prevHash = Buffer.alloc(32);
+        }
+        if (typeof data.merkleRoot === 'string') {
+            merkleRoot = BufferUtil.reverse(Buffer.from(data.merkleRoot, 'hex'));
+        }
+        else if (!Buffer.isBuffer(data.merkleRoot)) {
+            merkleRoot = Buffer.alloc(32);
+        }
+        if (typeof data.epochBlock === 'string') {
+            epochBlock = BufferUtil.reverse(Buffer.from(data.epochBlock, 'hex'));
+        }
+        else if (!Buffer.isBuffer(data.epochBlock)) {
+            epochBlock = Buffer.alloc(32);
+        }
+        if (typeof data.extendedMetadata === 'string') {
+            extendedMetadata = BufferUtil.reverse(Buffer.from(data.extendedMetadata, 'hex'));
+        }
+        else if (!Buffer.isBuffer(data.extendedMetadata)) {
+            extendedMetadata = Buffer.alloc(32);
+        }
+        if (typeof data.nonce === 'string') {
+            nonce = new BN(data.nonce, 10);
+        }
+        else if (typeof data.nonce === 'number') {
+            nonce = new BN(data.nonce);
+        }
+        else if (data.nonce instanceof BN) {
+            nonce = data.nonce;
+        }
+        else {
+            nonce = new BN(0);
+        }
+        if (typeof data.size === 'string') {
+            size = new BN(data.size, 10);
+        }
+        else if (typeof data.size === 'number') {
+            size = new BN(data.size);
+        }
+        else if (data.size instanceof BN) {
+            size = data.size;
+        }
+        else {
+            size = new BN(0);
+        }
+        return {
+            hash: data.hash,
+            prevHash: prevHash,
+            bits: data.bits || 0,
+            timestamp: data.time || data.timestamp || 0,
+            reserved: data.reserved || 0,
+            nonce: nonce,
+            version: data.version || 0,
+            size: size,
+            height: data.height || 0,
+            epochBlock: epochBlock,
+            merkleRoot: merkleRoot,
+            extendedMetadata: extendedMetadata,
+            time: data.time || data.timestamp || 0,
+        };
+    }
+    static fromObject(obj) {
+        const info = BlockHeader._fromObject(obj);
+        return new BlockHeader(info);
+    }
+    static fromRawBlock(data) {
+        if (!Buffer.isBuffer(data)) {
+            data = Buffer.from(data, 'binary');
+        }
+        const br = new BufferReader(data);
+        br.pos = BlockHeader.Constants.START_OF_HEADER;
+        const info = BlockHeader._fromBufferReader(br);
+        return new BlockHeader(info);
+    }
+    static fromBuffer(buf) {
+        const info = BlockHeader._fromBufferReader(new BufferReader(buf));
+        return new BlockHeader(info);
+    }
+    static fromString(str) {
+        const buf = Buffer.from(str, 'hex');
+        return BlockHeader.fromBuffer(buf);
+    }
+    static _fromBufferReader(br) {
+        return {
+            prevHash: br.read(32),
+            bits: br.readUInt32LE(),
+            time: br.readUInt48LE(),
+            reserved: br.readUInt16LE(),
+            nonce: br.readUInt64LEBN(),
+            version: br.readUInt8(),
+            size: br.readUInt56LEBN(),
+            height: br.readUInt32LE(),
+            epochBlock: br.read(32),
+            merkleRoot: br.read(32),
+            extendedMetadata: br.read(32),
+        };
+    }
+    static fromBufferReader(br) {
+        const info = BlockHeader._fromBufferReader(br);
+        return new BlockHeader(info);
+    }
+    toObject() {
+        return {
+            hash: this.hash,
+            prevHash: BufferUtil.reverse(this.prevHash).toString('hex'),
+            bits: this.bits,
+            time: this.time,
+            reserved: this.reserved,
+            nonce: this.nonce.toString(10),
+            version: this.version,
+            size: this.size.toNumber(),
+            height: this.height,
+            epochBlock: BufferUtil.reverse(this.epochBlock).toString('hex'),
+            merkleRoot: BufferUtil.reverse(this.merkleRoot).toString('hex'),
+            extendedMetadata: BufferUtil.reverse(this.extendedMetadata).toString('hex'),
+        };
+    }
+    toJSON = this.toObject;
+    toBuffer() {
+        return this.toBufferWriter().toBuffer();
+    }
+    toString() {
+        return this.toBuffer().toString('hex');
+    }
+    toBufferWriter(bw) {
+        if (!bw) {
+            bw = new BufferWriter();
+        }
+        bw.write(this.prevHash);
+        bw.writeUInt32LE(this.bits);
+        bw.writeUInt48LE(this.time);
+        bw.writeUInt16LE(this.reserved);
+        bw.writeUInt64LEBN(this.nonce);
+        bw.writeUInt8(this.version);
+        bw.writeUInt56LEBN(this.size);
+        bw.writeUInt32LE(this.height);
+        bw.write(this.epochBlock);
+        bw.write(this.merkleRoot);
+        bw.write(this.extendedMetadata);
+        return bw;
+    }
+    getTargetDifficulty(bits) {
+        bits = bits || this.bits;
+        let target = new BN(bits & 0xffffff);
+        let mov = 8 * ((bits >>> 24) - 3);
+        while (mov-- > 0) {
+            target = target.mul(new BN(2));
+        }
+        return target;
+    }
+    getDifficulty() {
+        const difficulty1TargetBN = this.getTargetDifficulty(GENESIS_BITS).mul(new BN(Math.pow(10, 8)));
+        const currentTargetBN = this.getTargetDifficulty();
+        const difficultyString = difficulty1TargetBN
+            .div(currentTargetBN)
+            .toString(10);
+        const decimalPos = difficultyString.length - 8;
+        const formattedDifficulty = difficultyString.slice(0, decimalPos) +
+            '.' +
+            difficultyString.slice(decimalPos);
+        return parseFloat(formattedDifficulty);
+    }
+    _getHash() {
+        const layer3Hash = this._getLayer3Hash();
+        const layer2Hash = this._getLayer2Hash(layer3Hash);
+        const bw = new BufferWriter();
+        bw.write(this.prevHash);
+        bw.write(layer2Hash);
+        return Hash.sha256(bw.toBuffer());
+    }
+    _timeToBytes() {
+        const buf = Buffer.alloc(6);
+        buf.writeUIntLE(this.time, 0, 6);
+        return buf;
+    }
+    _sizeToBytes() {
+        const buf = Buffer.alloc(7);
+        const sizeBuffer = this.size.toArrayLike(Buffer, 'le', 7);
+        sizeBuffer.copy(buf);
+        return buf;
+    }
+    _getLayer3Hash() {
+        const bw = new BufferWriter();
+        bw.writeUInt8(this.version);
+        bw.writeUInt56LEBN(this.size);
+        bw.writeUInt32LE(this.height);
+        bw.write(this.epochBlock);
+        bw.write(this.merkleRoot);
+        bw.write(this.extendedMetadata);
+        return Hash.sha256(bw.toBuffer());
+    }
+    _getLayer2Hash(layer3Hash) {
+        const bw = new BufferWriter();
+        bw.writeUInt32LE(this.bits);
+        bw.writeUInt48LE(this.time);
+        bw.writeUInt16LE(this.reserved);
+        bw.writeUInt64LEBN(this.nonce);
+        bw.write(layer3Hash);
+        return Hash.sha256(bw.toBuffer());
+    }
+    get hash() {
+        if (!this._id) {
+            const hashBuffer = this._getHash();
+            const reader = new BufferReader(hashBuffer);
+            this._id = reader.readReverse(32).toString('hex');
+        }
+        return this._id;
+    }
+    get id() {
+        return this.hash;
+    }
+    validTimestamp() {
+        const currentTime = Math.round(new Date().getTime() / 1000);
+        if (this.time > currentTime + BlockHeader.Constants.MAX_TIME_OFFSET) {
+            return false;
+        }
+        return true;
+    }
+    validProofOfWork() {
+        const pow = new BN(this.id, 'hex');
+        const target = this.getTargetDifficulty();
+        if (pow.gt(target)) {
+            return false;
+        }
+        return true;
+    }
+    inspect() {
+        return '<BlockHeader ' + this.id + '>';
+    }
+}

package/dist/lib/bitcore/block/index.d.ts

@@ -0,0 +1,5 @@
+export { Block } from './block.js';
+export { BlockHeader } from './blockheader.js';
+export type { BlockData, BlockObject } from './block.js';
+export type { BlockHeaderData, BlockHeaderObject } from './blockheader.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/bitcore/block/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/block/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACxD,YAAY,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/lib/bitcore/block/index.js

@@ -0,0 +1,2 @@
+export { Block } from './block.js';
+export { BlockHeader } from './blockheader.js';

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

@@ -0,0 +1,22 @@
+export declare class Chunk {
+    buf?: Buffer;
+    len?: number;
+    opcodenum: number;
+    constructor(data?: {
+        buf?: Buffer;
+        len?: number;
+        opcodenum: number;
+    });
+    isOpCode(): boolean;
+    hasData(): boolean;
+    getLength(): number;
+    getBuffer(): Buffer | undefined;
+    getOpCode(): number;
+    toString(): string;
+    toObject(): {
+        buf?: Buffer;
+        len?: number;
+        opcodenum: number;
+    };
+}
+//# sourceMappingURL=chunk.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../../../lib/bitcore/chunk.ts"],"names":[],"mappings":"AAMA,qBAAa,KAAK;IAChB,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;gBAEL,IAAI,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;IAapE,QAAQ,IAAI,OAAO;IAOnB,OAAO,IAAI,OAAO;IAOlB,SAAS,IAAI,MAAM;IAOnB,SAAS,IAAI,MAAM,GAAG,SAAS;IAO/B,SAAS,IAAI,MAAM;IAOnB,QAAQ,IAAI,MAAM;IAYlB,QAAQ,IAAI;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE;CAO9D"}

package/dist/lib/bitcore/chunk.js

@@ -0,0 +1,46 @@
+export class Chunk {
+    buf;
+    len;
+    opcodenum;
+    constructor(data) {
+        if (data) {
+            this.buf = data.buf;
+            this.len = data.len;
+            this.opcodenum = data.opcodenum;
+        }
+        else {
+            this.opcodenum = 0;
+        }
+    }
+    isOpCode() {
+        return !this.buf && this.opcodenum !== undefined;
+    }
+    hasData() {
+        return !!this.buf;
+    }
+    getLength() {
+        return this.len || 0;
+    }
+    getBuffer() {
+        return this.buf;
+    }
+    getOpCode() {
+        return this.opcodenum;
+    }
+    toString() {
+        if (this.isOpCode()) {
+            return `OP_${this.opcodenum}`;
+        }
+        else if (this.buf) {
+            return this.buf.toString('hex');
+        }
+        return '';
+    }
+    toObject() {
+        return {
+            buf: this.buf,
+            len: this.len,
+            opcodenum: this.opcodenum,
+        };
+    }
+}

package/dist/lib/bitcore/crypto/bn.d.ts

@@ -0,0 +1,53 @@
+import BN from 'bn.js';
+export interface BNWrapperOptions {
+    endian?: 'little' | 'big';
+    size?: number;
+}
+declare class BNWrapper {
+    private _bn;
+    static readonly Zero: BNWrapper;
+    static readonly One: BNWrapper;
+    static readonly Minus1: BNWrapper;
+    constructor(n: number | string | BN | Buffer, base?: number | 'hex' | 'le' | 'be');
+    static fromString(str: string, base?: number): BNWrapper;
+    static fromBuffer(buf: Buffer, opts?: BNWrapperOptions): BNWrapper;
+    static fromSM(buf: Buffer, opts?: BNWrapperOptions): BNWrapper;
+    static fromScriptNumBuffer(buf: Buffer, fRequireMinimal?: boolean, size?: number): BNWrapper;
+    static reversebuf(buf: Buffer): Buffer;
+    static trim(buf: Buffer, natlen: number): Buffer;
+    static pad(buf: Buffer, natlen: number, size: number): Buffer;
+    static fromNumber(n: number): BNWrapper;
+    toNumber(): number;
+    add(r: BNWrapper): BNWrapper;
+    mod(r: BNWrapper): BNWrapper;
+    umod(r: BNWrapper): BNWrapper;
+    get bn(): BN;
+    toString(base?: number): string;
+    toBuffer(opts?: BNWrapperOptions): Buffer;
+    toArrayLike(ArrayType: typeof Buffer, endian?: 'le' | 'be', length?: number): Buffer;
+    mul(r: BNWrapper): BNWrapper;
+    sub(r: BNWrapper): BNWrapper;
+    pow(r: BNWrapper): BNWrapper;
+    div(r: BNWrapper): BNWrapper;
+    modPow(exponent: BNWrapper, modulus: BNWrapper): BNWrapper;
+    and(other: BNWrapper | number): BNWrapper;
+    neg(): BNWrapper;
+    invm(r: BNWrapper): BNWrapper;
+    eq(other: BNWrapper): boolean;
+    lt(other: BNWrapper): boolean;
+    gt(other: BNWrapper): boolean;
+    lte(other: BNWrapper): boolean;
+    gte(other: BNWrapper): boolean;
+    isZero(): boolean;
+    isNeg(): boolean;
+    isOdd(): boolean;
+    isEven(): boolean;
+    toSMBigEndian(): Buffer;
+    toSM(opts?: BNWrapperOptions): Buffer;
+    toScriptNumBuffer(): Buffer;
+    cmp(other: BNWrapper): number;
+    copy(other: BNWrapper): BNWrapper;
+    clone(): BNWrapper;
+}
+export { BNWrapper as BN };
+//# sourceMappingURL=bn.d.ts.map

package/dist/lib/bitcore/crypto/bn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bn.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/crypto/bn.ts"],"names":[],"mappings":"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"}