xpi-ts 0.2.0

package/dist/lib/bitcore/opcode.js

@@ -0,0 +1,270 @@
+import { Preconditions } from './util/preconditions.js';
+import { JSUtil } from './util/js.js';
+export class Opcode {
+    num;
+    constructor(num) {
+        if (typeof num === 'number') {
+            JSUtil.defineImmutable(this, { num });
+        }
+        else if (typeof num === 'string') {
+            const value = Opcode.map[num];
+            if (value === undefined) {
+                throw new Error(`Unknown opcode: ${num}`);
+            }
+            JSUtil.defineImmutable(this, { num: value });
+        }
+        else {
+            throw new TypeError(`Unrecognized num type: "${typeof num}" for Opcode`);
+        }
+    }
+    static fromBuffer(buf) {
+        Preconditions.checkArgument(Buffer.isBuffer(buf), 'buf', 'Must be a Buffer');
+        Preconditions.checkArgument(buf.length > 0, 'buf', 'Buffer cannot be empty');
+        return new Opcode(buf[0]);
+    }
+    toBuffer() {
+        return Buffer.from([this.num]);
+    }
+    toString() {
+        return this.num.toString();
+    }
+    static OP_0 = 0;
+    static OP_FALSE = 0;
+    static OP_PUSHDATA1 = 76;
+    static OP_PUSHDATA2 = 77;
+    static OP_PUSHDATA4 = 78;
+    static OP_1NEGATE = 79;
+    static OP_RESERVED = 80;
+    static OP_1 = 81;
+    static OP_TRUE = 81;
+    static OP_2 = 82;
+    static OP_3 = 83;
+    static OP_4 = 84;
+    static OP_5 = 85;
+    static OP_6 = 86;
+    static OP_7 = 87;
+    static OP_8 = 88;
+    static OP_9 = 89;
+    static OP_10 = 90;
+    static OP_11 = 91;
+    static OP_12 = 92;
+    static OP_13 = 93;
+    static OP_14 = 94;
+    static OP_15 = 95;
+    static OP_16 = 96;
+    static OP_NOP = 97;
+    static OP_SCRIPTTYPE = 98;
+    static OP_VER = 98;
+    static OP_IF = 99;
+    static OP_NOTIF = 100;
+    static OP_VERIF = 101;
+    static OP_VERNOTIF = 102;
+    static OP_ELSE = 103;
+    static OP_ENDIF = 104;
+    static OP_VERIFY = 105;
+    static OP_RETURN = 106;
+    static OP_TOALTSTACK = 107;
+    static OP_FROMALTSTACK = 108;
+    static OP_2DROP = 109;
+    static OP_2DUP = 110;
+    static OP_3DUP = 111;
+    static OP_2OVER = 112;
+    static OP_2ROT = 113;
+    static OP_2SWAP = 114;
+    static OP_IFDUP = 115;
+    static OP_DEPTH = 116;
+    static OP_DROP = 117;
+    static OP_DUP = 118;
+    static OP_NIP = 119;
+    static OP_OVER = 120;
+    static OP_PICK = 121;
+    static OP_ROLL = 122;
+    static OP_ROT = 123;
+    static OP_SWAP = 124;
+    static OP_TUCK = 125;
+    static OP_CAT = 126;
+    static OP_SPLIT = 127;
+    static OP_NUM2BIN = 128;
+    static OP_BIN2NUM = 129;
+    static OP_SIZE = 130;
+    static OP_INVERT = 131;
+    static OP_AND = 132;
+    static OP_OR = 133;
+    static OP_XOR = 134;
+    static OP_EQUAL = 135;
+    static OP_EQUALVERIFY = 136;
+    static OP_RESERVED1 = 137;
+    static OP_RESERVED2 = 138;
+    static OP_1ADD = 139;
+    static OP_1SUB = 140;
+    static OP_2MUL = 141;
+    static OP_2DIV = 142;
+    static OP_NEGATE = 143;
+    static OP_ABS = 144;
+    static OP_NOT = 145;
+    static OP_0NOTEQUAL = 146;
+    static OP_ADD = 147;
+    static OP_SUB = 148;
+    static OP_MUL = 149;
+    static OP_DIV = 150;
+    static OP_MOD = 151;
+    static OP_LSHIFT = 152;
+    static OP_RSHIFT = 153;
+    static OP_BOOLAND = 154;
+    static OP_BOOLOR = 155;
+    static OP_NUMEQUAL = 156;
+    static OP_NUMEQUALVERIFY = 157;
+    static OP_NUMNOTEQUAL = 158;
+    static OP_LESSTHAN = 159;
+    static OP_GREATERTHAN = 160;
+    static OP_LESSTHANOREQUAL = 161;
+    static OP_GREATERTHANOREQUAL = 162;
+    static OP_MIN = 163;
+    static OP_MAX = 164;
+    static OP_WITHIN = 165;
+    static OP_RIPEMD160 = 166;
+    static OP_SHA1 = 167;
+    static OP_SHA256 = 168;
+    static OP_HASH160 = 169;
+    static OP_HASH256 = 170;
+    static OP_CODESEPARATOR = 171;
+    static OP_CHECKSIG = 172;
+    static OP_CHECKSIGVERIFY = 173;
+    static OP_CHECKMULTISIG = 174;
+    static OP_CHECKMULTISIGVERIFY = 175;
+    static OP_NOP1 = 176;
+    static OP_CHECKLOCKTIMEVERIFY = 177;
+    static OP_NOP2 = 177;
+    static OP_CHECKSEQUENCEVERIFY = 178;
+    static OP_NOP3 = 178;
+    static OP_NOP4 = 179;
+    static OP_NOP5 = 180;
+    static OP_NOP6 = 181;
+    static OP_NOP7 = 182;
+    static OP_NOP8 = 183;
+    static OP_NOP9 = 184;
+    static OP_NOP10 = 185;
+    static OP_CHECKDATASIG = 186;
+    static OP_CHECKDATASIGVERIFY = 187;
+    static OP_REVERSEBYTES = 188;
+    static map = {
+        OP_0: 0,
+        OP_FALSE: 0,
+        OP_PUSHDATA1: 76,
+        OP_PUSHDATA2: 77,
+        OP_PUSHDATA4: 78,
+        OP_1NEGATE: 79,
+        OP_RESERVED: 80,
+        OP_1: 81,
+        OP_TRUE: 81,
+        OP_2: 82,
+        OP_3: 83,
+        OP_4: 84,
+        OP_5: 85,
+        OP_6: 86,
+        OP_7: 87,
+        OP_8: 88,
+        OP_9: 89,
+        OP_10: 90,
+        OP_11: 91,
+        OP_12: 92,
+        OP_13: 93,
+        OP_14: 94,
+        OP_15: 95,
+        OP_16: 96,
+        OP_NOP: 97,
+        OP_SCRIPTTYPE: 98,
+        OP_IF: 99,
+        OP_NOTIF: 100,
+        OP_VERIF: 101,
+        OP_VERNOTIF: 102,
+        OP_ELSE: 103,
+        OP_ENDIF: 104,
+        OP_VERIFY: 105,
+        OP_RETURN: 106,
+        OP_TOALTSTACK: 107,
+        OP_FROMALTSTACK: 108,
+        OP_2DROP: 109,
+        OP_2DUP: 110,
+        OP_3DUP: 111,
+        OP_2OVER: 112,
+        OP_2ROT: 113,
+        OP_2SWAP: 114,
+        OP_IFDUP: 115,
+        OP_DEPTH: 116,
+        OP_DROP: 117,
+        OP_DUP: 118,
+        OP_NIP: 119,
+        OP_OVER: 120,
+        OP_PICK: 121,
+        OP_ROLL: 122,
+        OP_ROT: 123,
+        OP_SWAP: 124,
+        OP_TUCK: 125,
+        OP_CAT: 126,
+        OP_SPLIT: 127,
+        OP_NUM2BIN: 128,
+        OP_BIN2NUM: 129,
+        OP_SIZE: 130,
+        OP_INVERT: 131,
+        OP_AND: 132,
+        OP_OR: 133,
+        OP_XOR: 134,
+        OP_EQUAL: 135,
+        OP_EQUALVERIFY: 136,
+        OP_RESERVED1: 137,
+        OP_RESERVED2: 138,
+        OP_1ADD: 139,
+        OP_1SUB: 140,
+        OP_2MUL: 141,
+        OP_2DIV: 142,
+        OP_NEGATE: 143,
+        OP_ABS: 144,
+        OP_NOT: 145,
+        OP_0NOTEQUAL: 146,
+        OP_ADD: 147,
+        OP_SUB: 148,
+        OP_MUL: 149,
+        OP_DIV: 150,
+        OP_MOD: 151,
+        OP_LSHIFT: 152,
+        OP_RSHIFT: 153,
+        OP_BOOLAND: 154,
+        OP_BOOLOR: 155,
+        OP_NUMEQUAL: 156,
+        OP_NUMEQUALVERIFY: 157,
+        OP_NUMNOTEQUAL: 158,
+        OP_LESSTHAN: 159,
+        OP_GREATERTHAN: 160,
+        OP_LESSTHANOREQUAL: 161,
+        OP_GREATERTHANOREQUAL: 162,
+        OP_MIN: 163,
+        OP_MAX: 164,
+        OP_WITHIN: 165,
+        OP_RIPEMD160: 166,
+        OP_SHA1: 167,
+        OP_SHA256: 168,
+        OP_HASH160: 169,
+        OP_HASH256: 170,
+        OP_CODESEPARATOR: 171,
+        OP_CHECKSIG: 172,
+        OP_CHECKSIGVERIFY: 173,
+        OP_CHECKMULTISIG: 174,
+        OP_CHECKMULTISIGVERIFY: 175,
+        OP_NOP1: 176,
+        OP_CHECKLOCKTIMEVERIFY: 177,
+        OP_NOP2: 177,
+        OP_CHECKSEQUENCEVERIFY: 178,
+        OP_NOP3: 178,
+        OP_NOP4: 179,
+        OP_NOP5: 180,
+        OP_NOP6: 181,
+        OP_NOP7: 182,
+        OP_NOP8: 183,
+        OP_NOP9: 184,
+        OP_NOP10: 185,
+        OP_CHECKDATASIG: 186,
+        OP_CHECKDATASIGVERIFY: 187,
+        OP_REVERSEBYTES: 188,
+    };
+}

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

@@ -0,0 +1,56 @@
+import { BN } from './crypto/bn.js';
+import { Network } from './networks.js';
+import { PublicKey } from './publickey.js';
+import { Address } from './address.js';
+export interface PrivateKeyData {
+    bn?: BN;
+    compressed?: boolean;
+    network?: Network;
+}
+export interface PrivateKeyObject {
+    bn: string;
+    network: string;
+    compressed: boolean;
+}
+export interface PrivateKeySerialized {
+    bn: string;
+    compressed: boolean;
+    network: string;
+}
+export interface HDPrivateKeyDerivedData {
+    buf: Buffer;
+    compressed: boolean;
+}
+export type PrivateKeyInput = string | Buffer | PrivateKeyData | BN | PrivateKeyObject | HDPrivateKeyDerivedData;
+export declare class PrivateKey {
+    readonly bn: BN;
+    readonly compressed: boolean;
+    readonly network: Network;
+    private _pubkey?;
+    constructor(data?: PrivateKeyInput, network?: Network | string);
+    get publicKey(): PublicKey;
+    private _classifyArguments;
+    private static _getRandomBN;
+    private static _transformBuffer;
+    private static _transformBNBuffer;
+    private static _transformWIF;
+    private static _transformObject;
+    static fromBuffer(arg: Buffer, network?: Network | string): PrivateKey;
+    static fromString(str: string, network?: Network | string): PrivateKey;
+    static fromWIF(str: string, network?: Network | string): PrivateKey;
+    static fromObject(obj: PrivateKeyObject, network?: Network | string): PrivateKey;
+    static fromRandom(network?: Network | string): PrivateKey;
+    static getValidationError(data: PrivateKeyInput, network?: Network | string): Error | null;
+    static isValid(data: PrivateKeyInput, network?: Network | string): boolean;
+    toString(): string;
+    toWIF(compressed?: boolean): string;
+    toBigNumber(): BN;
+    toBuffer(): Buffer;
+    toBufferNoPadding(): Buffer;
+    toPublicKey(): PublicKey;
+    toAddress(network?: Network | string): Address;
+    toObject(): PrivateKeySerialized;
+    toJSON(): PrivateKeySerialized;
+    inspect(): string;
+}
+//# sourceMappingURL=privatekey.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"privatekey.d.ts","sourceRoot":"","sources":["../../../lib/bitcore/privatekey.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAA;AAKnC,OAAO,EACL,OAAO,EAIR,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAEtC,MAAM,WAAW,cAAc;IAC7B,EAAE,CAAC,EAAE,EAAE,CAAA;IACP,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,OAAO,CAAA;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,uBAAuB;IACtC,GAAG,EAAE,MAAM,CAAA;IACX,UAAU,EAAE,OAAO,CAAA;CACpB;AAED,MAAM,MAAM,eAAe,GACvB,MAAM,GACN,MAAM,GACN,cAAc,GACd,EAAE,GACF,gBAAgB,GAChB,uBAAuB,CAAA;AAE3B,qBAAa,UAAU;IACrB,QAAQ,CAAC,EAAE,EAAG,EAAE,CAAA;IAChB,QAAQ,CAAC,UAAU,EAAG,OAAO,CAAA;IAC7B,QAAQ,CAAC,OAAO,EAAG,OAAO,CAAA;IAC1B,OAAO,CAAC,OAAO,CAAC,CAAW;gBAEf,IAAI,CAAC,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM;IA2B9D,IAAI,SAAS,IAAI,SAAS,CAEzB;IAMD,OAAO,CAAC,kBAAkB;IAoD1B,OAAO,CAAC,MAAM,CAAC,YAAY;IAY3B,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAoD/B,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAejC,OAAO,CAAC,MAAM,CAAC,aAAa;IAU5B,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAa/B,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,UAAU;IAOtE,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,UAAU;IAYtE,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,UAAU;IAOnE,MAAM,CAAC,UAAU,CACf,GAAG,EAAE,gBAAgB,EACrB,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GACzB,UAAU;IAUb,MAAM,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,UAAU;IAQzD,MAAM,CAAC,kBAAkB,CACvB,IAAI,EAAE,eAAe,EACrB,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GACzB,KAAK,GAAG,IAAI;IAYf,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO;IAU1E,QAAQ,IAAI,MAAM;IASlB,KAAK,CAAC,UAAU,GAAE,OAAc,GAAG,MAAM;IAqBzC,WAAW,IAAI,EAAE;IAOjB,QAAQ,IAAI,MAAM;IAOlB,iBAAiB,IAAI,MAAM;IAO3B,WAAW,IAAI,SAAS;IAYxB,SAAS,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO;IAQ9C,QAAQ,IAAI,oBAAoB;IAWhC,MAAM,IAAI,oBAAoB;IAO9B,OAAO,IAAI,MAAM;CAIlB"}

package/dist/lib/bitcore/privatekey.js

@@ -0,0 +1,237 @@
+import { BN } from './crypto/bn.js';
+import { Point } from './crypto/point.js';
+import { Random } from './crypto/random.js';
+import { Base58Check } from './encoding/base58check.js';
+import { JSUtil } from './util/js.js';
+import { get as getNetwork, defaultNetwork, } from './networks.js';
+import { PublicKey } from './publickey.js';
+import { Address } from './address.js';
+export class PrivateKey {
+    bn;
+    compressed;
+    network;
+    _pubkey;
+    constructor(data, network) {
+        if (data instanceof PrivateKey) {
+            return data;
+        }
+        const info = this._classifyArguments(data, network);
+        if (!info.bn || info.bn.isZero()) {
+            throw new TypeError('Number can not be equal to zero, undefined, null or false');
+        }
+        if (!info.bn.lt(Point.getN())) {
+            throw new TypeError('Number must be less than N');
+        }
+        if (!info.network) {
+            throw new TypeError('Must specify the network ("livenet" or "testnet")');
+        }
+        JSUtil.defineImmutable(this, {
+            bn: info.bn,
+            compressed: info.compressed,
+            network: info.network,
+        });
+    }
+    get publicKey() {
+        return this.toPublicKey();
+    }
+    _classifyArguments(data, network) {
+        const info = {
+            compressed: true,
+            network: network ? getNetwork(network) || defaultNetwork : defaultNetwork,
+        };
+        if (data === undefined || data === null) {
+            info.bn = PrivateKey._getRandomBN();
+        }
+        else if (data instanceof BN) {
+            info.bn = data;
+        }
+        else if (Buffer.isBuffer(data)) {
+            const bufferInfo = PrivateKey._transformBuffer(data, network);
+            Object.assign(info, bufferInfo);
+        }
+        else if (typeof data === 'object' &&
+            data !== null &&
+            'compressed' in data &&
+            'buf' in data) {
+            info.compressed = data.compressed;
+            info.bn = new BN(data.buf, 'be');
+        }
+        else if (typeof data === 'object' &&
+            data !== null &&
+            'bn' in data &&
+            'network' in data) {
+            const objectInfo = PrivateKey._transformObject(data);
+            Object.assign(info, objectInfo);
+        }
+        else if (!network && typeof data === 'string' && getNetwork(data)) {
+            info.bn = PrivateKey._getRandomBN();
+            info.network = getNetwork(data);
+        }
+        else if (typeof data === 'string') {
+            if (JSUtil.isHexa(data)) {
+                info.bn = new BN(data, 16);
+            }
+            else {
+                const wifInfo = PrivateKey._transformWIF(data, network);
+                Object.assign(info, wifInfo);
+            }
+        }
+        else {
+            throw new TypeError('First argument is an unrecognized data type.');
+        }
+        return info;
+    }
+    static _getRandomBN() {
+        let bn;
+        do {
+            const privbuf = Random.getPseudoRandomBuffer(32);
+            bn = new BN(privbuf, 'be');
+        } while (!bn.lt(Point.getN()));
+        return bn;
+    }
+    static _transformBuffer(buf, network) {
+        const info = {};
+        if (buf.length === 32) {
+            return PrivateKey._transformBNBuffer(buf, network);
+        }
+        const detectedNetwork = getNetwork(buf[0], 'privatekey');
+        if (!detectedNetwork) {
+            throw new Error('Invalid network');
+        }
+        info.network = detectedNetwork;
+        if (network) {
+            const specifiedNetwork = getNetwork(network);
+            if (specifiedNetwork && info.network !== specifiedNetwork) {
+                const isCompatible = (info.network.name === 'testnet' &&
+                    specifiedNetwork.name === 'regtest') ||
+                    (info.network.name === 'regtest' &&
+                        specifiedNetwork.name === 'testnet');
+                if (!isCompatible) {
+                    throw new TypeError('Private key network mismatch');
+                }
+                info.network = specifiedNetwork;
+            }
+        }
+        if (buf.length === 1 + 32 + 1 && buf[1 + 32 + 1 - 1] === 1) {
+            info.compressed = true;
+        }
+        else if (buf.length === 1 + 32) {
+            info.compressed = false;
+        }
+        else {
+            throw new Error('Length of buffer must be 33 (uncompressed) or 34 (compressed)');
+        }
+        info.bn = new BN(buf.subarray(1, 32 + 1), 'be');
+        return info;
+    }
+    static _transformBNBuffer(buf, network) {
+        network ||= defaultNetwork;
+        return {
+            network: getNetwork(network),
+            bn: new BN(buf, 'be'),
+            compressed: true,
+        };
+    }
+    static _transformWIF(str, network) {
+        return PrivateKey._transformBuffer(Base58Check.decode(str), network);
+    }
+    static _transformObject(json) {
+        const bn = new BN(json.bn, 16);
+        const network = getNetwork(json.network);
+        return {
+            bn: bn,
+            network: network || defaultNetwork,
+            compressed: json.compressed,
+        };
+    }
+    static fromBuffer(arg, network) {
+        return new PrivateKey(arg, network);
+    }
+    static fromString(str, network) {
+        if (typeof str !== 'string') {
+            throw new Error('First argument is expected to be a string.');
+        }
+        return new PrivateKey(str, network);
+    }
+    static fromWIF(str, network) {
+        return PrivateKey.fromString(str, network ?? defaultNetwork);
+    }
+    static fromObject(obj, network) {
+        if (typeof obj !== 'object') {
+            throw new Error('First argument is expected to be an object.');
+        }
+        return new PrivateKey(obj, network);
+    }
+    static fromRandom(network) {
+        const bn = PrivateKey._getRandomBN();
+        return new PrivateKey(bn, network);
+    }
+    static getValidationError(data, network) {
+        try {
+            new PrivateKey(data, network);
+            return null;
+        }
+        catch (e) {
+            return e;
+        }
+    }
+    static isValid(data, network) {
+        if (!data) {
+            return false;
+        }
+        return !PrivateKey.getValidationError(data, network);
+    }
+    toString() {
+        return this.toBuffer().toString('hex');
+    }
+    toWIF(compressed = true) {
+        let buf;
+        if (compressed) {
+            buf = Buffer.concat([
+                Buffer.from([this.network.privatekey]),
+                this.bn.toArrayLike(Buffer, 'be', 32),
+                Buffer.from([0x01]),
+            ]);
+        }
+        else {
+            buf = Buffer.concat([
+                Buffer.from([this.network.privatekey]),
+                this.bn.toArrayLike(Buffer, 'be', 32),
+            ]);
+        }
+        return Base58Check.encode(buf);
+    }
+    toBigNumber() {
+        return this.bn;
+    }
+    toBuffer() {
+        return this.bn.toArrayLike(Buffer, 'be', 32);
+    }
+    toBufferNoPadding() {
+        return this.bn.toArrayLike(Buffer, 'be');
+    }
+    toPublicKey() {
+        if (!this._pubkey) {
+            this._pubkey = PublicKey.fromPrivateKey(this);
+        }
+        return this._pubkey;
+    }
+    toAddress(network) {
+        const pubkey = this.toPublicKey();
+        return Address.fromPublicKey(pubkey, network ?? this.network.name);
+    }
+    toObject() {
+        return {
+            bn: this.bn.toString(16),
+            compressed: this.compressed,
+            network: this.network.toString(),
+        };
+    }
+    toJSON() {
+        return this.toObject();
+    }
+    inspect() {
+        const uncompressed = !this.compressed ? ', uncompressed' : '';
+        return `<PrivateKey: ${this.toString()}, network: ${this.network}${uncompressed}>`;
+    }
+}

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

@@ -0,0 +1,59 @@
+import { BN } from './crypto/bn.js';
+import { Point } from './crypto/point.js';
+import { Network } from './networks.js';
+import { PrivateKey } from './privatekey.js';
+import { Address } from './address.js';
+export interface PublicKeyData {
+    point: Point;
+    compressed: boolean;
+    network?: Network;
+}
+export interface PublicKeyExtra {
+    network?: Network | string;
+    compressed?: boolean;
+}
+export interface PublicKeyObject {
+    x: string;
+    y: string;
+    compressed: boolean;
+}
+export interface PublicKeySerialized {
+    x: string;
+    y: string;
+    compressed: boolean;
+}
+export type PublicKeyInput = Point | PublicKeyObject | string | Buffer | PrivateKey;
+export declare class PublicKey {
+    readonly point: Point;
+    readonly compressed: boolean;
+    readonly network: Network;
+    constructor(data: PublicKeyInput, extra?: PublicKeyExtra);
+    private _classifyArgs;
+    private static _isPrivateKey;
+    private static _isBuffer;
+    private static _transformPrivateKey;
+    private static _transformDER;
+    private static _transformX;
+    private static _transformObject;
+    static fromPrivateKey(privkey: PrivateKey): PublicKey;
+    static fromDER(buf: Buffer, strict?: boolean): PublicKey;
+    static fromBuffer(buf: Buffer, strict?: boolean): PublicKey;
+    static fromPoint(point: Point, compressed?: boolean): PublicKey;
+    static fromString(str: string, encoding?: string): PublicKey;
+    static fromX(odd: boolean, x: BN): PublicKey;
+    static getValidationError(data: PublicKeyInput): Error | null;
+    static isValid(data: PublicKeyInput): boolean;
+    static isValid(data: PublicKey): boolean;
+    toObject(): PublicKeySerialized;
+    toJSON(): PublicKeySerialized;
+    toBigNumber(): BN;
+    toBuffer(): Buffer;
+    toDER(): Buffer;
+    _getID(): Buffer;
+    toAddress(network?: Network | string): Address;
+    toString(): string;
+    inspect(): string;
+    addScalar(scalar: Buffer | BN): PublicKey;
+    static getN(): BN;
+}
+//# sourceMappingURL=publickey.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"publickey.d.ts","sourceRoot":"","sources":["../../../lib/bitcore/publickey.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAA;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAGzC,OAAO,EAAE,OAAO,EAAqC,MAAM,eAAe,CAAA;AAC1E,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAEtC,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,KAAK,CAAA;IACZ,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;IAC1B,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,UAAU,EAAE,OAAO,CAAA;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;IACT,UAAU,EAAE,OAAO,CAAA;CACpB;AAED,MAAM,MAAM,cAAc,GACtB,KAAK,GACL,eAAe,GACf,MAAM,GACN,MAAM,GACN,UAAU,CAAA;AAEd,qBAAa,SAAS;IACpB,QAAQ,CAAC,KAAK,EAAG,KAAK,CAAA;IACtB,QAAQ,CAAC,UAAU,EAAG,OAAO,CAAA;IAC7B,QAAQ,CAAC,OAAO,EAAG,OAAO,CAAA;gBAEd,IAAI,EAAE,cAAc,EAAE,KAAK,CAAC,EAAE,cAAc;IA4BxD,OAAO,CAAC,aAAa;IA+CrB,OAAO,CAAC,MAAM,CAAC,aAAa;IAO5B,OAAO,CAAC,MAAM,CAAC,SAAS;IAOxB,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAcnC,OAAO,CAAC,MAAM,CAAC,aAAa;IAmD5B,OAAO,CAAC,MAAM,CAAC,WAAW;IAa1B,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAa/B,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,UAAU,GAAG,SAAS;IAcrD,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS;IAaxD,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS;IAO3D,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,SAAS;IAY/D,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS;IAW5D,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,GAAG,SAAS;IAU5C,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,KAAK,GAAG,IAAI;IAY7D,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO;IAC7C,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,OAAO;IAWxC,QAAQ,IAAI,mBAAmB;IAW/B,MAAM,IAAI,mBAAmB;IAO7B,WAAW,IAAI,EAAE;IAOjB,QAAQ,IAAI,MAAM;IAOlB,KAAK,IAAI,MAAM;IAyBf,MAAM,IAAI,MAAM;IAOhB,SAAS,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO;IAO9C,QAAQ,IAAI,MAAM;IAOlB,OAAO,IAAI,MAAM;IAkBjB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,EAAE,GAAG,SAAS;IAuBzC,MAAM,CAAC,IAAI,IAAI,EAAE;CAGlB"}