xpi-ts 0.2.13 → 0.2.15

package/dist/esm/lib/bitcore/mnemonic/words/index.js

@@ -1,4 +1,6 @@
 import { english } from './english.js';
+import { french } from './french.js';
 export const Words = {
     ENGLISH: english,
+    FRENCH: french,
 };

package/dist/esm/lib/bitcore/musig2/session.js

@@ -1,7 +1,8 @@
-import { Signature, Random, Hash } from '../crypto/index.js';
-import { musigKeyAgg, musigNonceGen, musigNonceAgg, musigPartialSign, musigPartialSigVerify, musigSigAgg, } from '../crypto/musig2.js';
-import { verifyTaprootKeyPathMuSigPartial } from '../taproot/musig2.js';
-import { calculateTapTweak, tweakPublicKey } from '../taproot.js';
+import { Signature, Random, Hash } from '../crypto/index';
+import { muSig2KeyAgg, muSig2NonceGen, muSig2NonceAgg, muSig2PartialSign, muSig2PartialSigVerify, muSig2SigAgg, } from '../crypto/musig2';
+import { verifyTaprootKeyPathMuSigPartial } from '../taproot/musig2';
+import { calculateTapTweak, tweakPublicKey } from '../script/taproot';
+import { BufferUtil } from '../util/buffer';
 export var MuSigSessionPhase;
 (function (MuSigSessionPhase) {
     MuSigSessionPhase["INIT"] = "init";
@@ -18,7 +19,7 @@ export class MuSigSessionManager {
         if (!message || message.length === 0) {
             throw new Error('Cannot create MuSig2 session with empty message');
         }
-        const keyAggContext = musigKeyAgg(signers);
+        const keyAggContext = muSig2KeyAgg(signers);
         const myPubKey = myPrivateKey.publicKey;
         const myIndex = keyAggContext.pubkeys.findIndex(signer => signer.toString() === myPubKey.toString());
         if (myIndex === -1) {
@@ -49,7 +50,7 @@ export class MuSigSessionManager {
             throw new Error('Nonces already generated for this session. NEVER reuse nonces!');
         }
         const entropy = extraInput !== undefined ? extraInput : Random.getRandomBuffer(32);
-        const nonce = musigNonceGen(privateKey, session.keyAggContext.aggregatedPubKey, session.message, entropy);
+        const nonce = muSig2NonceGen(privateKey, session.keyAggContext.aggregatedPubKey, session.message, entropy);
         session.mySecretNonce = nonce;
         session.myPublicNonce = nonce.publicNonces;
         session.phase = MuSigSessionPhase.NONCE_EXCHANGE;
@@ -97,7 +98,7 @@ export class MuSigSessionManager {
             session.phase !== MuSigSessionPhase.PARTIAL_SIG_EXCHANGE) {
             throw new Error(`Cannot create partial signature in phase ${session.phase}. Must be in NONCE_EXCHANGE or PARTIAL_SIG_EXCHANGE.`);
         }
-        const partialSig = musigPartialSign(session.mySecretNonce, privateKey, session.keyAggContext, session.myIndex, session.aggregatedNonce, session.message);
+        const partialSig = muSig2PartialSign(session.mySecretNonce, privateKey, session.keyAggContext, session.myIndex, session.aggregatedNonce, session.message);
         session.myPartialSig = partialSig;
         session.phase = MuSigSessionPhase.PARTIAL_SIG_EXCHANGE;
         session.updatedAt = Date.now();
@@ -123,12 +124,12 @@ export class MuSigSessionManager {
         }
         let isValid;
         if (session.metadata?.inputScriptType === 'taproot') {
-            const merkleRoot = Buffer.alloc(32);
+            const merkleRoot = BufferUtil.alloc(32);
             const tweak = calculateTapTweak(session.keyAggContext.aggregatedPubKey, merkleRoot);
             isValid = verifyTaprootKeyPathMuSigPartial(partialSig, publicNonce, session.signers[signerIndex], session.keyAggContext, signerIndex, session.aggregatedNonce, session.message, tweak);
         }
         else {
-            isValid = musigPartialSigVerify(partialSig, publicNonce, session.signers[signerIndex], session.keyAggContext, signerIndex, session.aggregatedNonce, session.message);
+            isValid = muSig2PartialSigVerify(partialSig, publicNonce, session.signers[signerIndex], session.keyAggContext, signerIndex, session.aggregatedNonce, session.message);
         }
         if (!isValid) {
             this._abortSession(session, `Invalid partial signature from signer ${signerIndex}`);
@@ -169,11 +170,11 @@ export class MuSigSessionManager {
         };
     }
     _generateSessionId(signers, message, createdAt = Date.now(), entropy = Random.getRandomBuffer(16)) {
-        const signersHash = Hash.sha256(Buffer.concat(signers.map(s => s.toBuffer())));
+        const signersHash = Hash.sha256(BufferUtil.concat(signers.map(s => s.toBuffer())));
         const messageHash = Hash.sha256(message);
-        const timestampBuffer = Buffer.alloc(8);
-        timestampBuffer.writeBigInt64BE(BigInt(createdAt));
-        const combined = Buffer.concat([
+        const timestampBuffer = BufferUtil.alloc(8);
+        timestampBuffer.writeBigInt64BE(createdAt, 0);
+        const combined = BufferUtil.concat([
             signersHash,
             messageHash,
             timestampBuffer,
@@ -205,7 +206,7 @@ export class MuSigSessionManager {
                 allNonces.push(nonce);
             }
         }
-        session.aggregatedNonce = musigNonceAgg(allNonces);
+        session.aggregatedNonce = muSig2NonceAgg(allNonces);
         session.updatedAt = Date.now();
     }
     _finalizeSignature(session) {
@@ -231,7 +232,7 @@ export class MuSigSessionManager {
         let pubKeyForAggregation = session.keyAggContext.aggregatedPubKey;
         let pubKeyForNonceCoef = session.keyAggContext.aggregatedPubKey;
         if (session.metadata?.inputScriptType === 'taproot') {
-            const merkleRoot = Buffer.alloc(32);
+            const merkleRoot = BufferUtil.alloc(32);
             const commitment = tweakPublicKey(session.keyAggContext.aggregatedPubKey, merkleRoot);
             pubKeyForAggregation = commitment;
             pubKeyForNonceCoef = commitment;
@@ -241,7 +242,7 @@ export class MuSigSessionManager {
             : session.metadata?.inputScriptType === 'taproot'
                 ? Signature.SIGHASH_ALL | Signature.SIGHASH_LOTUS
                 : undefined;
-        session.finalSignature = musigSigAgg(allPartialSigs, session.aggregatedNonce, session.message, pubKeyForAggregation, sighashType, pubKeyForNonceCoef);
+        session.finalSignature = muSig2SigAgg(allPartialSigs, session.aggregatedNonce, session.message, pubKeyForAggregation, sighashType, pubKeyForNonceCoef);
         session.phase = MuSigSessionPhase.COMPLETE;
         session.updatedAt = Date.now();
     }

package/dist/esm/lib/bitcore/musig2/signer.js

@@ -1,11 +1,12 @@
 import { Signature } from '../crypto/signature.js';
 import { Hash } from '../crypto/hash.js';
 import { Random } from '../crypto/random.js';
-import { musigKeyAgg, musigNonceGen, musigNonceAgg, musigPartialSign, musigPartialSigVerify, musigSigAgg, } from '../crypto/musig2.js';
+import { muSig2KeyAgg, muSig2NonceGen, muSig2NonceAgg, muSig2PartialSign, muSig2PartialSigVerify, muSig2SigAgg, } from '../crypto/musig2.js';
 import { MuSigSessionManager, } from './session.js';
-import { buildMuSigTaprootKey, signTaprootKeyPathWithMuSig2, } from '../taproot/musig2.js';
+import { buildMuSig2TaprootKey, signTaprootKeyPathWithMuSig2, } from '../taproot/musig2.js';
 import { sighash } from '../transaction/sighash.js';
 import { BN } from '../crypto/bn.js';
+import { BufferUtil } from '../util';
 export class MuSig2Signer {
     config;
     sessionManager;
@@ -25,11 +26,11 @@ export class MuSig2Signer {
     }
     prepare(message, useSession = false) {
         const normalizedMessage = this._normalizeMessage(message);
-        const keyAggContext = musigKeyAgg(this.config.signers);
+        const keyAggContext = muSig2KeyAgg(this.config.signers);
         const entropy = this.config.extraInput !== undefined
             ? this.config.extraInput
             : Random.getRandomBuffer(32);
-        const nonce = musigNonceGen(this.config.myPrivateKey, keyAggContext.aggregatedPubKey, normalizedMessage, entropy);
+        const nonce = muSig2NonceGen(this.config.myPrivateKey, keyAggContext.aggregatedPubKey, normalizedMessage, entropy);
         const myIndex = keyAggContext.pubkeys.findIndex(s => s.toString() === this.config.myPrivateKey.publicKey.toString());
         const result = {
             keyAggContext,
@@ -49,17 +50,17 @@ export class MuSig2Signer {
     }
     createPartialSignature(prepare, allPublicNonces, message) {
         const normalizedMessage = this._normalizeMessage(message);
-        const aggregatedNonce = musigNonceAgg(allPublicNonces);
+        const aggregatedNonce = muSig2NonceAgg(allPublicNonces);
         const secretNonce = {
             secretNonces: prepare.mySecretNonces,
             publicNonces: prepare.myPublicNonces,
         };
-        return musigPartialSign(secretNonce, this.config.myPrivateKey, prepare.keyAggContext, prepare.myIndex, aggregatedNonce, normalizedMessage);
+        return muSig2PartialSign(secretNonce, this.config.myPrivateKey, prepare.keyAggContext, prepare.myIndex, aggregatedNonce, normalizedMessage);
     }
     verifyPartialSignature(partialSig, publicNonce, publicKey, signerIndex, prepare, allPublicNonces, message) {
         const normalizedMessage = this._normalizeMessage(message);
-        const aggregatedNonce = musigNonceAgg(allPublicNonces);
-        return musigPartialSigVerify(partialSig, publicNonce, publicKey, prepare.keyAggContext, signerIndex, aggregatedNonce, normalizedMessage);
+        const aggregatedNonce = muSig2NonceAgg(allPublicNonces);
+        return muSig2PartialSigVerify(partialSig, publicNonce, publicKey, prepare.keyAggContext, signerIndex, aggregatedNonce, normalizedMessage);
     }
     sign(prepare, allPublicNonces, message, allPartialSigs) {
         if (allPublicNonces.length !== this.config.signers.length) {
@@ -69,17 +70,17 @@ export class MuSig2Signer {
             throw new Error(`Invalid number of partial signatures: expected ${this.config.signers.length}, got ${allPartialSigs.length}`);
         }
         const normalizedMessage = this._normalizeMessage(message);
-        const aggregatedNonce = musigNonceAgg(allPublicNonces);
-        const signature = musigSigAgg(allPartialSigs, aggregatedNonce, normalizedMessage, prepare.keyAggContext.aggregatedPubKey);
+        const aggregatedNonce = muSig2NonceAgg(allPublicNonces);
+        const signature = muSig2SigAgg(allPartialSigs, aggregatedNonce, normalizedMessage, prepare.keyAggContext.aggregatedPubKey);
         return {
             signature,
             aggregatedPubKey: prepare.keyAggContext.aggregatedPubKey,
             isAggregator: true,
         };
     }
-    prepareTaproot(state) {
-        const result = buildMuSigTaprootKey(this.config.signers, state);
-        const keyAggContext = musigKeyAgg(this.config.signers);
+    prepareTaproot() {
+        const result = buildMuSig2TaprootKey(this.config.signers);
+        const keyAggContext = muSig2KeyAgg(this.config.signers);
         return {
             ...result,
             keyAggContext,
@@ -90,11 +91,11 @@ export class MuSig2Signer {
         const satoshisBN = new BN(amount);
         const sighashBuffer = sighash(transaction, sigType, inputIndex, prepare.script, satoshisBN);
         const normalizedSighash = this._normalizeMessage(sighashBuffer);
-        const aggregatedNonce = musigNonceAgg(allPublicNonces);
+        const aggregatedNonce = muSig2NonceAgg(allPublicNonces);
         const entropy = this.config.extraInput !== undefined
             ? this.config.extraInput
             : Random.getRandomBuffer(32);
-        const nonce = musigNonceGen(this.config.myPrivateKey, prepare.keyAggContext.aggregatedPubKey, normalizedSighash, entropy);
+        const nonce = muSig2NonceGen(this.config.myPrivateKey, prepare.keyAggContext.aggregatedPubKey, normalizedSighash, entropy);
         const myIndex = prepare.keyAggContext.pubkeys.findIndex(s => s.toString() === this.config.myPrivateKey.publicKey.toString());
         return signTaprootKeyPathWithMuSig2(nonce, this.config.myPrivateKey, prepare.keyAggContext, myIndex, aggregatedNonce, normalizedSighash, prepare.tweak);
     }
@@ -103,8 +104,8 @@ export class MuSig2Signer {
         const satoshisBN = new BN(amount);
         const sighashBuffer = sighash(transaction, sigType, inputIndex, prepare.script, satoshisBN);
         const normalizedSighash = this._normalizeMessage(sighashBuffer);
-        const aggregatedNonce = musigNonceAgg(allPublicNonces);
-        return musigSigAgg(allPartialSigs, aggregatedNonce, normalizedSighash, prepare.commitment, undefined, prepare.commitment);
+        const aggregatedNonce = muSig2NonceAgg(allPublicNonces);
+        return muSig2SigAgg(allPartialSigs, aggregatedNonce, normalizedSighash, prepare.commitment, undefined, prepare.commitment);
     }
     createSession(message, metadata) {
         if (!this.sessionManager) {
@@ -133,7 +134,7 @@ export class MuSig2Signer {
     }
     _normalizeMessage(message) {
         if (typeof message === 'string') {
-            return Hash.sha256(Buffer.from(message, 'utf8'));
+            return Hash.sha256(BufferUtil.from(message, 'utf8'));
         }
         if (message.length === 32) {
             return message;

package/dist/esm/lib/bitcore/networks.js

@@ -1,3 +1,4 @@
+import { BufferUtil } from './util/buffer';
 function prefixToArray(prefix) {
     const result = [];
     for (let i = 0; i < prefix.length; i++) {
@@ -48,7 +49,7 @@ export const livenet = new Network({
     scripthash: 5,
     xpubkey: 0x0488b21e,
     xprivkey: 0x0488ade4,
-    networkMagic: Buffer.from('ece7eff3', 'hex'),
+    networkMagic: BufferUtil.from('ece7eff3', 'hex'),
     port: 10605,
     dnsSeeds: ['seed.lotusia.org'],
     prefixArray: prefixToArray('bitcoincash'),
@@ -63,7 +64,7 @@ export const testnet = new Network({
     scripthash: 0xc4,
     xpubkey: 0x043587cf,
     xprivkey: 0x04358394,
-    networkMagic: Buffer.from('ecf4f3f4', 'hex'),
+    networkMagic: BufferUtil.from('ecf4f3f4', 'hex'),
     port: 11605,
     dnsSeeds: ['seed.lotusia.org'],
     prefixArray: prefixToArray('bchtest'),
@@ -78,7 +79,7 @@ export const regtest = new Network({
     scripthash: 0xc4,
     xpubkey: 0x043587cf,
     xprivkey: 0x04358394,
-    networkMagic: Buffer.from('ecf2e5e7', 'hex'),
+    networkMagic: BufferUtil.from('ecf2e5e7', 'hex'),
     port: 12605,
     dnsSeeds: [],
     prefixArray: prefixToArray('bchreg'),

package/dist/esm/lib/bitcore/opcode.js

@@ -1,5 +1,5 @@
-import { Preconditions } from './util/preconditions.js';
-import { JSUtil } from './util/js.js';
+import { Preconditions as $ } from './util/preconditions';
+import { JSUtil, BufferUtil } from './util';
 export class Opcode {
     num;
     constructor(num) {
@@ -18,12 +18,12 @@ export class Opcode {
         }
     }
     static fromBuffer(buf) {
-        Preconditions.checkArgument(Buffer.isBuffer(buf), 'buf', 'Must be a Buffer');
-        Preconditions.checkArgument(buf.length > 0, 'buf', 'Buffer cannot be empty');
+        $.checkArgument(BufferUtil.isBuffer(buf), 'buf', 'Must be a Buffer');
+        $.checkArgument(buf.length > 0, 'buf', 'Buffer cannot be empty');
         return new Opcode(buf[0]);
     }
     toBuffer() {
-        return Buffer.from([this.num]);
+        return BufferUtil.from([this.num]);
     }
     toString() {
         return this.num.toString();
@@ -147,6 +147,8 @@ export class Opcode {
     static OP_CHECKDATASIG = 186;
     static OP_CHECKDATASIGVERIFY = 187;
     static OP_REVERSEBYTES = 188;
+    static OP_MULPOW2 = 189;
+    static OP_RAWLEFTBITSHIFT = 190;
     static map = {
         OP_0: 0,
         OP_FALSE: 0,
@@ -266,5 +268,7 @@ export class Opcode {
         OP_CHECKDATASIG: 186,
         OP_CHECKDATASIGVERIFY: 187,
         OP_REVERSEBYTES: 188,
+        OP_MULPOW2: 189,
+        OP_RAWLEFTBITSHIFT: 190,
     };
 }

package/dist/esm/lib/bitcore/privatekey.js

@@ -1,11 +1,12 @@
-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';
+import { BN } from './crypto/bn';
+import { Point } from './crypto/point';
+import { Random } from './crypto/random';
+import { Base58Check } from './encoding/base58check';
+import { BufferUtil } from './util/buffer';
+import { JSUtil } from './util/js';
+import { get as getNetwork, defaultNetwork, } from './networks';
+import { PublicKey } from './publickey';
+import { Address } from './address';
 export class PrivateKey {
     bn;
     compressed;
@@ -45,7 +46,7 @@ export class PrivateKey {
         else if (data instanceof BN) {
             info.bn = data;
         }
-        else if (Buffer.isBuffer(data)) {
+        else if (BufferUtil.isBuffer(data)) {
             const bufferInfo = PrivateKey._transformBuffer(data, network);
             Object.assign(info, bufferInfo);
         }
@@ -54,7 +55,7 @@ export class PrivateKey {
             'compressed' in data &&
             'buf' in data) {
             info.compressed = data.compressed;
-            info.bn = new BN(data.buf, 'be');
+            info.bn = BN.fromBuffer(data.buf);
         }
         else if (typeof data === 'object' &&
             data !== null &&
@@ -69,7 +70,7 @@ export class PrivateKey {
         }
         else if (typeof data === 'string') {
             if (JSUtil.isHexa(data)) {
-                info.bn = new BN(data, 16);
+                info.bn = BN.fromString(data, 'hex');
             }
             else {
                 const wifInfo = PrivateKey._transformWIF(data, network);
@@ -84,8 +85,7 @@ export class PrivateKey {
     static _getRandomBN() {
         let bn;
         do {
-            const privbuf = Random.getRandomBuffer(32);
-            bn = new BN(privbuf, 'be');
+            bn = BN.fromBuffer(Random.getRandomBuffer(32));
         } while (!bn.lt(Point.getN()));
         return bn;
     }
@@ -121,14 +121,14 @@ export class PrivateKey {
         else {
             throw new Error('Length of buffer must be 33 (uncompressed) or 34 (compressed)');
         }
-        info.bn = new BN(buf.subarray(1, 32 + 1), 'be');
+        info.bn = BN.fromBuffer(buf.slice(1, 32 + 1));
         return info;
     }
     static _transformBNBuffer(buf, network) {
         network ||= defaultNetwork;
         return {
             network: getNetwork(network),
-            bn: new BN(buf, 'be'),
+            bn: BN.fromBuffer(buf),
             compressed: true,
         };
     }
@@ -136,7 +136,7 @@ export class PrivateKey {
         return PrivateKey._transformBuffer(Base58Check.decode(str), network);
     }
     static _transformObject(json) {
-        const bn = new BN(json.bn, 16);
+        const bn = BN.fromString(json.bn, 'hex');
         const network = getNetwork(json.network);
         if (!network) {
             throw new Error(`Invalid network: ${json.network}`);
@@ -190,16 +190,16 @@ export class PrivateKey {
     toWIF(compressed = true) {
         let buf;
         if (compressed) {
-            buf = Buffer.concat([
-                Buffer.from([this.network.privatekey]),
-                this.bn.toArrayLike(Buffer, 'be', 32),
-                Buffer.from([0x01]),
+            buf = BufferUtil.concat([
+                BufferUtil.from([this.network.privatekey]),
+                this.bn.toBuffer({ size: 32 }),
+                BufferUtil.from([0x01]),
             ]);
         }
         else {
-            buf = Buffer.concat([
-                Buffer.from([this.network.privatekey]),
-                this.bn.toArrayLike(Buffer, 'be', 32),
+            buf = BufferUtil.concat([
+                BufferUtil.from([this.network.privatekey]),
+                this.bn.toBuffer({ size: 32 }),
             ]);
         }
         return Base58Check.encode(buf);
@@ -208,10 +208,10 @@ export class PrivateKey {
         return this.bn;
     }
     toBuffer() {
-        return this.bn.toArrayLike(Buffer, 'be', 32);
+        return this.bn.toBuffer({ size: 32 });
     }
     toBufferNoPadding() {
-        return this.bn.toArrayLike(Buffer, 'be');
+        return this.bn.toBuffer();
     }
     toPublicKey() {
         if (!this._pubkey) {

package/dist/esm/lib/bitcore/publickey.js

@@ -1,14 +1,23 @@
-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';
+import { BN } from './crypto/bn';
+import { Point } from './crypto/point';
+import { Hash } from './crypto/hash';
+import { BufferUtil } from './util/buffer';
+import { JSUtil } from './util/js';
+import { get as getNetwork, defaultNetwork, } from './networks';
+import { PrivateKey } from './privatekey';
+import { Address } from './address';
+export const PUBKEY_PREFIX_EVEN = 0x02;
+export const PUBKEY_PREFIX_ODD = 0x03;
+export const PUBKEY_PREFIX_UNCOMPRESSED = 0x04;
 export class PublicKey {
     point;
     compressed;
     network;
+    static PrefixOddY = BufferUtil.from([PUBKEY_PREFIX_ODD]);
+    static PrefixEvenY = BufferUtil.from([PUBKEY_PREFIX_EVEN]);
+    static PrefixUncompressed = BufferUtil.from([
+        PUBKEY_PREFIX_UNCOMPRESSED,
+    ]);
     constructor(data, extra) {
         if (data instanceof PublicKey) {
             return data;
@@ -40,7 +49,7 @@ export class PublicKey {
             Object.assign(info, objectInfo);
         }
         else if (typeof data === 'string') {
-            const derInfo = PublicKey._transformDER(Buffer.from(data, 'hex'));
+            const derInfo = PublicKey._transformDER(BufferUtil.from(data, 'hex'));
             Object.assign(info, derInfo);
         }
         else if (PublicKey._isBuffer(data)) {
@@ -66,7 +75,7 @@ export class PublicKey {
         return param instanceof PrivateKey;
     }
     static _isBuffer(param) {
-        return Buffer.isBuffer(param) || param instanceof Uint8Array;
+        return BufferUtil.isBuffer(param) || param instanceof Uint8Array;
     }
     static _transformPrivateKey(privkey) {
         if (!PublicKey._isPrivateKey(privkey)) {
@@ -88,28 +97,23 @@ export class PublicKey {
         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 (buf[0] === PUBKEY_PREFIX_UNCOMPRESSED ||
+            (!strict && (buf[0] === 0x06 || buf[0] === 0x07))) {
+            xbuf = buf.slice(1, 33);
+            ybuf = buf.slice(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');
+            x = BN.fromBuffer(xbuf);
+            y = BN.fromBuffer(ybuf);
             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);
+        else if (buf[0] === PUBKEY_PREFIX_ODD || buf[0] === PUBKEY_PREFIX_EVEN) {
+            xbuf = buf.slice(1);
+            x = BN.fromBuffer(xbuf);
+            const isOdd = buf[0] === PUBKEY_PREFIX_ODD;
+            const xInfo = PublicKey._transformX(isOdd, x);
             point = xInfo.point;
             compressed = true;
         }
@@ -131,8 +135,8 @@ export class PublicKey {
         };
     }
     static _transformObject(json) {
-        const x = new BN(json.x, 16);
-        const y = new BN(json.y, 16);
+        const x = BN.fromString(json.x, 'hex');
+        const y = BN.fromString(json.y, 'hex');
         const point = new Point(x, y);
         return {
             point: point,
@@ -170,7 +174,7 @@ export class PublicKey {
         });
     }
     static fromString(str, encoding) {
-        const buf = Buffer.from(str, encoding || 'hex');
+        const buf = BufferUtil.from(str, encoding || 'hex');
         const info = PublicKey._transformDER(buf);
         return new PublicKey(info.point, {
             compressed: info.compressed,
@@ -199,8 +203,8 @@ export class PublicKey {
     }
     toObject() {
         return {
-            x: this.point.getX().toString(16).padStart(64, '0'),
-            y: this.point.getY().toString(16).padStart(64, '0'),
+            x: this.point.x.toString(16).padStart(64, '0'),
+            y: this.point.y.toString(16).padStart(64, '0'),
             compressed: this.compressed,
         };
     }
@@ -208,30 +212,30 @@ export class PublicKey {
         return this.toObject();
     }
     toBigNumber() {
-        return this.point.getX();
+        return this.point.x;
     }
     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);
+        const x = this.point.x;
+        const y = this.point.y;
+        const xbuf = x.toBuffer({ size: 32 });
+        const ybuf = y.toBuffer({ size: 32 });
         let prefix;
         if (!this.compressed) {
-            prefix = Buffer.from([0x04]);
-            return Buffer.concat([prefix, xbuf, ybuf]);
+            prefix = BufferUtil.from([0x04]);
+            return BufferUtil.concat([prefix, xbuf, ybuf]);
         }
         else {
-            const odd = y.mod(new BN(2)).eq(new BN(1));
+            const odd = y.mod(new BN(2)).eq(BN.One);
             if (odd) {
-                prefix = Buffer.from([0x03]);
+                prefix = PublicKey.PrefixOddY;
             }
             else {
-                prefix = Buffer.from([0x02]);
+                prefix = PublicKey.PrefixEvenY;
             }
-            return Buffer.concat([prefix, xbuf]);
+            return BufferUtil.concat([prefix, xbuf]);
         }
     }
     _getID() {
@@ -247,7 +251,7 @@ export class PublicKey {
         return `<PublicKey: ${this.toString()}${this.compressed ? '' : ', uncompressed'}>`;
     }
     addScalar(scalar) {
-        const scalarBN = Buffer.isBuffer(scalar) ? new BN(scalar) : scalar;
+        const scalarBN = BufferUtil.isBuffer(scalar) ? new BN(scalar) : scalar;
         const G = Point.getG();
         const tweakPoint = G.mul(scalarBN);
         const tweakedPoint = this.point.add(tweakPoint);

package/dist/esm/lib/bitcore/script/interpreter/condition-stack.js

@@ -0,0 +1,37 @@
+export class ConditionStack {
+    static NO_FALSE = 0xffffffff;
+    _size = 0;
+    _firstFalsePos = ConditionStack.NO_FALSE;
+    isEmpty() {
+        return this._size === 0;
+    }
+    allTrue() {
+        return this._firstFalsePos === ConditionStack.NO_FALSE;
+    }
+    pushBack(value) {
+        if (this._firstFalsePos === ConditionStack.NO_FALSE && !value) {
+            this._firstFalsePos = this._size;
+        }
+        this._size++;
+    }
+    popBack() {
+        if (this._size === 0) {
+            throw new Error('ConditionStack: pop from empty stack');
+        }
+        this._size--;
+        if (this._firstFalsePos === this._size) {
+            this._firstFalsePos = ConditionStack.NO_FALSE;
+        }
+    }
+    toggleTop() {
+        if (this._size === 0) {
+            throw new Error('ConditionStack: toggle on empty stack');
+        }
+        if (this._firstFalsePos === ConditionStack.NO_FALSE) {
+            this._firstFalsePos = this._size - 1;
+        }
+        else if (this._firstFalsePos === this._size - 1) {
+            this._firstFalsePos = ConditionStack.NO_FALSE;
+        }
+    }
+}

package/dist/esm/lib/bitcore/script/interpreter/index.js

@@ -0,0 +1,4 @@
+export { MAX_SCRIPT_ELEMENT_SIZE, MAX_OPS_PER_SCRIPT, MAX_PUBKEYS_PER_MULTISIG, MAX_SCRIPT_SIZE, MAX_STACK_SIZE, MAX_NUM2BIN_SIZE, LOCKTIME_THRESHOLD, SCRIPTNUM_MAX_ELEMENT_SIZE, STANDARD_SCRIPT_VERIFY_FLAGS, ScriptFlags, ScriptError, NULL_SIGNATURE_CHECKER, } from './types';
+export { ScriptNum, ScriptNumError } from './script-num';
+export { ConditionStack } from './condition-stack';
+export { evalScript, verifyScript, Interpreter } from './interpreter';