xpi-ts 0.2.13 → 0.2.15

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

@@ -1,20 +1,21 @@
-import { Preconditions } from '../util/preconditions.js';
-import { JSUtil } from '../util/js.js';
-import { BufferReader } from '../encoding/bufferreader.js';
-import { BufferWriter } from '../encoding/bufferwriter.js';
-import { Hash } from '../crypto/hash.js';
-import { Signature } from '../crypto/signature.js';
-import { verify } from './sighash.js';
-import { BitcoreError } from '../errors.js';
-import { Address } from '../address.js';
-import { UnspentOutput } from './unspentoutput.js';
-import { Input, MultisigInput, MultisigScriptHashInput, PublicKeyInput, PublicKeyHashInput, TaprootInput, MuSigTaprootInput, } from './input.js';
-import { Output } from './output.js';
-import { Script } from '../script.js';
-import { PrivateKey } from '../privatekey.js';
-import { BN } from '../crypto/bn.js';
-import { sighash as computeSighash } from './sighash.js';
-import { Interpreter } from '../script/interpreter.js';
+import { Preconditions } from '../util/preconditions';
+import { JSUtil } from '../util/js';
+import { BufferReader } from '../encoding/bufferreader';
+import { BufferWriter } from '../encoding/bufferwriter';
+import { Hash } from '../crypto/hash';
+import { Signature } from '../crypto/signature';
+import { verify } from './sighash';
+import { BitcoreError } from '../errors';
+import { Address } from '../address';
+import { UnspentOutput } from './unspentoutput';
+import { Input, MultisigInput, MultisigScriptHashInput, PublicKeyInput, PublicKeyHashInput, TaprootInput, MuSig2TaprootInput, } from './input';
+import { Output } from './output';
+import { Script } from '../script';
+import { PrivateKey } from '../privatekey';
+import { BN } from '../crypto/bn';
+import { sighash as computeSighash } from './sighash';
+import { Interpreter } from '../script/interpreter';
+import { BufferUtil } from '../util';
 const CURRENT_VERSION = 2;
 const DEFAULT_NLOCKTIME = 0;
 const MAX_BLOCK_SIZE = 32_000_000;
@@ -26,7 +27,7 @@ const NLOCKTIME_MAX_VALUE = 4294967295;
 const FEE_PER_KB = 1_000;
 const CHANGE_OUTPUT_MAX_SIZE = 20 + 4 + 34 + 4;
 const MAXIMUM_EXTRA_SIZE = 4 + 9 + 9 + 4;
-const NULL_HASH = Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
+const NULL_HASH = BufferUtil.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
 export class Transaction {
     static DUST_AMOUNT = DUST_AMOUNT;
     static FEE_SECURITY_MARGIN = FEE_SECURITY_MARGIN;
@@ -62,7 +63,7 @@ export class Transaction {
         else if (typeof serialized === 'string' && JSUtil.isHexa(serialized)) {
             this.fromString(serialized);
         }
-        else if (Buffer.isBuffer(serialized)) {
+        else if (BufferUtil.isBuffer(serialized)) {
             this.fromBuffer(serialized);
         }
         else if (serialized && typeof serialized === 'object') {
@@ -99,6 +100,9 @@ export class Transaction {
         }
         return this._hash;
     }
+    get hashBuffer() {
+        return this._getHash();
+    }
     get id() {
         return this.txid;
     }
@@ -110,6 +114,9 @@ export class Transaction {
         }
         return this._txid;
     }
+    get txidBuffer() {
+        return this._getTxid();
+    }
     get inputAmount() {
         return this._getInputAmount();
     }
@@ -198,7 +205,7 @@ export class Transaction {
                 size += 1;
             }
             for (let i = 0; i < size; i += 2) {
-                const buf = Buffer.concat([hashes[j + i], hashes[j + i + 1]]);
+                const buf = BufferUtil.concat([hashes[j + i], hashes[j + i + 1]]);
                 hashes.push(Hash.sha256sha256(buf));
             }
             j += size;
@@ -347,7 +354,7 @@ export class Transaction {
         return this;
     }
     fromString(str) {
-        return this.fromBuffer(Buffer.from(str, 'hex'));
+        return this.fromBuffer(BufferUtil.from(str, 'hex'));
     }
     toObject() {
         const inputs = this.inputs.map(input => input.toObject());
@@ -504,12 +511,12 @@ export class Transaction {
         return this.sign(privateKey, Signature.SIGHASH_ALL | Signature.SIGHASH_LOTUS, 'schnorr');
     }
     getMuSig2Inputs() {
-        return this.inputs.filter(input => input instanceof MuSigTaprootInput);
+        return this.inputs.filter(input => input instanceof MuSig2TaprootInput);
     }
     getMuSig2Sighash(inputIndex) {
         const input = this.inputs[inputIndex];
-        if (!(input instanceof MuSigTaprootInput)) {
-            throw new Error(`Input ${inputIndex} is not a MuSigTaprootInput`);
+        if (!(input instanceof MuSig2TaprootInput)) {
+            throw new Error(`Input ${inputIndex} is not a MuSig2TaprootInput`);
         }
         if (!input.output) {
             throw new Error(`Input ${inputIndex} is missing output information`);
@@ -519,16 +526,16 @@ export class Transaction {
     }
     addMuSig2Nonce(inputIndex, signerIndex, nonce) {
         const input = this.inputs[inputIndex];
-        if (!(input instanceof MuSigTaprootInput)) {
-            throw new Error(`Input ${inputIndex} is not a MuSigTaprootInput`);
+        if (!(input instanceof MuSig2TaprootInput)) {
+            throw new Error(`Input ${inputIndex} is not a MuSig2TaprootInput`);
         }
         input.addPublicNonce(signerIndex, nonce);
         return this;
     }
     addMuSig2PartialSignature(inputIndex, signerIndex, partialSig) {
         const input = this.inputs[inputIndex];
-        if (!(input instanceof MuSigTaprootInput)) {
-            throw new Error(`Input ${inputIndex} is not a MuSigTaprootInput`);
+        if (!(input instanceof MuSig2TaprootInput)) {
+            throw new Error(`Input ${inputIndex} is not a MuSig2TaprootInput`);
         }
         input.addPartialSignature(signerIndex, partialSig);
         return this;
@@ -537,13 +544,13 @@ export class Transaction {
         const musigInputs = this.getMuSig2Inputs();
         for (let i = 0; i < this.inputs.length; i++) {
             const input = this.inputs[i];
-            if (input instanceof MuSigTaprootInput) {
+            if (input instanceof MuSig2TaprootInput) {
                 if (!input.hasAllPartialSignatures()) {
                     throw new Error(`MuSig2 input ${i} is missing partial signatures. ` +
                         `Has ${input.partialSignatures?.size || 0} of ${input.keyAggContext?.pubkeys.length || 0}`);
                 }
                 const sighash = this.getMuSig2Sighash(i);
-                input.finalizeMuSigSignature(this, sighash);
+                input.finalizeMuSig2Signature(this, sighash);
             }
         }
         return this;
@@ -556,7 +563,7 @@ export class Transaction {
             const input = this.inputs[index];
             let inputSigtype = sigtype;
             if (!inputSigtype) {
-                if (input.output?.script.isPayToTaproot()) {
+                if (input.output?.script.isTaprootOut()) {
                     const taprootInput = input;
                     if (taprootInput.hasScriptTree()) {
                         inputSigtype = Signature.SIGHASH_ALL | Signature.SIGHASH_FORKID;
@@ -660,7 +667,7 @@ export class Transaction {
                 x.i = i++;
             });
             copy.sort((first, second) => {
-                const prevTxIdCompare = Buffer.compare(first.prevTxId, second.prevTxId);
+                const prevTxIdCompare = BufferUtil.compare(first.prevTxId, second.prevTxId);
                 if (prevTxIdCompare !== 0)
                     return prevTxIdCompare;
                 const outputIndexCompare = first.outputIndex - second.outputIndex;
@@ -682,7 +689,7 @@ export class Transaction {
                 const satoshisCompare = first.satoshis - second.satoshis;
                 if (satoshisCompare !== 0)
                     return satoshisCompare;
-                const scriptCompare = Buffer.compare(first.scriptBuffer, second.scriptBuffer);
+                const scriptCompare = BufferUtil.compare(first.scriptBuffer, second.scriptBuffer);
                 if (scriptCompare !== 0)
                     return scriptCompare;
                 return (first.i -
@@ -817,13 +824,10 @@ export class Transaction {
             try {
                 const verifyFlags = flags !== undefined
                     ? flags
-                    : Interpreter.SCRIPT_VERIFY_P2SH |
-                        Interpreter.SCRIPT_VERIFY_STRICTENC |
-                        Interpreter.SCRIPT_VERIFY_DERSIG |
-                        Interpreter.SCRIPT_VERIFY_LOW_S |
-                        Interpreter.SCRIPT_VERIFY_NULLFAIL |
-                        Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID |
-                        Interpreter.SCRIPT_ENABLE_SCHNORR_MULTISIG;
+                    : Interpreter.SCRIPT_ENABLE_SIGHASH_FORKID |
+                        Interpreter.SCRIPT_VERIFY_CLEANSTACK |
+                        Interpreter.SCRIPT_VERIFY_DISCOURAGE_UPGRADABLE_NOPS |
+                        Interpreter.SCRIPT_VERIFY_INPUT_SIGCHECKS;
                 const interpreter = new Interpreter();
                 const isValid = interpreter.verify(input.script, input.output.script, this, i, verifyFlags, BigInt(input.output.satoshis));
                 if (!isValid) {
@@ -870,11 +874,14 @@ export class Transaction {
     _fromNonP2SH(utxo) {
         let clazz;
         const unspentOutput = new UnspentOutput(utxo);
-        if (unspentOutput.script.isPayToTaproot()) {
+        if (unspentOutput.script.isTaprootOut()) {
             if (unspentOutput.keyAggContext &&
                 unspentOutput.mySignerIndex !== undefined) {
-                clazz = MuSigTaprootInput;
-                const input = new MuSigTaprootInput({
+                if (!unspentOutput.internalPubKey || !unspentOutput.merkleRoot) {
+                    throw new BitcoreError('MuSig2 Taproot input requires internalPubKey and merkleRoot');
+                }
+                clazz = MuSig2TaprootInput;
+                const input = new MuSig2TaprootInput({
                     output: new Output({
                         script: unspentOutput.script,
                         satoshis: unspentOutput.satoshis,
@@ -884,10 +891,15 @@ export class Transaction {
                     script: new Script(),
                     keyAggContext: unspentOutput.keyAggContext,
                     mySignerIndex: unspentOutput.mySignerIndex,
+                    internalPubKey: unspentOutput.internalPubKey,
+                    merkleRoot: unspentOutput.merkleRoot,
                 });
                 this.addInput(input);
                 return;
             }
+            if (!unspentOutput.internalPubKey) {
+                throw new BitcoreError('Taproot input requires internalPubKey');
+            }
             clazz = TaprootInput;
             const taprootInput = new TaprootInput({
                 output: new Output({
@@ -898,12 +910,12 @@ export class Transaction {
                 outputIndex: unspentOutput.outputIndex,
                 script: new Script(),
                 internalPubKey: unspentOutput.internalPubKey,
-                merkleRoot: unspentOutput.merkleRoot || Buffer.alloc(32),
+                merkleRoot: unspentOutput.merkleRoot || BufferUtil.alloc(32),
             });
             this.addInput(taprootInput);
             return;
         }
-        else if (unspentOutput.script.isPayToPublicKeyHash()) {
+        else if (unspentOutput.script.isPublicKeyHashOut()) {
             clazz = PublicKeyHashInput;
         }
         else if (unspentOutput.script.isPublicKeyOut()) {
@@ -936,7 +948,7 @@ export class Transaction {
                 script: new Script(),
             }), pubkeys, threshold, undefined, opts));
         }
-        else if (unspentOutput.script.isPayToScriptHash()) {
+        else if (unspentOutput.script.isScriptHashOut()) {
             this.addInput(new MultisigScriptHashInput(new Input({
                 output: new Output({
                     script: unspentOutput.script,

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

@@ -1,9 +1,10 @@
-import { Preconditions } from '../util/preconditions.js';
-import { JSUtil } from '../util/js.js';
-import { Script } from '../script.js';
-import { Address } from '../address.js';
-import { PublicKey } from '../publickey.js';
-import { Unit } from '../unit.js';
+import { Preconditions } from '../util/preconditions';
+import { BufferUtil } from '../util/buffer';
+import { JSUtil } from '../util/js';
+import { Script } from '../script';
+import { Address } from '../address';
+import { PublicKey } from '../publickey';
+import { Unit } from '../unit';
 export class UnspentOutput {
     address;
     txId;
@@ -18,7 +19,7 @@ export class UnspentOutput {
         Preconditions.checkArgument(typeof data === 'object' && data !== null, 'Must provide an object from where to extract data');
         const address = data.address ? new Address(data.address) : undefined;
         const txId = data.txid || data.txId;
-        if (!txId || !JSUtil.isHexaString(txId) || txId.length > 64) {
+        if (!txId || !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;
@@ -51,7 +52,7 @@ export class UnspentOutput {
             if (data.internalPubKey instanceof PublicKey) {
                 this.internalPubKey = data.internalPubKey;
             }
-            else if (Buffer.isBuffer(data.internalPubKey)) {
+            else if (BufferUtil.isBuffer(data.internalPubKey)) {
                 this.internalPubKey = new PublicKey(data.internalPubKey);
             }
             else if (typeof data.internalPubKey === 'string') {
@@ -69,7 +70,7 @@ export class UnspentOutput {
         return Unit.fromSatoshis(this.satoshis);
     }
     isValid() {
-        return (JSUtil.isHexaString(this.txId) &&
+        return (JSUtil.isHexa(this.txId) &&
             this.txId.length === 64 &&
             this.outputIndex >= 0 &&
             this.satoshis > 0 &&
@@ -116,10 +117,13 @@ export 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/esm/lib/bitcore/util/bits.js

@@ -0,0 +1,27 @@
+export 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;
+}
+export 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;
+}
+export function extractBit(bytes, position) {
+    return (bytes[position >> 3] & (1 << (position & 7))) !== 0;
+}
+export 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/esm/lib/bitcore/util/buffer.js

@@ -1,8 +1,7 @@
-import { Preconditions } from './preconditions.js';
+import { Buffer } from 'buffer/';
 export class BufferUtil {
+    static Buffer = Buffer;
     static fill(buffer, value) {
-        Preconditions.checkArgumentType(buffer, 'Buffer', 'buffer');
-        Preconditions.checkArgumentType(value, 'number', 'value');
         const length = buffer.length;
         for (let i = 0; i < length; i++) {
             buffer[i] = value;
@@ -18,13 +17,15 @@ export class BufferUtil {
         return Buffer.isBuffer(arg) || arg instanceof Uint8Array;
     }
     static emptyBuffer(bytes) {
-        Preconditions.checkArgumentType(bytes, 'number', 'bytes');
         const result = Buffer.alloc(bytes);
         for (let i = 0; i < bytes; i++) {
             result.write('\0', i);
         }
         return result;
     }
+    static alloc(size, fill) {
+        return Buffer.alloc(size, fill);
+    }
     static concat(list, totalLength) {
         return Buffer.concat(list, totalLength);
     }
@@ -44,11 +45,9 @@ export class BufferUtil {
         return BufferUtil.equals(a, b);
     }
     static integerAsSingleByteBuffer(integer) {
-        Preconditions.checkArgumentType(integer, 'number', 'integer');
         return Buffer.from([integer & 0xff]);
     }
     static integerAsBuffer(integer) {
-        Preconditions.checkArgumentType(integer, 'number', 'integer');
         const bytes = [];
         bytes.push((integer >> 24) & 0xff);
         bytes.push((integer >> 16) & 0xff);
@@ -57,20 +56,32 @@ export class BufferUtil {
         return Buffer.from(bytes);
     }
     static integerFromBuffer(buffer) {
-        Preconditions.checkArgumentType(buffer, 'Buffer', 'buffer');
         return (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
     }
     static integerFromSingleByteBuffer(buffer) {
-        Preconditions.checkArgumentType(buffer, 'Buffer', 'buffer');
         return buffer[0];
     }
     static bufferToHex(buffer) {
-        Preconditions.checkArgumentType(buffer, 'Buffer', 'buffer');
         return buffer.toString('hex');
     }
     static reverse(param) {
         return Buffer.from(param).reverse();
     }
+    static from(data, byteOffsetOrEncoding, length) {
+        if (Array.isArray(data)) {
+            return Buffer.from(data);
+        }
+        if (typeof data === 'string') {
+            return Buffer.from(data, (byteOffsetOrEncoding || 'utf8'));
+        }
+        if (data instanceof ArrayBuffer) {
+            return Buffer.from(data, byteOffsetOrEncoding, length);
+        }
+        return Buffer.from(data);
+    }
+    static compare(buf1, buf2) {
+        return Buffer.compare(buf1, buf2);
+    }
 }
 export const NULL_HASH = BufferUtil.fill(Buffer.alloc(32), 0);
 export const EMPTY_BUFFER = Buffer.alloc(0);

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

@@ -5,9 +5,6 @@ export 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/esm/lib/bitcore/util/merkle.js

@@ -0,0 +1,47 @@
+import { Hash } from '../crypto/hash';
+import { BufferUtil } from './buffer';
+export function calcTreeWidth(nLeaves, height) {
+    return (nLeaves + (1 << height) - 1) >> height;
+}
+export function calcTreeHeight(nLeaves) {
+    let height = 0;
+    while (calcTreeWidth(nLeaves, height) > 1) {
+        height++;
+    }
+    return height;
+}
+export function calcMerkleHash(height, pos, hashes, nullHash = 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.sha256sha256(BufferUtil.concat([
+        BufferUtil.from(left, 'hex'),
+        BufferUtil.from(right, 'hex'),
+    ])).toString('hex');
+}
+export function traverseAndBuild(height, pos, nLeaves, hashes, vfMatch, vBits, vHash, nullHash = 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/esm/lib/bitcore/util/preconditions.js

@@ -1,4 +1,5 @@
-import { BitcoreError } from '../errors.js';
+import { BitcoreError } from '../errors';
+import { BufferUtil } from './buffer';
 export class Preconditions {
     static checkState(condition, message) {
         if (!condition) {
@@ -14,7 +15,7 @@ export class Preconditions {
         argumentName = argumentName || '(unknown name)';
         if (typeof type === 'string') {
             if (type === 'Buffer') {
-                if (!Buffer.isBuffer(argument)) {
+                if (!BufferUtil.isBuffer(argument)) {
                     throw new BitcoreError.Precondition.InvalidArgumentType(argument, type, argumentName);
                 }
             }

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

@@ -1,3 +1,4 @@
+import { Buffer } from 'buffer/';
 import { Preconditions } from './util/preconditions.js';
 import { Base58 } from './encoding/base58.js';
 import { BufferWriter } from './encoding/bufferwriter.js';
@@ -5,8 +6,6 @@ import { Networks } from './networks.js';
 import { Hash } from './crypto/hash.js';
 import { JSUtil } from './util/js.js';
 import { BufferUtil } from './util/buffer.js';
-const TOKEN_NAME = 'lotus';
-const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
 export class XAddress {
     static PayToPublicKeyHash = 'pubkeyhash';
     static PayToScriptHash = 'scripthash';
@@ -15,7 +14,7 @@ export class XAddress {
     hashBuffer;
     network;
     type;
-    constructor(data, network, type, prefix = TOKEN_NAME) {
+    constructor(data, network, type, prefix = 'lotus') {
         if (data instanceof XAddress) {
             return data;
         }
@@ -96,7 +95,7 @@ export 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)) {
             throw new TypeError('XAddress supplied is not a buffer.');
@@ -188,7 +187,7 @@ function createChecksum(prefix, networkChar, typeByte, payload) {
         typeByte,
         payload,
     ]);
-    return Hash.sha256(data).subarray(0, 4);
+    return Hash.sha256(data).slice(0, 4);
 }
 function createChecksumLegacy(prefix, networkChar, typeByte, payload) {
     const bw = new BufferWriter();
@@ -199,7 +198,7 @@ function createChecksumLegacy(prefix, networkChar, typeByte, payload) {
     bw.writeVarintNum(payload.length);
     bw.write(payload);
     const buf = bw.concat();
-    return Hash.sha256(buf).subarray(0, 4);
+    return Hash.sha256(buf).slice(0, 4);
 }
 function getType(typeByte) {
     switch (typeByte) {
@@ -210,7 +209,7 @@ function getType(typeByte) {
         case 2:
             return 'taproot';
     }
-    return 'pubkeyhash';
+    return null;
 }
 function getTypeByte(type) {
     switch (type) {
@@ -263,15 +262,20 @@ function decode(address) {
     const networkChar = address.substring(splitLocation, splitLocation + 1);
     const encodedPayload = address.substring(splitLocation + 1);
     const decodedBytes = 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.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.checkArgument(validChecksum, 'checksum', 'Invalid checksum: ' + address);
+    const type = getType(typeByte[0]);
+    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;
 }