xpi-ts 0.2.13 → 0.2.15

package/dist/cjs/lib/bitcore/transaction/unspentoutput.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnspentOutput = void 0;
-const preconditions_js_1 = require("../util/preconditions.js");
-const js_js_1 = require("../util/js.js");
-const script_js_1 = require("../script.js");
-const address_js_1 = require("../address.js");
-const publickey_js_1 = require("../publickey.js");
-const unit_js_1 = require("../unit.js");
+const preconditions_1 = require("../util/preconditions");
+const buffer_1 = require("../util/buffer");
+const js_1 = require("../util/js");
+const script_1 = require("../script");
+const address_1 = require("../address");
+const publickey_1 = require("../publickey");
+const unit_1 = require("../unit");
 class UnspentOutput {
     address;
     txId;
@@ -18,22 +19,22 @@ class UnspentOutput {
     keyAggContext;
     mySignerIndex;
     constructor(data) {
-        preconditions_js_1.Preconditions.checkArgument(typeof data === 'object' && data !== null, 'Must provide an object from where to extract data');
-        const address = data.address ? new address_js_1.Address(data.address) : undefined;
+        preconditions_1.Preconditions.checkArgument(typeof data === 'object' && data !== null, 'Must provide an object from where to extract data');
+        const address = data.address ? new address_1.Address(data.address) : undefined;
         const txId = data.txid || data.txId;
-        if (!txId || !js_js_1.JSUtil.isHexaString(txId) || txId.length > 64) {
+        if (!txId || !js_1.JSUtil.isHexa(txId) || txId.length > 64) {
             throw new Error('Invalid TXID in object: ' + JSON.stringify(data));
         }
         const outputIndex = data.vout !== undefined ? data.vout : data.outputIndex;
         if (typeof outputIndex !== 'number') {
             throw new Error('Invalid outputIndex, received ' + outputIndex);
         }
-        preconditions_js_1.Preconditions.checkArgument(data.scriptPubKey !== undefined || data.script !== undefined, 'Must provide the scriptPubKey for that output!');
-        const script = new script_js_1.Script(data.scriptPubKey || data.script);
-        preconditions_js_1.Preconditions.checkArgument(data.amount !== undefined || data.satoshis !== undefined, 'Must provide an amount for the output');
+        preconditions_1.Preconditions.checkArgument(data.scriptPubKey !== undefined || data.script !== undefined, 'Must provide the scriptPubKey for that output!');
+        const script = new script_1.Script(data.scriptPubKey || data.script);
+        preconditions_1.Preconditions.checkArgument(data.amount !== undefined || data.satoshis !== undefined, 'Must provide an amount for the output');
         let amount;
         if (data.amount !== undefined) {
-            amount = Number(unit_js_1.Unit.fromXPI(data.amount).toSatoshis());
+            amount = Number(unit_1.Unit.fromXPI(data.amount).toSatoshis());
         }
         else if (data.satoshis !== undefined) {
             amount =
@@ -44,21 +45,21 @@ class UnspentOutput {
         else {
             throw new Error('No amount provided');
         }
-        preconditions_js_1.Preconditions.checkArgument(typeof amount === 'number', 'Amount must be a number');
+        preconditions_1.Preconditions.checkArgument(typeof amount === 'number', 'Amount must be a number');
         this.address = address;
         this.txId = txId;
         this.outputIndex = outputIndex;
         this.script = script;
         this.satoshis = amount;
         if (data.internalPubKey) {
-            if (data.internalPubKey instanceof publickey_js_1.PublicKey) {
+            if (data.internalPubKey instanceof publickey_1.PublicKey) {
                 this.internalPubKey = data.internalPubKey;
             }
-            else if (Buffer.isBuffer(data.internalPubKey)) {
-                this.internalPubKey = new publickey_js_1.PublicKey(data.internalPubKey);
+            else if (buffer_1.BufferUtil.isBuffer(data.internalPubKey)) {
+                this.internalPubKey = new publickey_1.PublicKey(data.internalPubKey);
             }
             else if (typeof data.internalPubKey === 'string') {
-                this.internalPubKey = new publickey_js_1.PublicKey(data.internalPubKey);
+                this.internalPubKey = new publickey_1.PublicKey(data.internalPubKey);
             }
         }
         this.merkleRoot = data.merkleRoot;
@@ -69,10 +70,10 @@ class UnspentOutput {
         return this.satoshis / 1000000;
     }
     getUnit() {
-        return unit_js_1.Unit.fromSatoshis(this.satoshis);
+        return unit_1.Unit.fromSatoshis(this.satoshis);
     }
     isValid() {
-        return (js_js_1.JSUtil.isHexaString(this.txId) &&
+        return (js_1.JSUtil.isHexa(this.txId) &&
             this.txId.length === 64 &&
             this.outputIndex >= 0 &&
             this.satoshis > 0 &&
@@ -87,7 +88,7 @@ class UnspentOutput {
             txid: this.txId,
             vout: this.outputIndex,
             scriptPubKey: this.script.toBuffer().toString('hex'),
-            amount: unit_js_1.Unit.fromSatoshis(this.satoshis).toXPI(),
+            amount: unit_1.Unit.fromSatoshis(this.satoshis).toXPI(),
         };
     }
     toJSON = this.toObject;
@@ -119,10 +120,13 @@ class UnspentOutput {
         return this.txId + ':' + this.outputIndex;
     }
     isPayToPublicKeyHash() {
-        return this.script.isPayToPublicKeyHash();
+        return this.script.isPublicKeyHashOut();
     }
     isPayToScriptHash() {
-        return this.script.isPayToScriptHash();
+        return this.script.isScriptHashOut();
+    }
+    isPayToTaproot() {
+        return this.script.isTaprootOut();
     }
     getAddress() {
         try {

package/dist/cjs/lib/bitcore/util/bits.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bitsToBytes = bitsToBytes;
+exports.bytesToBits = bytesToBits;
+exports.extractBit = extractBit;
+exports.setBit = setBit;
+function bitsToBytes(bits) {
+    const bytes = new Array(Math.ceil(bits.length / 8)).fill(0);
+    for (let p = 0; p < bits.length; p++) {
+        bytes[p >> 3] |= (bits[p] ? 1 : 0) << (p & 7);
+    }
+    return bytes;
+}
+function bytesToBits(bytes) {
+    const bits = new Array(bytes.length * 8);
+    for (let p = 0; p < bits.length; p++) {
+        bits[p] = (bytes[p >> 3] & (1 << (p & 7))) !== 0;
+    }
+    return bits;
+}
+function extractBit(bytes, position) {
+    return (bytes[position >> 3] & (1 << (position & 7))) !== 0;
+}
+function setBit(bytes, position, value) {
+    const byteIndex = position >> 3;
+    const bitIndex = position & 7;
+    if (value) {
+        bytes[byteIndex] |= 1 << bitIndex;
+    }
+    else {
+        bytes[byteIndex] &= ~(1 << bitIndex);
+    }
+}

package/dist/cjs/lib/bitcore/util/buffer.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EMPTY_BUFFER = exports.NULL_HASH = exports.BufferUtil = void 0;
-const preconditions_js_1 = require("./preconditions.js");
+const buffer_1 = require("buffer/");
 class BufferUtil {
+    static Buffer = buffer_1.Buffer;
     static fill(buffer, value) {
-        preconditions_js_1.Preconditions.checkArgumentType(buffer, 'Buffer', 'buffer');
-        preconditions_js_1.Preconditions.checkArgumentType(value, 'number', 'value');
         const length = buffer.length;
         for (let i = 0; i < length; i++) {
             buffer[i] = value;
@@ -13,23 +12,25 @@ class BufferUtil {
         return buffer;
     }
     static copy(original) {
-        const buffer = Buffer.alloc(original.length);
+        const buffer = buffer_1.Buffer.alloc(original.length);
         original.copy(buffer);
         return buffer;
     }
     static isBuffer(arg) {
-        return Buffer.isBuffer(arg) || arg instanceof Uint8Array;
+        return buffer_1.Buffer.isBuffer(arg) || arg instanceof Uint8Array;
     }
     static emptyBuffer(bytes) {
-        preconditions_js_1.Preconditions.checkArgumentType(bytes, 'number', 'bytes');
-        const result = Buffer.alloc(bytes);
+        const result = buffer_1.Buffer.alloc(bytes);
         for (let i = 0; i < bytes; i++) {
             result.write('\0', i);
         }
         return result;
     }
+    static alloc(size, fill) {
+        return buffer_1.Buffer.alloc(size, fill);
+    }
     static concat(list, totalLength) {
-        return Buffer.concat(list, totalLength);
+        return buffer_1.Buffer.concat(list, totalLength);
     }
     static equals(a, b) {
         if (a.length !== b.length) {
@@ -47,34 +48,44 @@ class BufferUtil {
         return BufferUtil.equals(a, b);
     }
     static integerAsSingleByteBuffer(integer) {
-        preconditions_js_1.Preconditions.checkArgumentType(integer, 'number', 'integer');
-        return Buffer.from([integer & 0xff]);
+        return buffer_1.Buffer.from([integer & 0xff]);
     }
     static integerAsBuffer(integer) {
-        preconditions_js_1.Preconditions.checkArgumentType(integer, 'number', 'integer');
         const bytes = [];
         bytes.push((integer >> 24) & 0xff);
         bytes.push((integer >> 16) & 0xff);
         bytes.push((integer >> 8) & 0xff);
         bytes.push(integer & 0xff);
-        return Buffer.from(bytes);
+        return buffer_1.Buffer.from(bytes);
     }
     static integerFromBuffer(buffer) {
-        preconditions_js_1.Preconditions.checkArgumentType(buffer, 'Buffer', 'buffer');
         return (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
     }
     static integerFromSingleByteBuffer(buffer) {
-        preconditions_js_1.Preconditions.checkArgumentType(buffer, 'Buffer', 'buffer');
         return buffer[0];
     }
     static bufferToHex(buffer) {
-        preconditions_js_1.Preconditions.checkArgumentType(buffer, 'Buffer', 'buffer');
         return buffer.toString('hex');
     }
     static reverse(param) {
-        return Buffer.from(param).reverse();
+        return buffer_1.Buffer.from(param).reverse();
+    }
+    static from(data, byteOffsetOrEncoding, length) {
+        if (Array.isArray(data)) {
+            return buffer_1.Buffer.from(data);
+        }
+        if (typeof data === 'string') {
+            return buffer_1.Buffer.from(data, (byteOffsetOrEncoding || 'utf8'));
+        }
+        if (data instanceof ArrayBuffer) {
+            return buffer_1.Buffer.from(data, byteOffsetOrEncoding, length);
+        }
+        return buffer_1.Buffer.from(data);
+    }
+    static compare(buf1, buf2) {
+        return buffer_1.Buffer.compare(buf1, buf2);
     }
 }
 exports.BufferUtil = BufferUtil;
-exports.NULL_HASH = BufferUtil.fill(Buffer.alloc(32), 0);
-exports.EMPTY_BUFFER = Buffer.alloc(0);
+exports.NULL_HASH = BufferUtil.fill(buffer_1.Buffer.alloc(32), 0);
+exports.EMPTY_BUFFER = buffer_1.Buffer.alloc(0);

package/dist/cjs/lib/bitcore/util/js.js

@@ -8,9 +8,6 @@ class JSUtil {
         }
         return /^[0-9a-fA-F]+$/.test(value);
     }
-    static isHexaString(str) {
-        return typeof str === 'string' && /^[0-9a-fA-F]+$/.test(str);
-    }
     static isValidJSON(arg) {
         if (typeof arg !== 'string') {
             return false;

package/dist/cjs/lib/bitcore/util/merkle.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calcTreeWidth = calcTreeWidth;
+exports.calcTreeHeight = calcTreeHeight;
+exports.calcMerkleHash = calcMerkleHash;
+exports.traverseAndBuild = traverseAndBuild;
+const hash_1 = require("../crypto/hash");
+const buffer_1 = require("./buffer");
+function calcTreeWidth(nLeaves, height) {
+    return (nLeaves + (1 << height) - 1) >> height;
+}
+function calcTreeHeight(nLeaves) {
+    let height = 0;
+    while (calcTreeWidth(nLeaves, height) > 1) {
+        height++;
+    }
+    return height;
+}
+function calcMerkleHash(height, pos, hashes, nullHash = buffer_1.BufferUtil.alloc(32)) {
+    if (height === 0) {
+        return hashes[pos];
+    }
+    const left = calcMerkleHash(height - 1, pos * 2, hashes, nullHash);
+    let right = left;
+    if (pos * 2 + 1 < calcTreeWidth(hashes.length, height - 1)) {
+        right = calcMerkleHash(height - 1, pos * 2 + 1, hashes, nullHash);
+    }
+    else {
+        right = nullHash.toString('hex');
+    }
+    return hash_1.Hash.sha256sha256(buffer_1.BufferUtil.concat([
+        buffer_1.BufferUtil.from(left, 'hex'),
+        buffer_1.BufferUtil.from(right, 'hex'),
+    ])).toString('hex');
+}
+function traverseAndBuild(height, pos, nLeaves, hashes, vfMatch, vBits, vHash, nullHash = buffer_1.BufferUtil.alloc(32)) {
+    let fParentOfMatch = false;
+    const startIdx = pos << height;
+    const endIdx = Math.min((pos + 1) << height, nLeaves);
+    for (let p = startIdx; p < endIdx; p++) {
+        fParentOfMatch ||= vfMatch[p];
+    }
+    vBits.push(fParentOfMatch);
+    if (height === 0 || !fParentOfMatch) {
+        vHash.push(calcMerkleHash(height, pos, hashes, nullHash));
+    }
+    else {
+        traverseAndBuild(height - 1, pos * 2, nLeaves, hashes, vfMatch, vBits, vHash, nullHash);
+        if (pos * 2 + 1 < calcTreeWidth(nLeaves, height - 1)) {
+            traverseAndBuild(height - 1, pos * 2 + 1, nLeaves, hashes, vfMatch, vBits, vHash, nullHash);
+        }
+    }
+}

package/dist/cjs/lib/bitcore/util/preconditions.js

@@ -1,33 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Preconditions = void 0;
-const errors_js_1 = require("../errors.js");
+const errors_1 = require("../errors");
+const buffer_1 = require("./buffer");
 class Preconditions {
     static checkState(condition, message) {
         if (!condition) {
-            throw new errors_js_1.BitcoreError.Precondition.InvalidState(message);
+            throw new errors_1.BitcoreError.Precondition.InvalidState(message);
         }
     }
     static checkArgument(condition, argumentName, message, docsPath) {
         if (!condition) {
-            throw new errors_js_1.BitcoreError.Precondition.InvalidArgument(argumentName, message, docsPath);
+            throw new errors_1.BitcoreError.Precondition.InvalidArgument(argumentName, message, docsPath);
         }
     }
     static checkArgumentType(argument, type, argumentName) {
         argumentName = argumentName || '(unknown name)';
         if (typeof type === 'string') {
             if (type === 'Buffer') {
-                if (!Buffer.isBuffer(argument)) {
-                    throw new errors_js_1.BitcoreError.Precondition.InvalidArgumentType(argument, type, argumentName);
+                if (!buffer_1.BufferUtil.isBuffer(argument)) {
+                    throw new errors_1.BitcoreError.Precondition.InvalidArgumentType(argument, type, argumentName);
                 }
             }
             else if (typeof argument !== type) {
-                throw new errors_js_1.BitcoreError.Precondition.InvalidArgumentType(argument, type, argumentName);
+                throw new errors_1.BitcoreError.Precondition.InvalidArgumentType(argument, type, argumentName);
             }
         }
         else {
             if (!(argument instanceof type)) {
-                throw new errors_js_1.BitcoreError.Precondition.InvalidArgumentType(argument, type.name, argumentName);
+                throw new errors_1.BitcoreError.Precondition.InvalidArgumentType(argument, type.name, argumentName);
             }
         }
     }

package/dist/cjs/lib/bitcore/xaddress.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XAddress = void 0;
+const buffer_1 = require("buffer/");
 const preconditions_js_1 = require("./util/preconditions.js");
 const base58_js_1 = require("./encoding/base58.js");
 const bufferwriter_js_1 = require("./encoding/bufferwriter.js");
@@ -8,8 +9,6 @@ const networks_js_1 = require("./networks.js");
 const hash_js_1 = require("./crypto/hash.js");
 const js_js_1 = require("./util/js.js");
 const buffer_js_1 = require("./util/buffer.js");
-const TOKEN_NAME = 'lotus';
-const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
 class XAddress {
     static PayToPublicKeyHash = 'pubkeyhash';
     static PayToScriptHash = 'scripthash';
@@ -18,7 +17,7 @@ class XAddress {
     hashBuffer;
     network;
     type;
-    constructor(data, network, type, prefix = TOKEN_NAME) {
+    constructor(data, network, type, prefix = 'lotus') {
         if (data instanceof XAddress) {
             return data;
         }
@@ -49,7 +48,7 @@ class XAddress {
         if (typeof data === 'string') {
             return XAddress._transformString(data, networkExplicitlyProvided ? network : undefined, type);
         }
-        else if (Buffer.isBuffer(data) || data instanceof Uint8Array) {
+        else if (buffer_1.Buffer.isBuffer(data) || data instanceof Uint8Array) {
             return XAddress._transformBuffer(data, network, type, prefix);
         }
         else if (typeof data === 'object' && data !== null) {
@@ -63,7 +62,7 @@ class XAddress {
         preconditions_js_1.Preconditions.checkArgument(data.hashBuffer !== undefined, 'data', 'Must provide a `hash` or `hashBuffer` property');
         preconditions_js_1.Preconditions.checkArgument(data.type !== undefined, 'data', 'Must provide a `type` property');
         return {
-            hashBuffer: data.hashBuffer || Buffer.from(data.hashBuffer.toString(), 'hex'),
+            hashBuffer: data.hashBuffer || buffer_1.Buffer.from(data.hashBuffer.toString(), 'hex'),
             network: networks_js_1.Networks.get(data.network) || networks_js_1.Networks.defaultNetwork,
             type: data.type,
             prefix: data.prefix,
@@ -99,9 +98,9 @@ class XAddress {
         }
         return info;
     }
-    static _transformBuffer(buffer, network, type, prefix = TOKEN_NAME) {
+    static _transformBuffer(buffer, network, type, prefix = 'lotus') {
         const info = {};
-        if (!Buffer.isBuffer(buffer) && !(buffer instanceof Uint8Array)) {
+        if (!buffer_1.Buffer.isBuffer(buffer) && !(buffer instanceof Uint8Array)) {
             throw new TypeError('XAddress supplied is not a buffer.');
         }
         const networkObj = networks_js_1.Networks.get(network);
@@ -112,7 +111,7 @@ class XAddress {
             throw new TypeError('Unknown type.');
         }
         info.prefix = prefix;
-        info.hashBuffer = Buffer.from(buffer);
+        info.hashBuffer = buffer_1.Buffer.from(buffer);
         info.network = networkObj || networks_js_1.Networks.defaultNetwork;
         info.type = type;
         return info;
@@ -123,7 +122,7 @@ class XAddress {
     }
     static fromObject(obj) {
         preconditions_js_1.Preconditions.checkState(js_js_1.JSUtil.isHexa(obj.hash), 'Unexpected hash property, "' + obj.hash + '", expected to be hex.');
-        const hashBuffer = Buffer.from(obj.hash, 'hex');
+        const hashBuffer = buffer_1.Buffer.from(obj.hash, 'hex');
         return new XAddress(hashBuffer, obj.network, obj.type, obj.prefix);
     }
     static getValidationError(data, network, type) {
@@ -142,10 +141,10 @@ class XAddress {
         return decode(address);
     }
     toBuffer() {
-        const version = Buffer.from([
+        const version = buffer_1.Buffer.from([
             this.network[this.type],
         ]);
-        const buf = Buffer.concat([version, this.hashBuffer]);
+        const buf = buffer_1.Buffer.concat([version, this.hashBuffer]);
         return buf;
     }
     toObject() {
@@ -162,7 +161,7 @@ class XAddress {
     toXAddress() {
         const prefix = this.prefix;
         const networkChar = getNetworkChar(this.network);
-        const typeByte = Buffer.from([getTypeByte(this.type)]);
+        const typeByte = buffer_1.Buffer.from([getTypeByte(this.type)]);
         const payload = this.hashBuffer;
         const checksum = createChecksum(prefix, networkChar, typeByte, payload);
         const encodedPayload = encodePayload(typeByte, payload, checksum);
@@ -187,23 +186,23 @@ class XAddress {
 exports.XAddress = XAddress;
 function createChecksum(prefix, networkChar, typeByte, payload) {
     const data = buffer_js_1.BufferUtil.concat([
-        Buffer.from(prefix),
-        Buffer.from(networkChar),
+        buffer_1.Buffer.from(prefix),
+        buffer_1.Buffer.from(networkChar),
         typeByte,
         payload,
     ]);
-    return hash_js_1.Hash.sha256(data).subarray(0, 4);
+    return hash_js_1.Hash.sha256(data).slice(0, 4);
 }
 function createChecksumLegacy(prefix, networkChar, typeByte, payload) {
     const bw = new bufferwriter_js_1.BufferWriter();
     bw.writeVarintNum(prefix.length);
-    bw.write(Buffer.from(prefix));
+    bw.write(buffer_1.Buffer.from(prefix));
     bw.writeUInt8(networkChar.charCodeAt(0));
     bw.writeUInt8(typeByte[0]);
     bw.writeVarintNum(payload.length);
     bw.write(payload);
     const buf = bw.concat();
-    return hash_js_1.Hash.sha256(buf).subarray(0, 4);
+    return hash_js_1.Hash.sha256(buf).slice(0, 4);
 }
 function getType(typeByte) {
     switch (typeByte) {
@@ -214,7 +213,7 @@ function getType(typeByte) {
         case 2:
             return 'taproot';
     }
-    return 'pubkeyhash';
+    return null;
 }
 function getTypeByte(type) {
     switch (type) {
@@ -267,15 +266,20 @@ function decode(address) {
     const networkChar = address.substring(splitLocation, splitLocation + 1);
     const encodedPayload = address.substring(splitLocation + 1);
     const decodedBytes = base58_js_1.Base58.decode(encodedPayload);
-    const typeByte = decodedBytes.subarray(0, 1);
-    const payload = decodedBytes.subarray(1, decodedBytes.length - 4);
-    const decodedChecksum = decodedBytes.subarray(decodedBytes.length - 4);
+    const typeByte = decodedBytes.slice(0, 1);
+    const payload = decodedBytes.slice(1, decodedBytes.length - 4);
+    const decodedChecksum = decodedBytes.slice(decodedBytes.length - 4);
     const checksum = createChecksum(prefix, networkChar, typeByte, payload);
-    preconditions_js_1.Preconditions.checkArgument(checksum.toString('hex') === decodedChecksum.toString('hex'), 'checksum', 'Invalid checksum: ' + address);
+    const legacyChecksum = createChecksumLegacy(prefix, networkChar, typeByte, payload);
+    const validChecksum = checksum.toString('hex') === decodedChecksum.toString('hex') ||
+        legacyChecksum.toString('hex') === decodedChecksum.toString('hex');
+    preconditions_js_1.Preconditions.checkArgument(validChecksum, 'checksum', 'Invalid checksum: ' + address);
+    const type = getType(typeByte[0]);
+    preconditions_js_1.Preconditions.checkArgument(type !== null, 'typeByte', 'Invalid type byte: ' + typeByte[0]);
     const info = {};
     info.hashBuffer = payload;
     info.network = getNetworkFromChar(networkChar);
-    info.type = getType(typeByte[0]);
+    info.type = type;
     info.prefix = prefix;
     return info;
 }