xpi-ts 0.2.13 → 0.2.15

package/dist/cjs/lib/bitcore/crypto/schnorr.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schnorr = void 0;
-const bn_js_1 = require("./bn.js");
-const point_js_1 = require("./point.js");
-const signature_js_1 = require("./signature.js");
-const hash_js_1 = require("./hash.js");
+const bn_1 = require("./bn");
+const point_1 = require("./point");
+const signature_1 = require("./signature");
+const hash_1 = require("./hash");
+const util_1 = require("../util");
 class Schnorr {
     hashbuf;
     endian;
@@ -41,26 +42,26 @@ class Schnorr {
         if (!hashbuf || !privkey || !d) {
             throw new Error('invalid parameters');
         }
-        if (!Buffer.isBuffer(hashbuf) || hashbuf.length !== 32) {
+        if (!util_1.BufferUtil.isBuffer(hashbuf) || hashbuf.length !== 32) {
             throw new Error('hashbuf must be a 32 byte buffer');
         }
-        const e = new bn_js_1.BN(hashbuf, 'be');
+        const e = bn_1.BN.fromBuffer(hashbuf);
         const obj = this._findSignature(d, e);
         obj.compressed = this.pubkey.compressed;
         obj.isSchnorr = true;
-        this.sig = new signature_js_1.Signature(obj);
+        this.sig = new signature_1.Signature(obj);
         return this;
     }
     _findSignature(d, e) {
-        const n = point_js_1.Point.getN();
-        const G = point_js_1.Point.getG();
-        if (d.lte(new bn_js_1.BN(0))) {
+        const n = point_1.Point.getN();
+        const G = point_1.Point.getG();
+        if (d.lte(bn_1.BN.Zero)) {
             throw new Error('privkey out of field of curve');
         }
         if (d.gte(n)) {
             throw new Error('privkey out of field of curve');
         }
-        let k = this.nonceFunctionRFC6979(d.toArrayLike(Buffer, 'be', 32), e.toArrayLike(Buffer, 'be', 32));
+        let k = this.nonceFunctionRFC6979(d.toBuffer({ size: 32 }), e.toBuffer({ size: 32 }));
         const P = G.mul(d);
         const R = G.mul(k);
         if (R.hasSquare()) {
@@ -68,94 +69,84 @@ class Schnorr {
         else {
             k = n.sub(k);
         }
-        const r = R.getX();
+        const r = R.x;
         const rBuffer = this.getrBuffer(r);
-        const e0 = new bn_js_1.BN(hash_js_1.Hash.sha256(Buffer.concat([
+        const e0 = bn_1.BN.fromBuffer(hash_1.Hash.sha256(util_1.BufferUtil.concat([
             rBuffer,
-            point_js_1.Point.pointToCompressed(P),
-            e.toArrayLike(Buffer, 'be', 32),
-        ])), 'be');
+            point_1.Point.pointToCompressed(P),
+            e.toBuffer({ size: 32 }),
+        ])));
         const s = e0.mul(d).add(k).mod(n);
         return { r, s, compressed: this.pubkey.compressed, isSchnorr: true };
     }
     getrBuffer(r) {
-        const rNaturalLength = r.toArrayLike(Buffer, 'be').length;
-        if (rNaturalLength < 32) {
-            return r.toArrayLike(Buffer, 'be', 32);
-        }
-        return r.toArrayLike(Buffer, 'be');
+        const buf = r.toBuffer();
+        return buf.length < 32 ? r.toBuffer({ size: 32 }) : buf;
     }
     getsBuffer(s) {
-        const sNaturalLength = s.toArrayLike(Buffer, 'be').length;
-        if (sNaturalLength < 32) {
-            return s.toArrayLike(Buffer, 'be', 32);
-        }
-        return s.toArrayLike(Buffer, 'be');
+        const buf = s.toBuffer();
+        return buf.length < 32 ? s.toBuffer({ size: 32 }) : buf;
     }
     sigError() {
-        if (!Buffer.isBuffer(this.hashbuf) || this.hashbuf.length !== 32) {
-            return true;
-        }
-        const sigLength = this.getrBuffer(this.sig.r).length + this.getsBuffer(this.sig.s).length;
-        if (!(sigLength === 64 || sigLength === 65)) {
+        if (!util_1.BufferUtil.isBuffer(this.hashbuf) || this.hashbuf.length !== 32) {
             return true;
         }
         const hashbuf = this.endian === 'little' ? this.reverseBuffer(this.hashbuf) : this.hashbuf;
         const P = this.pubkey.point;
-        const G = point_js_1.Point.getG();
+        const G = point_1.Point.getG();
         if (P.isInfinity()) {
             return true;
         }
         const r = this.sig.r;
         const s = this.sig.s;
-        const p = new bn_js_1.BN('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F', 16);
-        const n = point_js_1.Point.getN();
+        const p = bn_1.BN.fromString('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F', 'hex');
+        const n = point_1.Point.getN();
         if (r.gte(p) || s.gte(n)) {
             return true;
         }
         const Br = this.getrBuffer(this.sig.r);
-        const Bp = point_js_1.Point.pointToCompressed(P);
-        const hash = hash_js_1.Hash.sha256(Buffer.concat([Br, Bp, hashbuf]));
-        const e = new bn_js_1.BN(hash, 'be').mod(n);
+        const Bp = point_1.Point.pointToCompressed(P);
+        const hash = hash_1.Hash.sha256(util_1.BufferUtil.concat([Br, Bp, hashbuf]));
+        const e = bn_1.BN.fromBuffer(hash).mod(n);
         const sG = G.mul(s);
         const eP = P.mul(n.sub(e));
         const R = sG.add(eP);
-        if (R.isInfinity() || !R.hasSquare() || !R.getX().eq(r)) {
+        if (R.isInfinity() || !R.hasSquare() || !R.x.eq(r)) {
             return true;
         }
         return false;
     }
     verify() {
-        this.verified = !!!this.sigError();
+        this.verified = this.sigError() === false;
         return this;
     }
     nonceFunctionRFC6979(privkey, msgbuf) {
-        let V = Buffer.from('0101010101010101010101010101010101010101010101010101010101010101', 'hex');
-        let K = Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
-        const blob = Buffer.concat([
+        let V = util_1.BufferUtil.from('0101010101010101010101010101010101010101010101010101010101010101', 'hex');
+        let K = util_1.BufferUtil.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
+        const blob = util_1.BufferUtil.concat([
             privkey,
             msgbuf,
-            Buffer.from('', 'ascii'),
-            Buffer.from('Schnorr+SHA256  ', 'ascii'),
+            util_1.BufferUtil.from('', 'ascii'),
+            util_1.BufferUtil.from('Schnorr+SHA256  ', 'ascii'),
         ]);
-        K = hash_js_1.Hash.sha256hmac(Buffer.concat([V, Buffer.from('00', 'hex'), blob]), K);
-        V = hash_js_1.Hash.sha256hmac(V, K);
-        K = hash_js_1.Hash.sha256hmac(Buffer.concat([V, Buffer.from('01', 'hex'), blob]), K);
-        V = hash_js_1.Hash.sha256hmac(V, K);
-        let k = new bn_js_1.BN(0);
+        K = hash_1.Hash.sha256hmac(util_1.BufferUtil.concat([V, util_1.BufferUtil.from('00', 'hex'), blob]), K);
+        V = hash_1.Hash.sha256hmac(V, K);
+        K = hash_1.Hash.sha256hmac(util_1.BufferUtil.concat([V, util_1.BufferUtil.from('01', 'hex'), blob]), K);
+        V = hash_1.Hash.sha256hmac(V, K);
+        let k = bn_1.BN.Zero;
         let T;
         while (true) {
-            V = hash_js_1.Hash.sha256hmac(V, K);
-            T = new bn_js_1.BN(V, 'be');
+            V = hash_1.Hash.sha256hmac(V, K);
+            T = bn_1.BN.fromBuffer(V);
             k = T;
             if (V.length < 32) {
                 throw new Error('V length should be >= 32');
             }
-            if (k.gt(new bn_js_1.BN(0)) && k.lt(point_js_1.Point.getN())) {
+            if (k.gt(bn_1.BN.Zero) && k.lt(point_1.Point.getN())) {
                 break;
             }
-            K = hash_js_1.Hash.sha256hmac(Buffer.concat([V, Buffer.from('00', 'hex')]), K);
-            V = hash_js_1.Hash.sha256hmac(V, K);
+            K = hash_1.Hash.sha256hmac(util_1.BufferUtil.concat([V, util_1.BufferUtil.from('00', 'hex')]), K);
+            V = hash_1.Hash.sha256hmac(V, K);
         }
         return k;
     }
@@ -179,7 +170,7 @@ class Schnorr {
             .verify().verified;
     }
     reverseBuffer(buf) {
-        const buf2 = Buffer.alloc(buf.length);
+        const buf2 = util_1.BufferUtil.alloc(buf.length);
         for (let i = 0; i < buf.length; i++) {
             buf2[i] = buf[buf.length - 1 - i];
         }

package/dist/cjs/lib/bitcore/crypto/signature.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Signature = void 0;
-const bn_js_1 = require("./bn.js");
+const bn_1 = require("./bn");
+const util_1 = require("../util");
+const sigtype_1 = require("./sigtype");
 class Signature {
     r;
     s;
@@ -15,8 +17,10 @@ class Signature {
     static SIGHASH_FORKID = 0x40;
     static SIGHASH_LOTUS = 0x60;
     static SIGHASH_ANYONECANPAY = 0x80;
+    static SIGHASH_RESERVED = 0x20;
+    static SIGHASH_ALGORITHM_MASK = 0x60;
     constructor(r, s, isSchnorr) {
-        if (r instanceof bn_js_1.BN) {
+        if (r instanceof bn_1.BN) {
             this.set({
                 r: r,
                 s: s,
@@ -41,18 +45,18 @@ class Signature {
         return this;
     }
     static fromCompact(buf) {
-        if (!Buffer.isBuffer(buf)) {
+        if (!util_1.BufferUtil.isBuffer(buf)) {
             throw new Error('Argument is expected to be a Buffer');
         }
-        const sig = new Signature(new bn_js_1.BN(0), new bn_js_1.BN(0));
+        const sig = new Signature(new bn_1.BN(0), new bn_1.BN(0));
         let compressed = true;
-        let i = buf.subarray(0, 1)[0] - 27 - 4;
+        let i = buf.slice(0, 1)[0] - 27 - 4;
         if (i < 0) {
             compressed = false;
             i = i + 4;
         }
-        const b2 = buf.subarray(1, 33);
-        const b3 = buf.subarray(33, 65);
+        const b2 = buf.slice(1, 33);
+        const b3 = buf.slice(33, 65);
         if (!(i === 0 || i === 1 || i === 2 || i === 3)) {
             throw new Error('i must be 0, 1, 2, or 3');
         }
@@ -64,24 +68,25 @@ class Signature {
         }
         sig.compressed = compressed;
         sig.i = i;
-        sig.r = new bn_js_1.BN(b2, 'le');
-        sig.s = new bn_js_1.BN(b3, 'le');
+        sig.r = bn_1.BN.fromBuffer(b2);
+        sig.s = bn_1.BN.fromBuffer(b3);
         return sig;
     }
     static fromDER(buf, strict = true) {
-        if ((buf.length === 64 || buf.length === 65) && buf[0] !== 0x30) {
+        const rawSig = buf.length === 65 && buf[0] !== 0x30 ? buf.slice(0, 64) : buf;
+        if ((0, sigtype_1.isSchnorrSignature)(rawSig) && buf[0] !== 0x30) {
             const obj = Signature.parseSchnorrEncodedSig(buf);
-            const sig = new Signature(new bn_js_1.BN(0), new bn_js_1.BN(0));
+            const sig = new Signature(new bn_1.BN(0), new bn_1.BN(0));
             sig.r = obj.r;
             sig.s = obj.s;
             sig.isSchnorr = true;
             return sig;
         }
-        if (buf.length === 64 && buf[0] === 0x30) {
+        if ((0, sigtype_1.isSchnorrSignature)(buf) && buf[0] === 0x30) {
             throw new Error('64 DER (ecdsa) signatures not allowed');
         }
         const obj = Signature.parseDER(buf, strict);
-        const sig = new Signature(new bn_js_1.BN(0), new bn_js_1.BN(0));
+        const sig = new Signature(new bn_1.BN(0), new bn_1.BN(0));
         sig.r = obj.r;
         sig.s = obj.s;
         return sig;
@@ -91,17 +96,17 @@ class Signature {
     }
     static fromTxFormat(buf) {
         const nhashtype = buf.readUInt8(buf.length - 1);
-        const derbuf = buf.subarray(0, buf.length - 1);
+        const derbuf = buf.slice(0, buf.length - 1);
         const sig = Signature.fromDER(derbuf, false);
         sig.nhashtype = nhashtype;
         return sig;
     }
     static fromDataFormat(buf) {
-        const derbuf = buf.subarray(0, buf.length);
+        const derbuf = buf.slice(0, buf.length);
         return Signature.fromDER(derbuf, false);
     }
     static fromString(str) {
-        const buf = Buffer.from(str, 'hex');
+        const buf = util_1.BufferUtil.from(str, 'hex');
         return Signature.fromDER(buf);
     }
     static fromSchnorr(buf) {
@@ -117,20 +122,20 @@ class Signature {
         if (buf.length !== 64 && buf.length !== 65) {
             throw new Error(`Invalid Schnorr signature length: ${buf.length} bytes (expected 64 or 65)`);
         }
-        const r = buf.subarray(0, 32);
-        const s = buf.subarray(32, 64);
+        const r = buf.slice(0, 32);
+        const s = buf.slice(32, 64);
         let hashtype;
         if (buf.length === 65) {
-            hashtype = buf.subarray(64, 65);
+            hashtype = buf.slice(64, 65);
         }
         return {
-            r: new bn_js_1.BN(r, 'be'),
-            s: new bn_js_1.BN(s, 'be'),
+            r: bn_1.BN.fromBuffer(r),
+            s: bn_1.BN.fromBuffer(s),
             nhashtype: hashtype,
         };
     }
     static parseDER(buf, strict = true) {
-        if (!Buffer.isBuffer(buf)) {
+        if (!util_1.BufferUtil.isBuffer(buf)) {
             throw new Error('DER formatted signature should be a buffer');
         }
         const header = buf[0];
@@ -138,7 +143,7 @@ class Signature {
             throw new Error('Header byte should be 0x30');
         }
         let length = buf[1];
-        const buflength = buf.subarray(2).length;
+        const buflength = buf.slice(2).length;
         if (strict && length !== buflength) {
             throw new Error('Length byte should length of what follows');
         }
@@ -148,8 +153,8 @@ class Signature {
             throw new Error('Integer byte for r should be 0x02');
         }
         const rlength = buf[2 + 1];
-        const rbuf = buf.subarray(2 + 2, 2 + 2 + rlength);
-        const r = new bn_js_1.BN(rbuf, 'be');
+        const rbuf = buf.slice(2 + 2, 2 + 2 + rlength);
+        const r = new bn_1.BN(rbuf, 'be');
         if (rlength !== rbuf.length) {
             throw new Error('Length of r incorrect');
         }
@@ -158,8 +163,8 @@ class Signature {
             throw new Error('Integer byte for s should be 0x02');
         }
         const slength = buf[2 + 2 + rlength + 1];
-        const sbuf = buf.subarray(2 + 2 + rlength + 2, 2 + 2 + rlength + 2 + slength);
-        const s = new bn_js_1.BN(sbuf, 'be');
+        const sbuf = buf.slice(2 + 2 + rlength + 2, 2 + 2 + rlength + 2 + slength);
+        const s = new bn_1.BN(sbuf, 'be');
         if (slength !== sbuf.length) {
             throw new Error('Length of s incorrect');
         }
@@ -182,34 +187,38 @@ class Signature {
         if (isCompressed === false) {
             val = val - 4;
         }
-        const b1 = Buffer.from([val]);
-        const b2 = this.r.toArrayLike(Buffer, 'le', 32);
-        const b3 = this.s.toArrayLike(Buffer, 'le', 32);
-        return Buffer.concat([b1, b2, b3]);
+        const b1 = util_1.BufferUtil.from([val]);
+        const b2 = this.r.toBuffer({ size: 32 });
+        const b3 = this.s.toBuffer({ size: 32 });
+        return util_1.BufferUtil.concat([b1, b2, b3]);
     }
     toDER(signingMethod = 'ecdsa') {
         if (signingMethod === 'schnorr') {
-            return Buffer.concat([
-                this.r.toArrayLike(Buffer, 'be', 32),
-                this.s.toArrayLike(Buffer, 'be', 32),
+            return util_1.BufferUtil.concat([
+                this.r.toBuffer({ size: 32 }),
+                this.s.toBuffer({ size: 32 }),
             ]);
         }
-        const rnbuf = this.r.toArrayLike(Buffer, 'be');
-        const snbuf = this.s.toArrayLike(Buffer, 'be');
+        const rnbuf = this.r.toBuffer();
+        const snbuf = this.s.toBuffer();
         const rneg = (rnbuf[0] & 0x80) !== 0;
         const sneg = (snbuf[0] & 0x80) !== 0;
-        const rbuf = rneg ? Buffer.concat([Buffer.from([0x00]), rnbuf]) : rnbuf;
-        const sbuf = sneg ? Buffer.concat([Buffer.from([0x00]), snbuf]) : snbuf;
+        const rbuf = rneg
+            ? util_1.BufferUtil.concat([util_1.BufferUtil.from([0x00]), rnbuf])
+            : rnbuf;
+        const sbuf = sneg
+            ? util_1.BufferUtil.concat([util_1.BufferUtil.from([0x00]), snbuf])
+            : snbuf;
         const rlength = rbuf.length;
         const slength = sbuf.length;
         const length = 2 + rlength + 2 + slength;
         const rheader = 0x02;
         const sheader = 0x02;
         const header = 0x30;
-        return Buffer.concat([
-            Buffer.from([header, length, rheader, rlength]),
+        return util_1.BufferUtil.concat([
+            util_1.BufferUtil.from([header, length, rheader, rlength]),
             rbuf,
-            Buffer.from([sheader, slength]),
+            util_1.BufferUtil.from([sheader, slength]),
             sbuf,
         ]);
     }
@@ -224,9 +233,12 @@ class Signature {
     }
     toTxFormat(signingMethod) {
         const derbuf = this.toDER(signingMethod);
-        const buf = Buffer.alloc(1);
-        buf.writeUInt8(this.nhashtype || 0, 0);
-        return Buffer.concat([derbuf, buf]);
+        const buf = util_1.BufferUtil.alloc(1);
+        const defaultSighash = this.isSchnorr
+            ? Signature.SIGHASH_ALL | Signature.SIGHASH_LOTUS
+            : 0;
+        buf.writeUInt8(this.nhashtype ?? defaultSighash, 0);
+        return util_1.BufferUtil.concat([derbuf, buf]);
     }
     static isDER(buf) {
         if (buf.length < 8 || buf.length > 72) {
@@ -274,8 +286,8 @@ class Signature {
         return true;
     }
     hasLowS() {
-        const lowSThreshold = new bn_js_1.BN('7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0', 16);
-        if (this.s.lt(new bn_js_1.BN(1)) || this.s.gt(lowSThreshold)) {
+        const lowSThreshold = bn_1.BN.fromString('7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0', 'hex');
+        if (this.s.lt(bn_1.BN.One) || this.s.gt(lowSThreshold)) {
             return false;
         }
         return true;
@@ -284,21 +296,21 @@ class Signature {
         if (typeof this.nhashtype !== 'number') {
             return false;
         }
-        if (this.nhashtype & Signature.SIGHASH_LOTUS) {
-            const baseMask = ~(Signature.SIGHASH_LOTUS | Signature.SIGHASH_ANYONECANPAY) >>> 0;
-            const baseType = this.nhashtype & baseMask;
-            return (baseType >= Signature.SIGHASH_ALL &&
-                baseType <= Signature.SIGHASH_SINGLE);
+        const baseType = this.nhashtype & 0x1f;
+        if (baseType < Signature.SIGHASH_ALL ||
+            baseType > Signature.SIGHASH_SINGLE) {
+            return false;
         }
-        const mask = ~(Signature.SIGHASH_FORKID | Signature.SIGHASH_ANYONECANPAY) >>> 0;
-        const temp = this.nhashtype & mask;
-        if (temp < Signature.SIGHASH_ALL || temp > Signature.SIGHASH_SINGLE) {
+        const algorithm = this.nhashtype & Signature.SIGHASH_ALGORITHM_MASK;
+        if (algorithm !== 0x00 &&
+            algorithm !== Signature.SIGHASH_FORKID &&
+            algorithm !== Signature.SIGHASH_LOTUS) {
             return false;
         }
         return true;
     }
     static isTxDER(buf) {
-        return Signature.isDER(buf.subarray(0, buf.length - 1));
+        return Signature.isDER(buf.slice(0, buf.length - 1));
     }
 }
 exports.Signature = Signature;

package/dist/cjs/lib/bitcore/crypto/sigtype.js

@@ -17,7 +17,7 @@ function isValidSignatureLength(sig) {
     if (sig.length === 64) {
         return true;
     }
-    if (sig.length >= 9 && sig.length <= 73) {
+    if (sig.length >= 8 && sig.length <= 72) {
         return true;
     }
     return false;

package/dist/cjs/lib/bitcore/encoding/base58.js

@@ -5,11 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Base58 = void 0;
 const bs58_1 = __importDefault(require("bs58"));
+const util_1 = require("../util");
 const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'.split('');
 class Base58 {
     buf;
     constructor(obj) {
-        if (Buffer.isBuffer(obj)) {
+        if (util_1.BufferUtil.isBuffer(obj)) {
             const buf = obj;
             this.fromBuffer(buf);
         }
@@ -22,7 +23,7 @@ class Base58 {
         }
     }
     static validCharacters(chars) {
-        if (Buffer.isBuffer(chars)) {
+        if (util_1.BufferUtil.isBuffer(chars)) {
             chars = chars.toString();
         }
         return Array.from(chars).every(char => ALPHABET.includes(char));
@@ -32,7 +33,7 @@ class Base58 {
         return this;
     }
     static encode(buf) {
-        if (!Buffer.isBuffer(buf)) {
+        if (!util_1.BufferUtil.isBuffer(buf)) {
             throw new Error('Input should be a buffer');
         }
         return bs58_1.default.encode(buf);
@@ -41,7 +42,7 @@ class Base58 {
         if (typeof str !== 'string') {
             throw new Error('Input should be a string');
         }
-        return Buffer.from(bs58_1.default.decode(str));
+        return util_1.BufferUtil.from(bs58_1.default.decode(str));
     }
     fromBuffer(buf) {
         this.buf = buf;

package/dist/cjs/lib/bitcore/encoding/base58check.js

@@ -1,86 +1,43 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Base58Check = void 0;
-const sha256_1 = require("@noble/hashes/sha256");
-const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
-const ALPHABET_MAP = {};
-for (let i = 0; i < ALPHABET.length; i++) {
-    ALPHABET_MAP[ALPHABET[i]] = i;
-}
+const sha2_1 = require("@noble/hashes/sha2");
+const bs58_1 = __importDefault(require("bs58"));
+const util_1 = require("../util");
 class Base58Check {
     static encode(buf) {
-        if (!Buffer.isBuffer(buf)) {
+        if (!util_1.BufferUtil.isBuffer(buf)) {
             throw new Error('Input must be a Buffer');
         }
         const checksum = this.checksum(buf);
-        const payload = Buffer.concat([buf, checksum]);
-        return this.base58Encode(payload);
+        const payload = util_1.BufferUtil.concat([buf, checksum]);
+        return bs58_1.default.encode(payload);
     }
     static decode(str) {
         if (typeof str !== 'string') {
             throw new Error('Input must be a string');
         }
-        const buf = this.base58Decode(str);
+        const buf = util_1.BufferUtil.from(bs58_1.default.decode(str));
         if (buf.length < 4) {
             throw new Error('Input string too short');
         }
-        const data = buf.subarray(0, -4);
-        const checksum = buf.subarray(-4);
+        const data = buf.slice(0, -4);
+        const checksum = buf.slice(-4);
         if (!this.validChecksum(data, checksum)) {
             throw new Error('Invalid checksum');
         }
         return data;
     }
     static checksum(data) {
-        const hash1 = (0, sha256_1.sha256)(data);
-        const hash2 = (0, sha256_1.sha256)(hash1);
-        return Buffer.from(hash2).subarray(0, 4);
+        const hash = (0, sha2_1.sha256)((0, sha2_1.sha256)(data));
+        return util_1.BufferUtil.from(hash).slice(0, 4);
     }
     static validChecksum(data, checksum) {
         const calculatedChecksum = this.checksum(data);
         return calculatedChecksum.equals(checksum);
     }
-    static base58Encode(buf) {
-        if (buf.length === 0)
-            return '';
-        let num = 0n;
-        for (let i = 0; i < buf.length; i++) {
-            num = num * 256n + BigInt(buf[i]);
-        }
-        let result = '';
-        while (num > 0n) {
-            result = ALPHABET[Number(num % 58n)] + result;
-            num = num / 58n;
-        }
-        for (let i = 0; i < buf.length && buf[i] === 0; i++) {
-            result = '1' + result;
-        }
-        return result;
-    }
-    static base58Decode(str) {
-        if (str.length === 0)
-            return Buffer.alloc(0);
-        let num = 0n;
-        let leadingZeros = 0;
-        for (let i = 0; i < str.length; i++) {
-            const char = str[i];
-            if (ALPHABET_MAP[char] === undefined) {
-                throw new Error(`Invalid character: ${char}`);
-            }
-            num = num * 58n + BigInt(ALPHABET_MAP[char]);
-        }
-        for (let i = 0; i < str.length && str[i] === '1'; i++) {
-            leadingZeros++;
-        }
-        const bytes = [];
-        while (num > 0n) {
-            bytes.unshift(Number(num % 256n));
-            num = num / 256n;
-        }
-        for (let i = 0; i < leadingZeros; i++) {
-            bytes.unshift(0);
-        }
-        return Buffer.from(bytes);
-    }
 }
 exports.Base58Check = Base58Check;