xpi-ts 0.2.0

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

@@ -0,0 +1,76 @@
+import { Preconditions } from './preconditions.js';
+export class BufferUtil {
+    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;
+        }
+        return buffer;
+    }
+    static copy(original) {
+        const buffer = Buffer.alloc(original.length);
+        original.copy(buffer);
+        return buffer;
+    }
+    static isBuffer(arg) {
+        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 concat(list, totalLength) {
+        return Buffer.concat(list, totalLength);
+    }
+    static equals(a, b) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        const length = a.length;
+        for (let i = 0; i < length; i++) {
+            if (a[i] !== b[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static equal(a, b) {
+        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);
+        bytes.push((integer >> 8) & 0xff);
+        bytes.push(integer & 0xff);
+        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();
+    }
+}
+export const NULL_HASH = BufferUtil.fill(Buffer.alloc(32), 0);
+export const EMPTY_BUFFER = Buffer.alloc(0);

package/dist/lib/bitcore/util/convertBits.d.ts

@@ -0,0 +1,2 @@
+export declare function convertBits(data: number[], from: number, to: number, strict?: boolean): number[];
+//# sourceMappingURL=convertBits.d.ts.map

package/dist/lib/bitcore/util/convertBits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertBits.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/util/convertBits.ts"],"names":[],"mappings":"AAkBA,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EAAE,EACd,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,MAAM,GAAE,OAAe,GACtB,MAAM,EAAE,CAkCV"}

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

@@ -0,0 +1,26 @@
+import { Preconditions } from './preconditions.js';
+export function convertBits(data, from, to, strict = false) {
+    let accumulator = 0;
+    let bits = 0;
+    const result = [];
+    const mask = (1 << to) - 1;
+    for (let i = 0; i < data.length; i++) {
+        const value = data[i];
+        Preconditions.checkArgument(!(value < 0 || value >> from !== 0), 'value', `value ${value}`);
+        accumulator = (accumulator << from) | value;
+        bits += from;
+        while (bits >= to) {
+            bits -= to;
+            result.push((accumulator >> bits) & mask);
+        }
+    }
+    if (!strict) {
+        if (bits > 0) {
+            result.push((accumulator << (to - bits)) & mask);
+        }
+    }
+    else {
+        Preconditions.checkState(!(bits >= from || (accumulator << (to - bits)) & mask), 'Conversion requires padding but strict mode was used');
+    }
+    return result;
+}

package/dist/lib/bitcore/util/js.d.ts

@@ -0,0 +1,9 @@
+export declare class JSUtil {
+    static isHexa(value: string): boolean;
+    static isHexaString(str: string): boolean;
+    static isValidJSON(arg: string): boolean;
+    static cloneArray<T>(arr: T[]): T[];
+    static isNaturalNumber(value: unknown): boolean;
+    static defineImmutable(obj: object, properties: Record<string, unknown>): object;
+}
+//# sourceMappingURL=js.d.ts.map

package/dist/lib/bitcore/util/js.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"js.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/util/js.ts"],"names":[],"mappings":"AAKA,qBAAa,MAAM;IAIjB,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAOrC,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAOzC,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAexC,MAAM,CAAC,UAAU,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE;IAOnC,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAc/C,MAAM,CAAC,eAAe,CACpB,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,MAAM;CAWV"}

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

@@ -0,0 +1,45 @@
+export class JSUtil {
+    static isHexa(value) {
+        if (typeof value !== 'string') {
+            return false;
+        }
+        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;
+        }
+        try {
+            const parsed = JSON.parse(arg);
+            return typeof parsed === 'object';
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    static cloneArray(arr) {
+        return [...arr];
+    }
+    static isNaturalNumber(value) {
+        return ((typeof value === 'number' &&
+            isFinite(value) &&
+            Math.floor(value) === value &&
+            value >= 0) ||
+            (typeof value === 'string' && /^[0-9]+$/.test(value)) ||
+            (typeof value === 'bigint' && value >= 0n));
+    }
+    static defineImmutable(obj, properties) {
+        Object.keys(properties).forEach(key => {
+            Object.defineProperty(obj, key, {
+                value: properties[key],
+                writable: false,
+                enumerable: true,
+                configurable: false,
+            });
+        });
+        return obj;
+    }
+}

package/dist/lib/bitcore/util/preconditions.d.ts

@@ -0,0 +1,6 @@
+export declare class Preconditions {
+    static checkState(condition: boolean, message: string): void;
+    static checkArgument(condition: boolean, argumentName: string, message?: string, docsPath?: string): void;
+    static checkArgumentType(argument: unknown, type: string | ((...args: unknown[]) => unknown), argumentName?: string): void;
+}
+//# sourceMappingURL=preconditions.d.ts.map

package/dist/lib/bitcore/util/preconditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preconditions.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/util/preconditions.ts"],"names":[],"mappings":"AAOA,qBAAa,aAAa;IACxB,MAAM,CAAC,UAAU,CAAC,SAAS,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAM5D,MAAM,CAAC,aAAa,CAClB,SAAS,EAAE,OAAO,EAClB,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,MAAM,GAChB,IAAI;IAUP,MAAM,CAAC,iBAAiB,CACtB,QAAQ,EAAE,OAAO,EACjB,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,CAAC,EAChD,YAAY,CAAC,EAAE,MAAM,GACpB,IAAI;CA6BR"}

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

@@ -0,0 +1,31 @@
+import { BitcoreError } from '../errors.js';
+export class Preconditions {
+    static checkState(condition, message) {
+        if (!condition) {
+            throw new BitcoreError.Precondition.InvalidState(message);
+        }
+    }
+    static checkArgument(condition, argumentName, message, docsPath) {
+        if (!condition) {
+            throw new 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 BitcoreError.Precondition.InvalidArgumentType(argument, type, argumentName);
+                }
+            }
+            else if (typeof argument !== type) {
+                throw new BitcoreError.Precondition.InvalidArgumentType(argument, type, argumentName);
+            }
+        }
+        else {
+            if (!(argument instanceof type)) {
+                throw new BitcoreError.Precondition.InvalidArgumentType(argument, type.name, argumentName);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+import { BufferUtil } from './util/buffer.js';
+import { JSUtil } from './util/js.js';
+import { Preconditions } from './util/preconditions.js';
+import { Base32 } from './util/base32.js';
+import { convertBits } from './util/convertBits.js';
+export declare const util: {
+    buffer: typeof BufferUtil;
+    js: typeof JSUtil;
+    $: typeof Preconditions;
+    base32: typeof Base32;
+    convertBits: typeof convertBits;
+};
+export { BufferUtil, JSUtil, Preconditions, Base32, convertBits };
+//# sourceMappingURL=util.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../lib/bitcore/util.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAA;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAEnD,eAAO,MAAM,IAAI;;;;;;CAMhB,CAAA;AAGD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,EAAE,WAAW,EAAE,CAAA"}

package/dist/lib/bitcore/util.js

@@ -0,0 +1,13 @@
+import { BufferUtil } from './util/buffer.js';
+import { JSUtil } from './util/js.js';
+import { Preconditions } from './util/preconditions.js';
+import { Base32 } from './util/base32.js';
+import { convertBits } from './util/convertBits.js';
+export const util = {
+    buffer: BufferUtil,
+    js: JSUtil,
+    $: Preconditions,
+    base32: Base32,
+    convertBits: convertBits,
+};
+export { BufferUtil, JSUtil, Preconditions, Base32, convertBits };

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

@@ -0,0 +1,45 @@
+import { Network } from './networks.js';
+import { PublicKey } from './publickey.js';
+export interface XAddressData {
+    hashBuffer?: Buffer;
+    network?: Network;
+    type?: string;
+    prefix?: string;
+}
+export interface XAddressObject {
+    hash: string;
+    type: string;
+    network: string;
+    prefix?: string;
+}
+export type XAddressInput = string | Buffer | XAddressData | PublicKey;
+export declare class XAddress {
+    static readonly PayToPublicKeyHash = "pubkeyhash";
+    static readonly PayToScriptHash = "scripthash";
+    static readonly PayToTaproot = "taproot";
+    readonly prefix: string;
+    readonly hashBuffer: Buffer;
+    readonly network: Network;
+    readonly type: string;
+    constructor(data?: XAddressInput, network?: Network | string, type?: string, prefix?: string);
+    private _classifyArguments;
+    private static _transformObject;
+    private static _classifyFromVersion;
+    private static _transformString;
+    private static _transformBuffer;
+    static fromString(str: string, network?: Network | string, type?: string): XAddress;
+    static fromObject(obj: XAddressObject): XAddress;
+    static getValidationError(data: XAddressInput, network?: Network | string, type?: string): Error | null;
+    static isValid(data: XAddressInput, network?: Network | string, type?: string): boolean;
+    static _decode(address: string): XAddressData;
+    toBuffer(): Buffer;
+    toObject(): XAddressObject;
+    toJSON(): XAddressObject;
+    toXAddress(): string;
+    toString(): string;
+    isPayToPublicKeyHash(): boolean;
+    isPayToScriptHash(): boolean;
+    isPayToTaproot(): boolean;
+    inspect(): string;
+}
+//# sourceMappingURL=xaddress.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"xaddress.d.ts","sourceRoot":"","sources":["../../../lib/bitcore/xaddress.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,OAAO,EAAY,MAAM,eAAe,CAAA;AAIjD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAmB1C,MAAM,WAAW,YAAY;IAI3B,UAAU,CAAC,EAAE,MAAM,CAAA;IAKnB,OAAO,CAAC,EAAE,OAAO,CAAA;IAOjB,IAAI,CAAC,EAAE,MAAM,CAAA;IAKb,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAMD,MAAM,WAAW,cAAc;IAK7B,IAAI,EAAE,MAAM,CAAA;IAMZ,IAAI,EAAE,MAAM,CAAA;IAMZ,OAAO,EAAE,MAAM,CAAA;IAMf,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,YAAY,GAAG,SAAS,CAAA;AAEtE,qBAAa,QAAQ;IAInB,MAAM,CAAC,QAAQ,CAAC,kBAAkB,gBAAe;IAIjD,MAAM,CAAC,QAAQ,CAAC,eAAe,gBAAe;IAI9C,MAAM,CAAC,QAAQ,CAAC,YAAY,aAAY;IAExC,QAAQ,CAAC,MAAM,EAAG,MAAM,CAAA;IACxB,QAAQ,CAAC,UAAU,EAAG,MAAM,CAAA;IAC5B,QAAQ,CAAC,OAAO,EAAG,OAAO,CAAA;IAC1B,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAA;gBAGpB,IAAI,CAAC,EAAE,aAAa,EACpB,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,EAC1B,IAAI,CAAC,EAAE,MAAM,EACb,MAAM,GAAE,MAAmB;IAqE7B,OAAO,CAAC,kBAAkB;IA2B1B,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAuB/B,OAAO,CAAC,MAAM,CAAC,oBAAoB;IAwBnC,OAAO,CAAC,MAAM,CAAC,gBAAgB;IA6B/B,OAAO,CAAC,MAAM,CAAC,gBAAgB;IA+B/B,MAAM,CAAC,UAAU,CACf,GAAG,EAAE,MAAM,EACX,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,EAC1B,IAAI,CAAC,EAAE,MAAM,GACZ,QAAQ;IAQX,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,cAAc,GAAG,QAAQ;IAYhD,MAAM,CAAC,kBAAkB,CACvB,IAAI,EAAE,aAAa,EACnB,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,EAC1B,IAAI,CAAC,EAAE,MAAM,GACZ,KAAK,GAAG,IAAI;IAYf,MAAM,CAAC,OAAO,CACZ,IAAI,EAAE,aAAa,EACnB,OAAO,CAAC,EAAE,OAAO,GAAG,MAAM,EAC1B,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO;IAOV,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY;IAO7C,QAAQ,IAAI,MAAM;IAWlB,QAAQ,IAAI,cAAc;IAS1B,MAAM,IAAI,cAAc;IAUxB,UAAU,IAAI,MAAM;IAepB,QAAQ,IAAI,MAAM;IAOlB,oBAAoB,IAAI,OAAO;IAO/B,iBAAiB,IAAI,OAAO;IAO5B,cAAc,IAAI,OAAO;IAOzB,OAAO,IAAI,MAAM;CAGlB"}

package/dist/lib/bitcore/xaddress.js

@@ -0,0 +1,279 @@
+import { Preconditions } from './util/preconditions.js';
+import { Base58 } from './encoding/base58.js';
+import { BufferWriter } from './encoding/bufferwriter.js';
+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';
+    static PayToTaproot = 'taproot';
+    prefix;
+    hashBuffer;
+    network;
+    type;
+    constructor(data, network, type, prefix = TOKEN_NAME) {
+        if (data instanceof XAddress) {
+            return data;
+        }
+        Preconditions.checkArgument(data !== undefined, 'data', 'First argument is required, please include address data.', 'guide/address.html');
+        const networkExplicitlyProvided = network !== undefined;
+        network ||= Networks.defaultNetwork.name;
+        if (network && !Networks.get(network)) {
+            throw new TypeError('Second argument must be "livenet", "testnet", or "regtest".');
+        }
+        if (type &&
+            type !== XAddress.PayToPublicKeyHash &&
+            type !== XAddress.PayToScriptHash &&
+            type !== XAddress.PayToTaproot) {
+            throw new TypeError('Third argument must be "pubkeyhash", "scripthash", or "taproot".');
+        }
+        const info = this._classifyArguments(data, network, type, prefix, networkExplicitlyProvided);
+        info.network =
+            info.network || Networks.get(network) || Networks.defaultNetwork;
+        info.type = info.type || type || XAddress.PayToPublicKeyHash;
+        JSUtil.defineImmutable(this, {
+            prefix: info.prefix,
+            hashBuffer: info.hashBuffer,
+            network: info.network,
+            type: info.type,
+        });
+    }
+    _classifyArguments(data, network, type, prefix, networkExplicitlyProvided = true) {
+        if (typeof data === 'string') {
+            return XAddress._transformString(data, networkExplicitlyProvided ? network : undefined, type);
+        }
+        else if (Buffer.isBuffer(data) || data instanceof Uint8Array) {
+            return XAddress._transformBuffer(data, network, type, prefix);
+        }
+        else if (typeof data === 'object' && data !== null) {
+            return XAddress._transformObject(data);
+        }
+        else {
+            throw new TypeError('First argument is an unrecognized data format.');
+        }
+    }
+    static _transformObject(data) {
+        Preconditions.checkArgument(data.hashBuffer !== undefined, 'data', 'Must provide a `hash` or `hashBuffer` property');
+        Preconditions.checkArgument(data.type !== undefined, 'data', 'Must provide a `type` property');
+        return {
+            hashBuffer: data.hashBuffer || Buffer.from(data.hashBuffer.toString(), 'hex'),
+            network: Networks.get(data.network) || Networks.defaultNetwork,
+            type: data.type,
+            prefix: data.prefix,
+        };
+    }
+    static _classifyFromVersion(buffer) {
+        const version = {};
+        const pubkeyhashNetwork = Networks.get(buffer[0], 'pubkeyhash');
+        const scripthashNetwork = Networks.get(buffer[0], 'scripthash');
+        if (pubkeyhashNetwork) {
+            version.network = pubkeyhashNetwork;
+            version.type = XAddress.PayToPublicKeyHash;
+        }
+        else if (scripthashNetwork) {
+            version.network = scripthashNetwork;
+            version.type = XAddress.PayToScriptHash;
+        }
+        return version;
+    }
+    static _transformString(data, network, type) {
+        if (typeof data !== 'string') {
+            throw new TypeError('data parameter supplied is not a string.');
+        }
+        data = data.trim();
+        const networkObj = Networks.get(network);
+        if (network && !networkObj) {
+            throw new TypeError('Unknown network');
+        }
+        const info = XAddress._decode(data);
+        if (!info.network ||
+            (networkObj && networkObj.name !== info.network.name)) {
+            throw new TypeError('Address has mismatched network type.');
+        }
+        return info;
+    }
+    static _transformBuffer(buffer, network, type, prefix = TOKEN_NAME) {
+        const info = {};
+        if (!Buffer.isBuffer(buffer) && !(buffer instanceof Uint8Array)) {
+            throw new TypeError('XAddress supplied is not a buffer.');
+        }
+        const networkObj = Networks.get(network);
+        if (network && !networkObj) {
+            throw new TypeError('Unknown network');
+        }
+        if (type === undefined) {
+            throw new TypeError('Unknown type.');
+        }
+        info.prefix = prefix;
+        info.hashBuffer = Buffer.from(buffer);
+        info.network = networkObj || Networks.defaultNetwork;
+        info.type = type;
+        return info;
+    }
+    static fromString(str, network, type) {
+        const info = XAddress._transformString(str, network, type);
+        return new XAddress(info.hashBuffer, info.network, info.type);
+    }
+    static fromObject(obj) {
+        Preconditions.checkState(JSUtil.isHexa(obj.hash), 'Unexpected hash property, "' + obj.hash + '", expected to be hex.');
+        const hashBuffer = Buffer.from(obj.hash, 'hex');
+        return new XAddress(hashBuffer, obj.network, obj.type, obj.prefix);
+    }
+    static getValidationError(data, network, type) {
+        try {
+            new XAddress(data, network, type);
+            return null;
+        }
+        catch (e) {
+            return e;
+        }
+    }
+    static isValid(data, network, type) {
+        return !XAddress.getValidationError(data, network, type);
+    }
+    static _decode(address) {
+        return decode(address);
+    }
+    toBuffer() {
+        const version = Buffer.from([
+            this.network[this.type],
+        ]);
+        const buf = Buffer.concat([version, this.hashBuffer]);
+        return buf;
+    }
+    toObject() {
+        return {
+            prefix: this.prefix,
+            hash: this.hashBuffer.toString('hex'),
+            type: this.type,
+            network: this.network.toString(),
+        };
+    }
+    toJSON() {
+        return this.toObject();
+    }
+    toXAddress() {
+        const prefix = this.prefix;
+        const networkChar = getNetworkChar(this.network);
+        const networkByte = Buffer.from(networkChar);
+        const typeByte = Buffer.from([getTypeByte(this.type)]);
+        const payload = this.hashBuffer;
+        const checksum = createChecksum(prefix, networkByte, typeByte, payload);
+        const encodedPayload = encodePayload(typeByte, payload, checksum);
+        return prefix + networkChar + encodedPayload;
+    }
+    toString() {
+        return this.toXAddress();
+    }
+    isPayToPublicKeyHash() {
+        return this.type === XAddress.PayToPublicKeyHash;
+    }
+    isPayToScriptHash() {
+        return this.type === XAddress.PayToScriptHash;
+    }
+    isPayToTaproot() {
+        return this.type === XAddress.PayToTaproot;
+    }
+    inspect() {
+        return '<XAddress: ' + this.toString() + ', type: ' + this.type + '>';
+    }
+}
+function createChecksum(prefix, networkByte, typeByte, payload) {
+    const data = BufferUtil.concat([
+        Buffer.from(prefix),
+        networkByte,
+        typeByte,
+        payload,
+    ]);
+    return Hash.sha256(data).subarray(0, 4);
+}
+function createChecksumLegacy(prefix, networkByte, typeByte, payload) {
+    const bw = new BufferWriter();
+    bw.writeVarintNum(prefix.length);
+    bw.write(Buffer.from(prefix));
+    bw.writeUInt8(networkByte[0]);
+    bw.writeUInt8(typeByte[0]);
+    bw.writeVarintNum(payload.length);
+    bw.write(payload);
+    const buf = bw.concat();
+    return Hash.sha256(buf).subarray(0, 4);
+}
+function getType(typeByte) {
+    switch (typeByte) {
+        case 0:
+            return 'pubkeyhash';
+        case 1:
+            return 'scripthash';
+        case 2:
+            return 'taproot';
+    }
+    return 'pubkeyhash';
+}
+function getTypeByte(type) {
+    switch (type) {
+        case 'pubkeyhash':
+        case 'scripthash':
+            return 0;
+        case 'taproot':
+            return 2;
+    }
+    return 0;
+}
+function getNetworkFromChar(networkChar) {
+    switch (networkChar) {
+        case '_':
+            return Networks.get('livenet');
+        case 'T':
+            return Networks.get('testnet');
+        case 'R':
+            return Networks.get('regtest');
+        default:
+            throw new TypeError('Unknown network type: ' + networkChar);
+    }
+}
+function getNetworkChar(network) {
+    if (network.name === 'livenet') {
+        return '_';
+    }
+    else if (network.name === 'testnet') {
+        return 'T';
+    }
+    else if (network.name === 'regtest') {
+        return 'R';
+    }
+    else {
+        throw new TypeError('Unknown network: ' + network.name);
+    }
+}
+function encodePayload(typeByte, payload, checksum) {
+    const bw = new BufferWriter();
+    bw.writeUInt8(typeByte[0]);
+    bw.write(payload);
+    bw.write(checksum);
+    const buf = bw.concat();
+    return Base58.encode(buf);
+}
+function decode(address) {
+    const match = /[A-Z]|_/.exec(address);
+    const splitLocation = match ? match.index : 0;
+    const prefix = address.substring(0, splitLocation);
+    const networkChar = address.substring(splitLocation, splitLocation + 1);
+    const networkByte = Buffer.from(networkChar);
+    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 checksum = createChecksum(prefix, networkByte, typeByte, payload);
+    Preconditions.checkArgument(checksum.toString('hex') === decodedChecksum.toString('hex'), 'checksum', 'Invalid checksum: ' + address);
+    const info = {};
+    info.hashBuffer = payload;
+    info.network = getNetworkFromChar(networkChar);
+    info.type = getType(typeByte[0]);
+    info.prefix = prefix;
+    return info;
+}

package/dist/lib/rank/api.d.ts

@@ -0,0 +1,75 @@
+export type InstanceData = {
+    instanceId: string;
+    runtimeId: string;
+    startTime: string;
+    nonce: number;
+};
+export type AuthorizationData = {
+    instanceId: string;
+    scriptPayload: string;
+    blockhash: string;
+    blockheight: string;
+};
+export type PostMeta = {
+    hasWalletUpvoted: boolean;
+    hasWalletDownvoted: boolean;
+    txidsUpvoted: string[];
+    txidsDownvoted: string[];
+};
+export type TransactionAPI = {
+    txid: string;
+    outIdx: number;
+    sats: string;
+    firstSeen: string;
+    scriptPayload: string;
+    instanceId?: string;
+    height?: number;
+    timestamp?: string;
+};
+export type TransactionRANKAPI = TransactionAPI & {
+    sentiment: string;
+    platform: string;
+    profileId: string;
+    postId?: string;
+};
+export type TransactionRNKCAPI = TransactionAPI & {
+    data: string;
+    feeRate: number;
+    platform: string;
+    inReplyToProfileId?: string;
+    inReplyToPostId?: string;
+    repliedProfile?: ProfileAPI;
+    repliedPost?: PostAPI;
+};
+export type ParametersAPI = {
+    platform: string;
+    profileId: string;
+};
+export type ProfileAPI = ParametersAPI & {
+    ranking: string;
+    satsPositive: string;
+    satsNegative: string;
+    votesPositive: number;
+    votesNegative: number;
+    ranks?: TransactionRANKAPI[];
+    comments?: TransactionRNKCAPI[];
+    posts?: PostAPI[];
+};
+export type PostAPI = ParametersAPI & {
+    ranking: string;
+    satsPositive: string;
+    satsNegative: string;
+    votesPositive: number;
+    votesNegative: number;
+    profile: ProfileAPI;
+    postId: string;
+    ranks?: TransactionRANKAPI[];
+    comments?: TransactionRNKCAPI[];
+    data?: string;
+    postMeta?: PostMeta;
+};
+export declare const AuthenticateHeader: {
+    scheme: string;
+    param: string[];
+};
+//# sourceMappingURL=api.d.ts.map

package/dist/lib/rank/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../lib/rank/api.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG;IACzB,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AACD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,UAAU,EAAE,MAAM,CAAA;IAClB,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,gBAAgB,EAAE,OAAO,CAAA;IACzB,kBAAkB,EAAE,OAAO,CAAA;IAC3B,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,cAAc,EAAE,MAAM,EAAE,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;IACrB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AACD,MAAM,MAAM,kBAAkB,GAAG,cAAc,GAAG;IAChD,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG,cAAc,GAAG;IAChD,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,cAAc,CAAC,EAAE,UAAU,CAAA;IAC3B,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,aAAa,GAAG;IACvC,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IAErB,KAAK,CAAC,EAAE,kBAAkB,EAAE,CAAA;IAE5B,QAAQ,CAAC,EAAE,kBAAkB,EAAE,CAAA;IAE/B,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,OAAO,GAAG,aAAa,GAAG;IACpC,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IACrB,OAAO,EAAE,UAAU,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;IAEd,KAAK,CAAC,EAAE,kBAAkB,EAAE,CAAA;IAE5B,QAAQ,CAAC,EAAE,kBAAkB,EAAE,CAAA;IAE/B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,QAAQ,CAAA;CACpB,CAAA;AAGD,eAAO,MAAM,kBAAkB;;;CAG9B,CAAA"}

package/dist/lib/rank/api.js

@@ -0,0 +1,4 @@
+export const AuthenticateHeader = {
+    scheme: 'BlockDataSig',
+    param: ['blockhash', 'blockheight'],
+};