xpi-ts 0.2.0

package/dist/lib/bitcore/publickey.js

@@ -0,0 +1,263 @@
+import { BN } from './crypto/bn.js';
+import { Point } from './crypto/point.js';
+import { Hash } from './crypto/hash.js';
+import { JSUtil } from './util/js.js';
+import { get as getNetwork, defaultNetwork } from './networks.js';
+import { PrivateKey } from './privatekey.js';
+import { Address } from './address.js';
+export class PublicKey {
+    point;
+    compressed;
+    network;
+    constructor(data, extra) {
+        if (data instanceof PublicKey) {
+            return data;
+        }
+        if (!data) {
+            throw new Error('First argument is required, please include public key data.');
+        }
+        extra = extra || {};
+        const info = this._classifyArgs(data, extra);
+        info.point?.validate();
+        JSUtil.defineImmutable(this, {
+            point: info.point,
+            compressed: info.compressed,
+            network: info.network || defaultNetwork,
+        });
+    }
+    _classifyArgs(data, extra) {
+        const info = {
+            compressed: extra.compressed === undefined ? true : extra.compressed,
+        };
+        if (data instanceof Point) {
+            info.point = data;
+        }
+        else if (typeof data === 'object' &&
+            data !== null &&
+            'x' in data &&
+            'y' in data) {
+            const objectInfo = PublicKey._transformObject(data);
+            Object.assign(info, objectInfo);
+        }
+        else if (typeof data === 'string') {
+            const derInfo = PublicKey._transformDER(Buffer.from(data, 'hex'));
+            Object.assign(info, derInfo);
+        }
+        else if (PublicKey._isBuffer(data)) {
+            const derInfo = PublicKey._transformDER(data);
+            Object.assign(info, derInfo);
+        }
+        else if (PublicKey._isPrivateKey(data)) {
+            const privkeyInfo = PublicKey._transformPrivateKey(data);
+            Object.assign(info, privkeyInfo);
+        }
+        else {
+            throw new TypeError('First argument is an unrecognized data format.');
+        }
+        if (!info.network) {
+            info.network = extra.network ? getNetwork(extra.network) : undefined;
+        }
+        if (!info.point) {
+            throw new Error('Failed to derive a valid point from the input data');
+        }
+        return info;
+    }
+    static _isPrivateKey(param) {
+        return param instanceof PrivateKey;
+    }
+    static _isBuffer(param) {
+        return Buffer.isBuffer(param) || param instanceof Uint8Array;
+    }
+    static _transformPrivateKey(privkey) {
+        if (!PublicKey._isPrivateKey(privkey)) {
+            throw new Error('Must be an instance of PrivateKey');
+        }
+        return {
+            point: Point.getG().mul(privkey.bn),
+            compressed: privkey.compressed,
+            network: privkey.network,
+        };
+    }
+    static _transformDER(buf, strict = true) {
+        if (!PublicKey._isBuffer(buf)) {
+            throw new Error('Must be a hex buffer of DER encoded public key');
+        }
+        let point;
+        let compressed;
+        let x;
+        let y;
+        let xbuf;
+        let ybuf;
+        if (buf[0] === 0x04 || (!strict && (buf[0] === 0x06 || buf[0] === 0x07))) {
+            xbuf = buf.subarray(1, 33);
+            ybuf = buf.subarray(33, 65);
+            if (xbuf.length !== 32 || ybuf.length !== 32 || buf.length !== 65) {
+                throw new TypeError('Length of x and y must be 32 bytes');
+            }
+            x = new BN(xbuf, 'be');
+            y = new BN(ybuf, 'be');
+            point = new Point(x, y);
+            compressed = false;
+        }
+        else if (buf[0] === 0x03) {
+            xbuf = buf.subarray(1);
+            x = new BN(xbuf, 'be');
+            const xInfo = PublicKey._transformX(true, x);
+            point = xInfo.point;
+            compressed = true;
+        }
+        else if (buf[0] === 0x02) {
+            xbuf = buf.subarray(1);
+            x = new BN(xbuf, 'be');
+            const xInfo = PublicKey._transformX(false, x);
+            point = xInfo.point;
+            compressed = true;
+        }
+        else {
+            throw new TypeError('Invalid DER format public key');
+        }
+        return {
+            point,
+            compressed,
+        };
+    }
+    static _transformX(odd, x) {
+        if (typeof odd !== 'boolean') {
+            throw new Error('Must specify whether y is odd or not (true or false)');
+        }
+        return {
+            point: Point.fromX(odd, x),
+            compressed: true,
+        };
+    }
+    static _transformObject(json) {
+        const x = new BN(json.x, 16);
+        const y = new BN(json.y, 16);
+        const point = new Point(x, y);
+        return {
+            point: point,
+            compressed: json.compressed,
+        };
+    }
+    static fromPrivateKey(privkey) {
+        if (!PublicKey._isPrivateKey(privkey)) {
+            throw new Error('Must be an instance of PrivateKey');
+        }
+        const info = PublicKey._transformPrivateKey(privkey);
+        return new PublicKey(info.point, {
+            compressed: info.compressed,
+            network: info.network,
+        });
+    }
+    static fromDER(buf, strict) {
+        if (!PublicKey._isBuffer(buf)) {
+            throw new Error('Must be a hex buffer of DER encoded public key');
+        }
+        const info = PublicKey._transformDER(buf, strict);
+        return new PublicKey(info.point, {
+            compressed: info.compressed,
+        });
+    }
+    static fromBuffer(buf, strict) {
+        return PublicKey.fromDER(buf, strict);
+    }
+    static fromPoint(point, compressed) {
+        if (!(point instanceof Point)) {
+            throw new Error('First argument must be an instance of Point.');
+        }
+        return new PublicKey(point, {
+            compressed: compressed,
+        });
+    }
+    static fromString(str, encoding) {
+        const buf = Buffer.from(str, encoding || 'hex');
+        const info = PublicKey._transformDER(buf);
+        return new PublicKey(info.point, {
+            compressed: info.compressed,
+        });
+    }
+    static fromX(odd, x) {
+        const info = PublicKey._transformX(odd, x);
+        return new PublicKey(info.point, {
+            compressed: info.compressed,
+        });
+    }
+    static getValidationError(data) {
+        try {
+            new PublicKey(data);
+            return null;
+        }
+        catch (e) {
+            return e;
+        }
+    }
+    static isValid(data) {
+        if (data instanceof PublicKey) {
+            return true;
+        }
+        return !PublicKey.getValidationError(data);
+    }
+    toObject() {
+        return {
+            x: this.point.getX().toString(16).padStart(64, '0'),
+            y: this.point.getY().toString(16).padStart(64, '0'),
+            compressed: this.compressed,
+        };
+    }
+    toJSON() {
+        return this.toObject();
+    }
+    toBigNumber() {
+        return this.point.getX();
+    }
+    toBuffer() {
+        return this.toDER();
+    }
+    toDER() {
+        const x = this.point.getX();
+        const y = this.point.getY();
+        const xbuf = x.toArrayLike(Buffer, 'be', 32);
+        const ybuf = y.toArrayLike(Buffer, 'be', 32);
+        let prefix;
+        if (!this.compressed) {
+            prefix = Buffer.from([0x04]);
+            return Buffer.concat([prefix, xbuf, ybuf]);
+        }
+        else {
+            const odd = y.mod(new BN(2)).eq(new BN(1));
+            if (odd) {
+                prefix = Buffer.from([0x03]);
+            }
+            else {
+                prefix = Buffer.from([0x02]);
+            }
+            return Buffer.concat([prefix, xbuf]);
+        }
+    }
+    _getID() {
+        return Hash.sha256ripemd160(this.toBuffer());
+    }
+    toAddress(network) {
+        return Address.fromPublicKey(this, network);
+    }
+    toString() {
+        return this.toDER().toString('hex');
+    }
+    inspect() {
+        return `<PublicKey: ${this.toString()}${this.compressed ? '' : ', uncompressed'}>`;
+    }
+    addScalar(scalar) {
+        const scalarBN = Buffer.isBuffer(scalar) ? new BN(scalar) : scalar;
+        const G = Point.getG();
+        const tweakPoint = G.mul(scalarBN);
+        const tweakedPoint = this.point.add(tweakPoint);
+        tweakedPoint.validate();
+        return new PublicKey(tweakedPoint, {
+            compressed: this.compressed,
+            network: this.network,
+        });
+    }
+    static getN() {
+        return Point.getN();
+    }
+}

package/dist/lib/bitcore/script/interpreter.d.ts

@@ -0,0 +1,98 @@
+import { Script } from '../script.js';
+import { BN } from '../crypto/bn.js';
+import type { Transaction } from '../transaction/transaction.js';
+export interface InterpreterData {
+    script?: Script;
+    tx?: Transaction;
+    nin?: number;
+    flags?: number;
+    satoshisBN?: bigint;
+    outputScript?: Script;
+}
+export interface InterpreterObject {
+    script?: Script;
+    tx?: Transaction;
+    nin?: number;
+    flags?: number;
+    satoshisBN?: bigint;
+    outputScript?: Script;
+    stack?: Buffer[];
+}
+export declare class Interpreter {
+    static SCRIPT_VERIFY_NONE: number;
+    static SCRIPT_VERIFY_P2SH: number;
+    static SCRIPT_VERIFY_STRICTENC: number;
+    static SCRIPT_VERIFY_DERSIG: number;
+    static SCRIPT_VERIFY_LOW_S: number;
+    static SCRIPT_VERIFY_NULLDUMMY: number;
+    static SCRIPT_VERIFY_SIGPUSHONLY: number;
+    static SCRIPT_VERIFY_MINIMALDATA: number;
+    static SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS: number;
+    static SCRIPT_VERIFY_CLEANSTACK: number;
+    static SCRIPT_VERIFY_CHECKLOCKTIMEVERIFY: number;
+    static SCRIPT_VERIFY_CHECKSEQUENCEVERIFY: number;
+    static SCRIPT_VERIFY_MINIMALIF: number;
+    static SCRIPT_VERIFY_NULLFAIL: number;
+    static SCRIPT_VERIFY_COMPRESSED_PUBKEYTYPE: number;
+    static SCRIPT_ENABLE_SIGHASH_FORKID: number;
+    static SCRIPT_ENABLE_REPLAY_PROTECTION: number;
+    static SCRIPT_ENABLE_CHECKDATASIG: number;
+    static SCRIPT_DISALLOW_SEGWIT_RECOVERY: number;
+    static SCRIPT_ENABLE_SCHNORR_MULTISIG: number;
+    static SCRIPT_VERIFY_INPUT_SIGCHECKS: number;
+    static SCRIPT_TAPROOT_KEY_SPEND_PATH: number;
+    static SCRIPT_DISABLE_TAPROOT_SIGHASH_LOTUS: number;
+    static MAX_SCRIPT_ELEMENT_SIZE: number;
+    static MAX_SCRIPT_SIZE: number;
+    static MAX_STACK_SIZE: number;
+    static MAX_OPCODE_COUNT: number;
+    static false: Buffer<ArrayBuffer>;
+    static true: Buffer<ArrayBuffer>;
+    static MAXIMUM_ELEMENT_SIZE: number;
+    static LOCKTIME_THRESHOLD: number;
+    static LOCKTIME_THRESHOLD_BN: BN;
+    static SEQUENCE_LOCKTIME_DISABLE_FLAG: number;
+    static SEQUENCE_LOCKTIME_TYPE_FLAG: number;
+    static SEQUENCE_LOCKTIME_MASK: number;
+    script: Script;
+    tx?: Transaction;
+    nin?: number;
+    flags: number;
+    satoshisBN?: bigint;
+    outputScript?: Script;
+    stack: Buffer[];
+    altstack: Buffer[];
+    pc: number;
+    pbegincodehash: number;
+    nOpCount: number;
+    vfExec: boolean[];
+    errstr: string;
+    constructor(obj?: InterpreterObject);
+    static create(obj?: InterpreterObject): Interpreter;
+    initialize(): void;
+    set(obj: InterpreterObject): Interpreter;
+    verify(scriptSig: Script, scriptPubkey: Script, tx: Transaction, nin: number, flags: number, satoshisBN: bigint): boolean;
+    checkRawSignatureEncoding(buf: Buffer): boolean;
+    checkSignatureEncoding(buf: Buffer): boolean;
+    checkTxSignatureEncoding(buf: Buffer): boolean;
+    checkDataSignatureEncoding(buf: Buffer): boolean;
+    checkPubkeyEncoding(buf: Buffer): boolean;
+    private isCompressedOrUncompressedPubkey;
+    evaluate(): boolean;
+    private toScriptNumBuffer;
+    private fromScriptNumBuffer;
+    private castToBool;
+    step(): boolean;
+    private decodeBitfield;
+    private countBits;
+    private stacktop;
+    private isOpcodeDisabled;
+    checkLockTime(nLockTime: BN): boolean;
+    checkSequence(nSequence: BN): boolean;
+    static castToBool(buf: Buffer): boolean;
+    static isSchnorrSig(buf: Buffer): boolean;
+    private _verifyScriptType;
+    static _isMinimallyEncoded(buf: Buffer, nMaxNumSize?: number): boolean;
+    static _minimallyEncode(buf: Buffer): Buffer;
+}
+//# sourceMappingURL=interpreter.d.ts.map

package/dist/lib/bitcore/script/interpreter.d.ts.map

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