xpi-ts 0.2.0

package/dist/lib/bitcore/hdpublickey.js

@@ -0,0 +1,416 @@
+import { BN } from './crypto/bn.js';
+import { PublicKey } from './publickey.js';
+import { HDPrivateKey } from './hdprivatekey.js';
+import { get as getNetwork } from './networks.js';
+import { Hash } from './crypto/hash.js';
+import { Base58Check } from './encoding/base58check.js';
+import { JSUtil } from './util/js.js';
+import { Preconditions } from './util/preconditions.js';
+import { Point } from './crypto/point.js';
+export class HDPublicKey {
+    xpubkey;
+    network;
+    depth;
+    publicKey;
+    fingerPrint;
+    parentFingerPrint;
+    childIndex;
+    chainCode;
+    _buffers;
+    static Hardened = 0x80000000;
+    static RootElementAlias = ['m', 'M'];
+    static VersionSize = 4;
+    static DepthSize = 1;
+    static ParentFingerPrintSize = 4;
+    static ChildIndexSize = 4;
+    static ChainCodeSize = 32;
+    static PublicKeySize = 33;
+    static CheckSumSize = 4;
+    static DataSize = 78;
+    static SerializedByteSize = 82;
+    static VersionStart = 0;
+    static VersionEnd = HDPublicKey.VersionStart + HDPublicKey.VersionSize;
+    static DepthStart = HDPublicKey.VersionEnd;
+    static DepthEnd = HDPublicKey.DepthStart + HDPublicKey.DepthSize;
+    static ParentFingerPrintStart = HDPublicKey.DepthEnd;
+    static ParentFingerPrintEnd = HDPublicKey.ParentFingerPrintStart + HDPublicKey.ParentFingerPrintSize;
+    static ChildIndexStart = HDPublicKey.ParentFingerPrintEnd;
+    static ChildIndexEnd = HDPublicKey.ChildIndexStart + HDPublicKey.ChildIndexSize;
+    static ChainCodeStart = HDPublicKey.ChildIndexEnd;
+    static ChainCodeEnd = HDPublicKey.ChainCodeStart + HDPublicKey.ChainCodeSize;
+    static PublicKeyStart = HDPublicKey.ChainCodeEnd;
+    static PublicKeyEnd = HDPublicKey.PublicKeyStart + HDPublicKey.PublicKeySize;
+    static ChecksumStart = HDPublicKey.PublicKeyEnd;
+    static ChecksumEnd = HDPublicKey.ChecksumStart + HDPublicKey.CheckSumSize;
+    constructor(arg) {
+        if (arg instanceof HDPublicKey) {
+            return arg;
+        }
+        if (!(this instanceof HDPublicKey)) {
+            return new HDPublicKey(arg);
+        }
+        if (arg) {
+            if (typeof arg === 'string' || Buffer.isBuffer(arg)) {
+                const error = HDPublicKey.getSerializedError(arg);
+                if (!error) {
+                    return this._buildFromSerialized(arg);
+                }
+                else if (Buffer.isBuffer(arg) &&
+                    !HDPublicKey.getSerializedError(arg.toString())) {
+                    return this._buildFromSerialized(arg.toString());
+                }
+                else {
+                    throw error;
+                }
+            }
+            else {
+                if (typeof arg === 'object' && arg !== null) {
+                    if (arg instanceof HDPrivateKey) {
+                        return this._buildFromPrivate(arg);
+                    }
+                    else {
+                        return this._buildFromObject(arg);
+                    }
+                }
+                else {
+                    throw new Error('Unrecognized argument');
+                }
+            }
+        }
+        else {
+            throw new Error('Must supply an argument to create a HDPublicKey');
+        }
+    }
+    static isValidPath(arg) {
+        if (typeof arg === 'string') {
+            const indexes = arg.split('/').slice(1).map(Number);
+            return indexes.every(HDPublicKey.isValidPath);
+        }
+        if (typeof arg === 'number') {
+            return arg >= 0 && arg < HDPublicKey.Hardened;
+        }
+        return false;
+    }
+    static isValidSerialized(data, network) {
+        return HDPublicKey.getSerializedError(data, network) === null;
+    }
+    static getSerializedError(data, network) {
+        if (!(typeof data === 'string' || Buffer.isBuffer(data))) {
+            return new Error('expected buffer or string');
+        }
+        if (typeof data === 'string' && !JSUtil.isHexa(data)) {
+            try {
+                Base58Check.decode(data);
+            }
+            catch (e) {
+                return new Error('Invalid base58 checksum');
+            }
+        }
+        if (Buffer.isBuffer(data) && data.length !== HDPublicKey.DataSize) {
+            return new Error('Invalid length');
+        }
+        if (typeof data === 'string') {
+            const decoded = Base58Check.decode(data);
+            if (decoded.length !== HDPublicKey.DataSize) {
+                return new Error('Invalid length');
+            }
+        }
+        if (network !== undefined) {
+            const error = HDPublicKey._validateNetwork(data, network);
+            if (error) {
+                return error;
+            }
+        }
+        return null;
+    }
+    static _validateNetwork(data, networkArg) {
+        const network = getNetwork(networkArg);
+        if (!network) {
+            return new Error('Invalid network argument');
+        }
+        const version = Buffer.isBuffer(data)
+            ? data.subarray(HDPublicKey.VersionStart, HDPublicKey.VersionEnd)
+            : Buffer.from(Base58Check.decode(data).subarray(HDPublicKey.VersionStart, HDPublicKey.VersionEnd));
+        if (version.readUInt32BE(0) !== network.xpubkey) {
+            return new Error('Invalid network');
+        }
+        return null;
+    }
+    static fromString(arg) {
+        Preconditions.checkArgument(typeof arg === 'string', 'No valid string was provided');
+        return new HDPublicKey(arg);
+    }
+    static fromObject(arg) {
+        Preconditions.checkArgument(typeof arg === 'object', 'No valid argument was provided');
+        return new HDPublicKey(arg);
+    }
+    static fromBuffer(arg) {
+        return new HDPublicKey(arg);
+    }
+    _classifyArguments(arg) {
+        if (typeof arg === 'string') {
+            return HDPublicKey._transformString(arg);
+        }
+        else if (Buffer.isBuffer(arg)) {
+            return HDPublicKey._transformBuffer(arg);
+        }
+        else if (typeof arg === 'object' && arg !== null) {
+            if ('xpubkey' in arg) {
+                return HDPublicKey._transformObject(arg);
+            }
+            else {
+                return arg;
+            }
+        }
+        else {
+            throw new Error('Invalid HDPublicKey data');
+        }
+    }
+    static _transformString(str) {
+        if (!JSUtil.isHexa(str)) {
+            return HDPublicKey._transformSerialized(str);
+        }
+        return HDPublicKey._transformBuffer(Buffer.from(str, 'hex'));
+    }
+    static _transformSerialized(str) {
+        const buf = Base58Check.decode(str);
+        return HDPublicKey._transformBuffer(buf);
+    }
+    static _transformBuffer(buf) {
+        if (buf.length !== 78) {
+            throw new Error('Invalid HDPublicKey buffer length');
+        }
+        const version = buf.readUInt32BE(0);
+        const network = getNetwork(version, 'xpubkey');
+        if (!network) {
+            throw new Error('Invalid HDPublicKey network');
+        }
+        const depth = buf.readUInt8(4);
+        const parentFingerPrint = buf.subarray(5, 9);
+        const childIndex = buf.readUInt32BE(9);
+        const chainCode = buf.subarray(13, 45);
+        const publicKeyBuffer = buf.subarray(45, 78);
+        return {
+            network,
+            depth,
+            parentFingerPrint,
+            childIndex,
+            chainCode,
+            publicKey: PublicKey.fromBuffer(publicKeyBuffer),
+        };
+    }
+    static _transformObject(obj) {
+        const network = getNetwork(obj.network);
+        if (!network) {
+            throw new Error('Invalid network');
+        }
+        return {
+            network,
+            depth: obj.depth,
+            parentFingerPrint: Buffer.from(obj.parentFingerPrint, 'hex'),
+            childIndex: obj.childIndex,
+            chainCode: Buffer.from(obj.chainCode, 'hex'),
+            publicKey: PublicKey.fromBuffer(Buffer.from(obj.publicKey, 'hex')),
+        };
+    }
+    _buildFromPrivate(arg) {
+        const args = {
+            version: arg._buffers.version,
+            depth: arg._buffers.depth,
+            parentFingerPrint: arg._buffers.parentFingerPrint,
+            childIndex: arg._buffers.childIndex,
+            chainCode: arg._buffers.chainCode,
+            publicKey: Point.pointToCompressed(Point.getG().mul(new BN(arg._buffers.privateKey))),
+            checksum: arg._buffers.checksum,
+        };
+        return this._buildFromBuffers(args);
+    }
+    _buildFromSerialized(arg) {
+        const decoded = typeof arg === 'string' ? Base58Check.decode(arg) : arg;
+        const buffers = {
+            version: decoded.subarray(HDPublicKey.VersionStart, HDPublicKey.VersionEnd),
+            depth: decoded.subarray(HDPublicKey.DepthStart, HDPublicKey.DepthEnd),
+            parentFingerPrint: decoded.subarray(HDPublicKey.ParentFingerPrintStart, HDPublicKey.ParentFingerPrintEnd),
+            childIndex: decoded.subarray(HDPublicKey.ChildIndexStart, HDPublicKey.ChildIndexEnd),
+            chainCode: decoded.subarray(HDPublicKey.ChainCodeStart, HDPublicKey.ChainCodeEnd),
+            publicKey: decoded.subarray(HDPublicKey.PublicKeyStart, HDPublicKey.PublicKeyEnd),
+            checksum: decoded.subarray(HDPublicKey.ChecksumStart, HDPublicKey.ChecksumEnd),
+            xpubkey: typeof arg === 'string' ? Buffer.from(arg) : arg,
+        };
+        return this._buildFromBuffers(buffers);
+    }
+    _buildFromBuffers(arg) {
+        HDPublicKey._validateBufferArguments(arg);
+        JSUtil.defineImmutable(this, {
+            _buffers: arg,
+        });
+        const sequence = [
+            arg.version,
+            arg.depth,
+            arg.parentFingerPrint,
+            arg.childIndex,
+            arg.chainCode,
+            arg.publicKey,
+        ];
+        const concat = Buffer.concat(sequence);
+        const checksum = Base58Check.checksum(concat);
+        if (!arg.checksum || !arg.checksum.length) {
+            arg.checksum = checksum;
+        }
+        else {
+            if (arg.checksum.toString('hex') !== checksum.toString('hex')) {
+                throw new Error('Invalid base58 checksum');
+            }
+        }
+        const network = getNetwork(arg.version.readUInt32BE(0));
+        const xpubkey = Base58Check.encode(Buffer.concat(sequence));
+        arg.xpubkey = Buffer.from(xpubkey);
+        const publicKey = new PublicKey(arg.publicKey, { network });
+        const size = HDPublicKey.ParentFingerPrintSize;
+        const fingerPrint = Hash.sha256ripemd160(publicKey.toBuffer()).subarray(0, size);
+        JSUtil.defineImmutable(this, {
+            xpubkey: xpubkey,
+            network: network,
+            depth: arg.depth.readUInt8(0),
+            publicKey: publicKey,
+            fingerPrint: fingerPrint,
+        });
+        return this;
+    }
+    static _validateBufferArguments(arg) {
+        const checkBuffer = (name, size) => {
+            const buff = arg[name];
+            if (!Buffer.isBuffer(buff)) {
+                throw new Error(`${name} argument is not a buffer, it's ${typeof buff}`);
+            }
+            if (buff.length !== size) {
+                throw new Error(`${name} has not the expected size: found ${buff.length}, expected ${size}`);
+            }
+        };
+        checkBuffer('version', HDPublicKey.VersionSize);
+        checkBuffer('depth', HDPublicKey.DepthSize);
+        checkBuffer('parentFingerPrint', HDPublicKey.ParentFingerPrintSize);
+        checkBuffer('childIndex', HDPublicKey.ChildIndexSize);
+        checkBuffer('chainCode', HDPublicKey.ChainCodeSize);
+        checkBuffer('publicKey', HDPublicKey.PublicKeySize);
+        if (arg.checksum && arg.checksum.length) {
+            checkBuffer('checksum', HDPublicKey.CheckSumSize);
+        }
+    }
+    _buildFromObject(arg) {
+        const buffers = {
+            version: Buffer.alloc(4),
+            depth: typeof arg.depth === 'number'
+                ? Buffer.from([arg.depth])
+                : Buffer.alloc(1),
+            parentFingerPrint: typeof arg.parentFingerPrint === 'number'
+                ? Buffer.from([arg.parentFingerPrint])
+                : Buffer.isBuffer(arg.parentFingerPrint)
+                    ? arg.parentFingerPrint
+                    : Buffer.alloc(4),
+            childIndex: Buffer.alloc(4),
+            chainCode: typeof arg.chainCode === 'string'
+                ? Buffer.from(arg.chainCode, 'hex')
+                : Buffer.isBuffer(arg.chainCode)
+                    ? arg.chainCode
+                    : Buffer.alloc(32),
+            publicKey: typeof arg.publicKey === 'string'
+                ? Buffer.from(arg.publicKey, 'hex')
+                : Buffer.isBuffer(arg.publicKey)
+                    ? arg.publicKey
+                    : arg.publicKey?.toBuffer() || Buffer.alloc(33),
+            checksum: undefined,
+        };
+        if (arg.network) {
+            const network = getNetwork(arg.network);
+            if (network) {
+                buffers.version.writeUInt32BE(network.xpubkey, 0);
+            }
+        }
+        if (typeof arg.childIndex === 'number') {
+            buffers.childIndex.writeUInt32BE(arg.childIndex, 0);
+        }
+        return this._buildFromBuffers(buffers);
+    }
+    derive(arg, hardened) {
+        return this.deriveChild(arg, hardened);
+    }
+    deriveChild(arg, hardened) {
+        if (typeof arg === 'number') {
+            return this._deriveWithNumber(arg, hardened);
+        }
+        else if (typeof arg === 'string') {
+            return this._deriveFromString(arg);
+        }
+        else {
+            throw new Error('Invalid derivation argument');
+        }
+    }
+    _deriveWithNumber(index, hardened) {
+        if (index >= HDPublicKey.Hardened || hardened) {
+            throw new Error('Cannot derive hardened keys from public key');
+        }
+        if (index < 0) {
+            throw new Error('Invalid path');
+        }
+        const indexBuffer = Buffer.alloc(4);
+        indexBuffer.writeUInt32BE(index, 0);
+        const data = Buffer.concat([this.publicKey.toBuffer(), indexBuffer]);
+        const hash = Hash.sha512hmac(data, this._buffers.chainCode);
+        const leftPart = new BN(hash.subarray(0, 32));
+        const chainCode = hash.subarray(32, 64);
+        let publicKey;
+        try {
+            publicKey = PublicKey.fromPoint(Point.getG().mul(leftPart).add(this.publicKey.point));
+        }
+        catch (e) {
+            return this._deriveWithNumber(index + 1);
+        }
+        const derived = new HDPublicKey({
+            network: this.network,
+            depth: this.depth + 1,
+            parentFingerPrint: this.fingerPrint,
+            childIndex: index,
+            chainCode: chainCode,
+            publicKey: publicKey,
+        });
+        return derived;
+    }
+    _deriveFromString(path) {
+        if (path.includes("'")) {
+            throw new Error('Cannot derive hardened keys from public key');
+        }
+        else if (!HDPublicKey.isValidPath(path)) {
+            throw new Error('Invalid path');
+        }
+        const indexes = path.split('/').slice(1).map(Number);
+        const derived = indexes.reduce((prev, index) => {
+            return prev._deriveWithNumber(index);
+        }, this);
+        return derived;
+    }
+    toString() {
+        return this.xpubkey.toString();
+    }
+    toBuffer() {
+        return Buffer.from(this._buffers.xpubkey || Buffer.alloc(0));
+    }
+    toObject() {
+        return {
+            network: this.network.name,
+            depth: this.depth,
+            fingerPrint: this.fingerPrint.toString('hex'),
+            parentFingerPrint: this._buffers.parentFingerPrint.toString('hex'),
+            childIndex: this._buffers.childIndex.readUInt32BE(0),
+            chainCode: this._buffers.chainCode.toString('hex'),
+            publicKey: this.publicKey.toString(),
+            xpubkey: this.xpubkey.toString(),
+        };
+    }
+    toJSON() {
+        return JSON.stringify(this.toObject());
+    }
+    inspect() {
+        return '<HDPublicKey: ' + this.xpubkey + '>';
+    }
+}

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

@@ -0,0 +1,60 @@
+export { Hash } from './crypto/hash.js';
+export { Random } from './crypto/random.js';
+export { Point } from './crypto/point.js';
+export { Signature } from './crypto/signature.js';
+export { ECDSA } from './crypto/ecdsa.js';
+export { Schnorr } from './crypto/schnorr.js';
+export { BN } from './crypto/bn.js';
+export { musigKeyAgg, musigNonceGen, musigNonceAgg, musigPartialSign, musigPartialSigVerify, musigSigAgg, musigTaggedHash, type MuSigKeyAggContext, type MuSigNonce, type MuSigAggregatedNonce, } from './crypto/musig2.js';
+export { MuSigSessionManager, MuSigSessionPhase, type MuSigSession, } from './musig2/session.js';
+export { MuSig2Signer, createMuSig2Signer, type MuSig2SignerConfig, type MuSig2PrepareResult, type MuSig2SignResult, type MuSig2TaprootSignResult, } from './musig2/signer.js';
+export { buildMuSigTaprootKey, buildMuSigTaprootKeyWithScripts, signTaprootKeyPathWithMuSig2, verifyTaprootKeyPathMuSigPartial, isMuSigTaprootOutput, createMuSigTaprootAddress, type MuSigTaprootKeyResult, } from './taproot/musig2.js';
+export { PrivateKey } from './privatekey.js';
+export { PublicKey } from './publickey.js';
+export { HDPrivateKey } from './hdprivatekey.js';
+export { HDPublicKey } from './hdpublickey.js';
+export { JSUtil } from './util/js.js';
+export { Preconditions } from './util/preconditions.js';
+export { Base32 } from './util/base32.js';
+export { convertBits } from './util/convertBits.js';
+export { BufferUtil, NULL_HASH, EMPTY_BUFFER } from './util/buffer.js';
+export { util } from './util.js';
+export { BitcoreError } from './errors.js';
+export { Base58 } from './encoding/base58.js';
+export { Base58Check } from './encoding/base58check.js';
+export { BufferReader } from './encoding/bufferreader.js';
+export { BufferWriter, BufferWriterFactory } from './encoding/bufferwriter.js';
+export { Varint } from './encoding/varint.js';
+export { Network, livenet, testnet, regtest, networks, defaultNetwork, get as getNetwork, add as addNetwork, remove as removeNetwork, Networks, } from './networks.js';
+export { Address } from './address.js';
+export { XAddress } from './xaddress.js';
+export { Script } from './script.js';
+export { Opcode } from './opcode.js';
+export { Interpreter } from './script/interpreter.js';
+export { Chunk } from './chunk.js';
+export { type ScriptType, ScriptTypes, toAddress, empty } from './script.js';
+export { Unit } from './unit.js';
+export { Message } from './message.js';
+export { URI } from './uri.js';
+export { Input, MultisigInput, MultisigScriptHashInput, PublicKeyInput, PublicKeyHashInput, TaprootInput, Output, UnspentOutput, sighash, sign, verify, TransactionSignature, Transaction, } from './transaction/index.js';
+export { DEFAULT_SIGN_FLAGS, SIGHASH_SINGLE_BUG, BITS_64_ON, } from './transaction/sighash.js';
+export { buildKeyPathTaproot, buildPayToTaproot, buildScriptPathTaproot, buildTapTree, calculateTapBranch, calculateTapLeaf, calculateTapTweak, createControlBlock, extractTaprootCommitment, extractTaprootState, isPayToTaproot, isTapLeafNode, isTapBranchNode, taggedHash, tweakPublicKey, tweakPrivateKey, verifyTaprootCommitment, verifyTaprootScriptPath, verifyTaprootSpend, TAPROOT_LEAF_MASK, TAPROOT_LEAF_TAPSCRIPT, TAPROOT_CONTROL_BASE_SIZE, TAPROOT_CONTROL_NODE_SIZE, TAPROOT_CONTROL_MAX_NODE_COUNT, TAPROOT_CONTROL_MAX_SIZE, TAPROOT_SCRIPTTYPE, TAPROOT_INTRO_SIZE, TAPROOT_SIGHASH_TYPE, TAPROOT_SIZE_WITHOUT_STATE, TAPROOT_SIZE_WITH_STATE, TAPROOT_ANNEX_TAG, type TapLeafNode, type TapBranchNode, type TapNode, type TapLeaf, type TapTreeBuildResult, } from './taproot.js';
+export { NFT, NFTUtil } from './taproot/nft.js';
+export type { NFTMetadata, NFTAttribute, NFTCollectionMetadata, NFTData, NFTTransfer, NFTMintConfig, NFTTransferConfig, NFTUtxo, NFTWithScriptPath, NFTWithCollection, NFTInfo, NFTObject, } from './taproot/nft.js';
+export { Block, BlockHeader } from './block/index.js';
+export { Mnemonic, MnemonicError, pbkdf2, Words } from './mnemonic/index.js';
+export type { InputData, InputObject, OutputData, OutputObject, UnspentOutputData, UnspentOutputObject, TransactionSignatureData, TransactionSignatureObject, TransactionData, TransactionObject, } from './transaction/index.js';
+export type { BlockData, BlockObject, BlockHeaderData, BlockHeaderObject, } from './block/index.js';
+export type { NetworkConfig } from './networks.js';
+export type { PrivateKeyData, PrivateKeyObject, PrivateKeySerialized, } from './privatekey.js';
+export type { PublicKeyData, PublicKeyExtra, PublicKeyObject, PublicKeySerialized, } from './publickey.js';
+export type { HDPrivateKeyData, HDPrivateKeyObject, HDPrivateKeyBuffers, } from './hdprivatekey.js';
+export type { HDPublicKeyData, HDPublicKeyObject, HDPublicKeyBuffers, } from './hdpublickey.js';
+export type { AddressData, AddressObject, CashAddressDecoding, } from './address.js';
+export type { XAddressData, XAddressObject } from './xaddress.js';
+export type { ScriptData } from './script.js';
+export type { TaprootVerifyResult } from './taproot.js';
+export type { URIParams } from './uri.js';
+export type { UnitData } from './unit.js';
+export type { TransactionLike } from './transaction/sighash.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/bitcore/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAA;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAC7C,OAAO,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAA;AAGnC,OAAO,EACL,WAAW,EACX,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,qBAAqB,EACrB,WAAW,EACX,eAAe,EACf,KAAK,kBAAkB,EACvB,KAAK,UAAU,EACf,KAAK,oBAAoB,GAC1B,MAAM,oBAAoB,CAAA;AAG3B,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,KAAK,YAAY,GAClB,MAAM,qBAAqB,CAAA;AAE5B,OAAO,EAEL,YAAY,EACZ,kBAAkB,EAClB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,GAC7B,MAAM,oBAAoB,CAAA;AAG3B,OAAO,EACL,oBAAoB,EACpB,+BAA+B,EAC/B,4BAA4B,EAC5B,gCAAgC,EAChC,oBAAoB,EACpB,yBAAyB,EACzB,KAAK,qBAAqB,GAC3B,MAAM,qBAAqB,CAAA;AAG5B,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAG9C,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AACtE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAGhC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAG1C,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAC7C,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AACzD,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AAC9E,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAG7C,OAAO,EACL,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,EACP,QAAQ,EACR,cAAc,EACd,GAAG,IAAI,UAAU,EACjB,GAAG,IAAI,UAAU,EACjB,MAAM,IAAI,aAAa,EACvB,QAAQ,GACT,MAAM,eAAe,CAAA;AAGtB,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAGxC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AACrD,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,KAAK,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AAG5E,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAGhC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAGtC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAG9B,OAAO,EACL,KAAK,EACL,aAAa,EACb,uBAAuB,EACvB,cAAc,EACd,kBAAkB,EAClB,YAAY,EACZ,MAAM,EACN,aAAa,EACb,OAAO,EACP,IAAI,EACJ,MAAM,EACN,oBAAoB,EACpB,WAAW,GACZ,MAAM,wBAAwB,CAAA;AAG/B,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,UAAU,GACX,MAAM,0BAA0B,CAAA;AAGjC,OAAO,EAEL,mBAAmB,EACnB,iBAAiB,EACjB,sBAAsB,EACtB,YAAY,EACZ,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,kBAAkB,EAClB,wBAAwB,EACxB,mBAAmB,EACnB,cAAc,EACd,aAAa,EACb,eAAe,EACf,UAAU,EACV,cAAc,EACd,eAAe,EACf,uBAAuB,EACvB,uBAAuB,EACvB,kBAAkB,EAElB,iBAAiB,EACjB,sBAAsB,EACtB,yBAAyB,EACzB,yBAAyB,EACzB,8BAA8B,EAC9B,wBAAwB,EACxB,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,0BAA0B,EAC1B,uBAAuB,EACvB,iBAAiB,EAEjB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,OAAO,EACZ,KAAK,OAAO,EACZ,KAAK,kBAAkB,GACxB,MAAM,cAAc,CAAA;AAGrB,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAE/C,YAAY,EACV,WAAW,EACX,YAAY,EACZ,qBAAqB,EACrB,OAAO,EACP,WAAW,EACX,aAAa,EACb,iBAAiB,EACjB,OAAO,EACP,iBAAiB,EACjB,iBAAiB,EACjB,OAAO,EACP,SAAS,GACV,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAGrD,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAA;AAG5E,YAAY,EACV,SAAS,EACT,WAAW,EACX,UAAU,EACV,YAAY,EACZ,iBAAiB,EACjB,mBAAmB,EACnB,wBAAwB,EACxB,0BAA0B,EAC1B,eAAe,EACf,iBAAiB,GAClB,MAAM,wBAAwB,CAAA;AAE/B,YAAY,EACV,SAAS,EACT,WAAW,EACX,eAAe,EACf,iBAAiB,GAClB,MAAM,kBAAkB,CAAA;AAGzB,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAElD,YAAY,EACV,cAAc,EACd,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,iBAAiB,CAAA;AAExB,YAAY,EACV,aAAa,EACb,cAAc,EACd,eAAe,EACf,mBAAmB,GACpB,MAAM,gBAAgB,CAAA;AAEvB,YAAY,EACV,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,mBAAmB,CAAA;AAE1B,YAAY,EACV,eAAe,EACf,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,kBAAkB,CAAA;AAEzB,YAAY,EACV,WAAW,EACX,aAAa,EACb,mBAAmB,GACpB,MAAM,cAAc,CAAA;AAErB,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAEjE,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAE7C,YAAY,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAEvD,YAAY,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzC,YAAY,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAEzC,YAAY,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA"}

package/dist/lib/bitcore/index.js

@@ -0,0 +1,44 @@
+export { Hash } from './crypto/hash.js';
+export { Random } from './crypto/random.js';
+export { Point } from './crypto/point.js';
+export { Signature } from './crypto/signature.js';
+export { ECDSA } from './crypto/ecdsa.js';
+export { Schnorr } from './crypto/schnorr.js';
+export { BN } from './crypto/bn.js';
+export { musigKeyAgg, musigNonceGen, musigNonceAgg, musigPartialSign, musigPartialSigVerify, musigSigAgg, musigTaggedHash, } from './crypto/musig2.js';
+export { MuSigSessionManager, MuSigSessionPhase, } from './musig2/session.js';
+export { MuSig2Signer, createMuSig2Signer, } from './musig2/signer.js';
+export { buildMuSigTaprootKey, buildMuSigTaprootKeyWithScripts, signTaprootKeyPathWithMuSig2, verifyTaprootKeyPathMuSigPartial, isMuSigTaprootOutput, createMuSigTaprootAddress, } from './taproot/musig2.js';
+export { PrivateKey } from './privatekey.js';
+export { PublicKey } from './publickey.js';
+export { HDPrivateKey } from './hdprivatekey.js';
+export { HDPublicKey } from './hdpublickey.js';
+export { JSUtil } from './util/js.js';
+export { Preconditions } from './util/preconditions.js';
+export { Base32 } from './util/base32.js';
+export { convertBits } from './util/convertBits.js';
+export { BufferUtil, NULL_HASH, EMPTY_BUFFER } from './util/buffer.js';
+export { util } from './util.js';
+export { BitcoreError } from './errors.js';
+export { Base58 } from './encoding/base58.js';
+export { Base58Check } from './encoding/base58check.js';
+export { BufferReader } from './encoding/bufferreader.js';
+export { BufferWriter, BufferWriterFactory } from './encoding/bufferwriter.js';
+export { Varint } from './encoding/varint.js';
+export { Network, livenet, testnet, regtest, networks, defaultNetwork, get as getNetwork, add as addNetwork, remove as removeNetwork, Networks, } from './networks.js';
+export { Address } from './address.js';
+export { XAddress } from './xaddress.js';
+export { Script } from './script.js';
+export { Opcode } from './opcode.js';
+export { Interpreter } from './script/interpreter.js';
+export { Chunk } from './chunk.js';
+export { ScriptTypes, toAddress, empty } from './script.js';
+export { Unit } from './unit.js';
+export { Message } from './message.js';
+export { URI } from './uri.js';
+export { Input, MultisigInput, MultisigScriptHashInput, PublicKeyInput, PublicKeyHashInput, TaprootInput, Output, UnspentOutput, sighash, sign, verify, TransactionSignature, Transaction, } from './transaction/index.js';
+export { DEFAULT_SIGN_FLAGS, SIGHASH_SINGLE_BUG, BITS_64_ON, } from './transaction/sighash.js';
+export { buildKeyPathTaproot, buildPayToTaproot, buildScriptPathTaproot, buildTapTree, calculateTapBranch, calculateTapLeaf, calculateTapTweak, createControlBlock, extractTaprootCommitment, extractTaprootState, isPayToTaproot, isTapLeafNode, isTapBranchNode, taggedHash, tweakPublicKey, tweakPrivateKey, verifyTaprootCommitment, verifyTaprootScriptPath, verifyTaprootSpend, TAPROOT_LEAF_MASK, TAPROOT_LEAF_TAPSCRIPT, TAPROOT_CONTROL_BASE_SIZE, TAPROOT_CONTROL_NODE_SIZE, TAPROOT_CONTROL_MAX_NODE_COUNT, TAPROOT_CONTROL_MAX_SIZE, TAPROOT_SCRIPTTYPE, TAPROOT_INTRO_SIZE, TAPROOT_SIGHASH_TYPE, TAPROOT_SIZE_WITHOUT_STATE, TAPROOT_SIZE_WITH_STATE, TAPROOT_ANNEX_TAG, } from './taproot.js';
+export { NFT, NFTUtil } from './taproot/nft.js';
+export { Block, BlockHeader } from './block/index.js';
+export { Mnemonic, MnemonicError, pbkdf2, Words } from './mnemonic/index.js';

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

@@ -0,0 +1,23 @@
+import { PrivateKey } from './privatekey.js';
+import { Address } from './address.js';
+export declare class Message {
+    private _message;
+    error?: string;
+    static readonly MAGIC_BYTES: Buffer<ArrayBuffer>;
+    constructor(message: string);
+    magicHash(): Buffer;
+    private _sign;
+    sign(privateKey: PrivateKey): string;
+    private _verify;
+    verify(bitcoinAddress: Address | string, signatureString: string): boolean;
+    recoverPublicKey(bitcoinAddress: Address | string, signatureString: string): string;
+    static fromString(str: string): Message;
+    static fromJSON(json: string | object): Message;
+    toObject(): {
+        message: string;
+    };
+    toJSON(): string;
+    toString(): string;
+    inspect(): string;
+}
+//# sourceMappingURL=message.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../../../lib/bitcore/message.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAE5C,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAKtC,qBAAa,OAAO;IAClB,OAAO,CAAC,QAAQ,CAAQ;IACjB,KAAK,CAAC,EAAE,MAAM,CAAA;IAKrB,MAAM,CAAC,QAAQ,CAAC,WAAW,sBAA2C;gBAE1D,OAAO,EAAE,MAAM;IAW3B,SAAS,IAAI,MAAM;IAiBnB,OAAO,CAAC,KAAK;IAkBb,IAAI,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM;IAQpC,OAAO,CAAC,OAAO;IAoBf,MAAM,CAAC,cAAc,EAAE,OAAO,GAAG,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,OAAO;IAoC1E,gBAAgB,CACd,cAAc,EAAE,OAAO,GAAG,MAAM,EAChC,eAAe,EAAE,MAAM,GACtB,MAAM;IAmCT,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAOvC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO;IAU/C,QAAQ,IAAI;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE;IAO/B,MAAM,IAAI,MAAM;IAOhB,QAAQ,IAAI,MAAM;IAOlB,OAAO,IAAI,MAAM;CAGlB"}

package/dist/lib/bitcore/message.js

@@ -0,0 +1,112 @@
+import { Hash } from './crypto/hash.js';
+import { ECDSA } from './crypto/ecdsa.js';
+import { Signature } from './crypto/signature.js';
+import { PrivateKey } from './privatekey.js';
+import { PublicKey } from './publickey.js';
+import { Address } from './address.js';
+import { JSUtil } from './util/js.js';
+import { BufferWriter } from './encoding/bufferwriter.js';
+import { Preconditions } from './util/preconditions.js';
+export class Message {
+    _message;
+    error;
+    static MAGIC_BYTES = Buffer.from('Bitcoin Signed Message:\n');
+    constructor(message) {
+        Preconditions.checkArgument(typeof message === 'string', 'First argument should be a string');
+        this._message = message;
+    }
+    magicHash() {
+        const prefix1 = BufferWriter.varintBufNum(Message.MAGIC_BYTES.length);
+        const messageBuffer = Buffer.from(this._message);
+        const prefix2 = BufferWriter.varintBufNum(messageBuffer.length);
+        const buf = Buffer.concat([
+            prefix1,
+            Message.MAGIC_BYTES,
+            prefix2,
+            messageBuffer,
+        ]);
+        const hash = Hash.sha256sha256(buf);
+        return hash;
+    }
+    _sign(privateKey) {
+        Preconditions.checkArgument(privateKey instanceof PrivateKey, 'First argument should be an instance of PrivateKey');
+        const hash = this.magicHash();
+        const ecdsa = new ECDSA();
+        ecdsa.hashbuf = hash;
+        ecdsa.privkey = privateKey;
+        ecdsa.pubkey = privateKey.toPublicKey();
+        ecdsa.signRandomK();
+        ecdsa.calci();
+        return ecdsa.sig;
+    }
+    sign(privateKey) {
+        const signature = this._sign(privateKey);
+        return signature.toCompact().toString('base64');
+    }
+    _verify(publicKey, signature) {
+        Preconditions.checkArgument(publicKey instanceof PublicKey, 'First argument should be an instance of PublicKey');
+        Preconditions.checkArgument(signature instanceof Signature, 'Second argument should be an instance of Signature');
+        const hash = this.magicHash();
+        const verified = ECDSA.verify(hash, signature, publicKey);
+        if (!verified) {
+            this.error = 'The signature was invalid';
+        }
+        return verified;
+    }
+    verify(bitcoinAddress, signatureString) {
+        Preconditions.checkArgument(!!bitcoinAddress, 'bitcoinAddress is required');
+        Preconditions.checkArgument(!!(signatureString && typeof signatureString === 'string'), 'signatureString is required');
+        const address = typeof bitcoinAddress === 'string'
+            ? Address.fromString(bitcoinAddress)
+            : bitcoinAddress;
+        const signature = Signature.fromCompact(Buffer.from(signatureString, 'base64'));
+        const ecdsa = new ECDSA();
+        ecdsa.hashbuf = this.magicHash();
+        ecdsa.sig = signature;
+        const publicKey = ecdsa.toPublicKey();
+        const signatureAddress = Address.fromPublicKey(publicKey, address.network);
+        if (address.toString() !== signatureAddress.toString()) {
+            this.error = 'The signature did not match the message digest';
+            return false;
+        }
+        return this._verify(publicKey, signature);
+    }
+    recoverPublicKey(bitcoinAddress, signatureString) {
+        Preconditions.checkArgument(!!bitcoinAddress, 'bitcoinAddress is required');
+        Preconditions.checkArgument(!!(signatureString && typeof signatureString === 'string'), 'signatureString is required');
+        const address = typeof bitcoinAddress === 'string'
+            ? Address.fromString(bitcoinAddress)
+            : bitcoinAddress;
+        const signature = Signature.fromCompact(Buffer.from(signatureString, 'base64'));
+        const ecdsa = new ECDSA();
+        ecdsa.hashbuf = this.magicHash();
+        ecdsa.sig = signature;
+        const publicKey = ecdsa.toPublicKey();
+        const signatureAddress = Address.fromPublicKey(publicKey, address.network);
+        if (address.toString() !== signatureAddress.toString()) {
+            this.error = 'The signature did not match the message digest';
+        }
+        return publicKey.toString();
+    }
+    static fromString(str) {
+        return new Message(str);
+    }
+    static fromJSON(json) {
+        if (typeof json === 'string' && JSUtil.isValidJSON(json)) {
+            json = JSON.parse(json);
+        }
+        return new Message(json.message);
+    }
+    toObject() {
+        return { message: this._message };
+    }
+    toJSON() {
+        return JSON.stringify(this.toObject());
+    }
+    toString() {
+        return this._message;
+    }
+    inspect() {
+        return '<Message: ' + this.toString() + '>';
+    }
+}