@airgap/coinlib-core 0.13.11-beta.1 → 0.13.11-beta.2

package/utils/Network.d.ts

@@ -0,0 +1,2 @@
+import { ProtocolNetwork } from './ProtocolNetwork';
+export declare const isNetworkEqual: (network1: ProtocolNetwork, network2: ProtocolNetwork) => boolean;

package/utils/Network.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNetworkEqual = void 0;
+var isNetworkEqual = function (network1, network2) {
+    return network1.name === network2.name && network1.type === network2.type && network1.rpcUrl === network2.rpcUrl;
+};
+exports.isNetworkEqual = isNetworkEqual;
+//# sourceMappingURL=Network.js.map

package/utils/Network.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Network.js","sourceRoot":"","sources":["../../src/utils/Network.ts"],"names":[],"mappings":";;;AAEO,IAAM,cAAc,GAAsE,UAC/F,QAAyB,EACzB,QAAyB;IAEzB,OAAO,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,IAAI,QAAQ,CAAC,IAAI,KAAK,QAAQ,CAAC,IAAI,IAAI,QAAQ,CAAC,MAAM,KAAK,QAAQ,CAAC,MAAM,CAAA;AAClH,CAAC,CAAA;AALY,QAAA,cAAc,kBAK1B"}

package/utils/ProtocolBlockExplorer.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class ProtocolBlockExplorer {
+    readonly blockExplorer: string;
+    constructor(blockExplorer: string);
+    abstract getAddressLink(address: string): Promise<string>;
+    abstract getTransactionLink(transactionId: string): Promise<string>;
+}

package/utils/ProtocolBlockExplorer.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtocolBlockExplorer = void 0;
+var ProtocolBlockExplorer = /** @class */ (function () {
+    function ProtocolBlockExplorer(blockExplorer) {
+        this.blockExplorer = blockExplorer;
+    }
+    return ProtocolBlockExplorer;
+}());
+exports.ProtocolBlockExplorer = ProtocolBlockExplorer;
+//# sourceMappingURL=ProtocolBlockExplorer.js.map

package/utils/ProtocolBlockExplorer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolBlockExplorer.js","sourceRoot":"","sources":["../../src/utils/ProtocolBlockExplorer.ts"],"names":[],"mappings":";;;AAAA;IACE,+BAA4B,aAAqB;QAArB,kBAAa,GAAb,aAAa,CAAQ;IAAG,CAAC;IAIvD,4BAAC;AAAD,CAAC,AALD,IAKC;AALqB,sDAAqB"}

package/utils/ProtocolNetwork.d.ts

@@ -0,0 +1,15 @@
+import { ProtocolBlockExplorer } from './ProtocolBlockExplorer';
+export declare enum NetworkType {
+    MAINNET = "MAINNET",
+    TESTNET = "TESTNET",
+    CUSTOM = "CUSTOM"
+}
+export declare abstract class ProtocolNetwork<T = unknown> {
+    readonly name: string;
+    readonly type: NetworkType;
+    readonly rpcUrl: string;
+    readonly blockExplorer: ProtocolBlockExplorer;
+    readonly extras: T;
+    get identifier(): string;
+    constructor(name: string, type: NetworkType, rpcUrl: string, blockExplorer: ProtocolBlockExplorer, extras: T);
+}

package/utils/ProtocolNetwork.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProtocolNetwork = exports.NetworkType = void 0;
+var createHash = require("../dependencies/src/create-hash-1.2.0/index");
+var sha256hashShort = function (input) {
+    var hash = createHash('sha256');
+    hash.update(input);
+    return hash.digest('base64').slice(0, 10);
+};
+var NetworkType;
+(function (NetworkType) {
+    NetworkType["MAINNET"] = "MAINNET";
+    NetworkType["TESTNET"] = "TESTNET";
+    NetworkType["CUSTOM"] = "CUSTOM";
+})(NetworkType = exports.NetworkType || (exports.NetworkType = {}));
+var ProtocolNetwork = /** @class */ (function () {
+    function ProtocolNetwork(name, type, rpcUrl, blockExplorer, extras) {
+        this.name = name;
+        this.type = type;
+        this.rpcUrl = rpcUrl;
+        this.blockExplorer = blockExplorer;
+        this.extras = extras;
+    }
+    Object.defineProperty(ProtocolNetwork.prototype, "identifier", {
+        get: function () {
+            var hashed = sha256hashShort("".concat(this.name, "-").concat(this.rpcUrl));
+            return "".concat(this.type, "-").concat(hashed);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return ProtocolNetwork;
+}());
+exports.ProtocolNetwork = ProtocolNetwork;
+//# sourceMappingURL=ProtocolNetwork.js.map

package/utils/ProtocolNetwork.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolNetwork.js","sourceRoot":"","sources":["../../src/utils/ProtocolNetwork.ts"],"names":[],"mappings":";;;AAAA,wEAA0E;AAI1E,IAAM,eAAe,GAA8B,UAAC,KAAa;IAC/D,IAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAA;IACjC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IAElB,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;AAC3C,CAAC,CAAA;AAED,IAAY,WAIX;AAJD,WAAY,WAAW;IACrB,kCAAmB,CAAA;IACnB,kCAAmB,CAAA;IACnB,gCAAiB,CAAA;AACnB,CAAC,EAJW,WAAW,GAAX,mBAAW,KAAX,mBAAW,QAItB;AAED;IAOE,yBACkB,IAAY,EACZ,IAAiB,EACjB,MAAc,EACd,aAAoC,EACpC,MAAS;QAJT,SAAI,GAAJ,IAAI,CAAQ;QACZ,SAAI,GAAJ,IAAI,CAAa;QACjB,WAAM,GAAN,MAAM,CAAQ;QACd,kBAAa,GAAb,aAAa,CAAuB;QACpC,WAAM,GAAN,MAAM,CAAG;IACxB,CAAC;IAZJ,sBAAI,uCAAU;aAAd;YACE,IAAM,MAAM,GAAW,eAAe,CAAC,UAAG,IAAI,CAAC,IAAI,cAAI,IAAI,CAAC,MAAM,CAAE,CAAC,CAAA;YAErE,OAAO,UAAG,IAAI,CAAC,IAAI,cAAI,MAAM,CAAE,CAAA;QACjC,CAAC;;;OAAA;IASH,sBAAC;AAAD,CAAC,AAdD,IAcC;AAdqB,0CAAe"}

package/utils/ProtocolOptions.d.ts

@@ -0,0 +1,5 @@
+import { ProtocolNetwork } from './ProtocolNetwork';
+export interface ProtocolOptions<T = unknown> {
+    network: ProtocolNetwork;
+    config: T;
+}

package/utils/ProtocolOptions.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ProtocolOptions.js.map

package/utils/ProtocolOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolOptions.js","sourceRoot":"","sources":["../../src/utils/ProtocolOptions.ts"],"names":[],"mappings":""}

package/utils/ProtocolSymbols.d.ts

@@ -0,0 +1,45 @@
+export declare enum MainProtocolSymbols {
+    AE = "ae",
+    BTC = "btc",
+    BTC_SEGWIT = "btc_segwit",
+    ETH = "eth",
+    XTZ = "xtz",
+    XTZ_SHIELDED = "xtz_shielded",
+    GRS = "grs",
+    COSMOS = "cosmos",
+    POLKADOT = "polkadot",
+    KUSAMA = "kusama",
+    MOONBASE = "moonbase",
+    MOONRIVER = "moonriver",
+    MOONBEAM = "moonbeam",
+    ASTAR = "astar",
+    SHIDEN = "shiden",
+    ICP = "icp"
+}
+export declare enum SubProtocolSymbols {
+    XTZ_KT = "xtz-kt",
+    XTZ_BTC = "xtz-btc",
+    XTZ_USD = "xtz-usd",
+    XTZ_KUSD = "xtz-kusd",
+    XTZ_STKR = "xtz-stkr",
+    XTZ_ETHTZ = "xtz-eth",
+    XTZ_UUSD = "xtz-uusd",
+    XTZ_YOU = "xtz-you",
+    XTZ_W = "xtz-w",
+    XTZ_UDEFI = "xtz-udefi",
+    XTZ_UBTC = "xtz-ubtc",
+    XTZ_CTEZ = "xtz-ctez",
+    XTZ_PLENTY = "xtz-plenty",
+    XTZ_WRAP = "xtz-wrap",
+    XTZ_QUIPU = "xtz-quipu",
+    XTZ_DOGA = "xtz-doga",
+    XTZ_BTC_TEZ = "xtz-btc-tez",
+    XTZ_USDT = "xtz-usdt",
+    XTZ_SIRS = "xtz-sirs",
+    ETH_ERC20 = "eth-erc20",
+    ETH_ERC20_XCHF = "eth-erc20-xchf"
+}
+export declare type ProtocolSymbols = MainProtocolSymbols | SubProtocolSymbols;
+export declare function isMainProtocolSymbol(identifier: string): identifier is MainProtocolSymbols;
+export declare function isSubProtocolSymbol(identifier: string): identifier is SubProtocolSymbols;
+export declare function isProtocolSymbol(identifier: string): identifier is ProtocolSymbols;

package/utils/ProtocolSymbols.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isProtocolSymbol = exports.isSubProtocolSymbol = exports.isMainProtocolSymbol = exports.SubProtocolSymbols = exports.MainProtocolSymbols = void 0;
+var MainProtocolSymbols;
+(function (MainProtocolSymbols) {
+    MainProtocolSymbols["AE"] = "ae";
+    MainProtocolSymbols["BTC"] = "btc";
+    MainProtocolSymbols["BTC_SEGWIT"] = "btc_segwit";
+    MainProtocolSymbols["ETH"] = "eth";
+    MainProtocolSymbols["XTZ"] = "xtz";
+    MainProtocolSymbols["XTZ_SHIELDED"] = "xtz_shielded";
+    MainProtocolSymbols["GRS"] = "grs";
+    MainProtocolSymbols["COSMOS"] = "cosmos";
+    MainProtocolSymbols["POLKADOT"] = "polkadot";
+    MainProtocolSymbols["KUSAMA"] = "kusama";
+    MainProtocolSymbols["MOONBASE"] = "moonbase";
+    MainProtocolSymbols["MOONRIVER"] = "moonriver";
+    MainProtocolSymbols["MOONBEAM"] = "moonbeam";
+    MainProtocolSymbols["ASTAR"] = "astar";
+    MainProtocolSymbols["SHIDEN"] = "shiden";
+    MainProtocolSymbols["ICP"] = "icp";
+})(MainProtocolSymbols = exports.MainProtocolSymbols || (exports.MainProtocolSymbols = {}));
+var SubProtocolSymbols;
+(function (SubProtocolSymbols) {
+    SubProtocolSymbols["XTZ_KT"] = "xtz-kt";
+    SubProtocolSymbols["XTZ_BTC"] = "xtz-btc";
+    SubProtocolSymbols["XTZ_USD"] = "xtz-usd";
+    SubProtocolSymbols["XTZ_KUSD"] = "xtz-kusd";
+    SubProtocolSymbols["XTZ_STKR"] = "xtz-stkr";
+    SubProtocolSymbols["XTZ_ETHTZ"] = "xtz-eth";
+    SubProtocolSymbols["XTZ_UUSD"] = "xtz-uusd";
+    SubProtocolSymbols["XTZ_YOU"] = "xtz-you";
+    SubProtocolSymbols["XTZ_W"] = "xtz-w";
+    SubProtocolSymbols["XTZ_UDEFI"] = "xtz-udefi";
+    SubProtocolSymbols["XTZ_UBTC"] = "xtz-ubtc";
+    SubProtocolSymbols["XTZ_CTEZ"] = "xtz-ctez";
+    SubProtocolSymbols["XTZ_PLENTY"] = "xtz-plenty";
+    SubProtocolSymbols["XTZ_WRAP"] = "xtz-wrap";
+    SubProtocolSymbols["XTZ_QUIPU"] = "xtz-quipu";
+    SubProtocolSymbols["XTZ_DOGA"] = "xtz-doga";
+    SubProtocolSymbols["XTZ_BTC_TEZ"] = "xtz-btc-tez";
+    SubProtocolSymbols["XTZ_USDT"] = "xtz-usdt";
+    SubProtocolSymbols["XTZ_SIRS"] = "xtz-sirs";
+    SubProtocolSymbols["ETH_ERC20"] = "eth-erc20";
+    SubProtocolSymbols["ETH_ERC20_XCHF"] = "eth-erc20-xchf";
+})(SubProtocolSymbols = exports.SubProtocolSymbols || (exports.SubProtocolSymbols = {}));
+function isMainProtocolSymbol(identifier) {
+    return Object.values(MainProtocolSymbols).includes(identifier);
+}
+exports.isMainProtocolSymbol = isMainProtocolSymbol;
+function isSubProtocolSymbol(identifier) {
+    return Object.values(SubProtocolSymbols).includes(identifier);
+}
+exports.isSubProtocolSymbol = isSubProtocolSymbol;
+function isProtocolSymbol(identifier) {
+    return isMainProtocolSymbol(identifier) || isSubProtocolSymbol(identifier);
+}
+exports.isProtocolSymbol = isProtocolSymbol;
+//# sourceMappingURL=ProtocolSymbols.js.map

package/utils/ProtocolSymbols.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolSymbols.js","sourceRoot":"","sources":["../../src/utils/ProtocolSymbols.ts"],"names":[],"mappings":";;;AAAA,IAAY,mBAiBX;AAjBD,WAAY,mBAAmB;IAC7B,gCAAS,CAAA;IACT,kCAAW,CAAA;IACX,gDAAyB,CAAA;IACzB,kCAAW,CAAA;IACX,kCAAW,CAAA;IACX,oDAA6B,CAAA;IAC7B,kCAAW,CAAA;IACX,wCAAiB,CAAA;IACjB,4CAAqB,CAAA;IACrB,wCAAiB,CAAA;IACjB,4CAAqB,CAAA;IACrB,8CAAuB,CAAA;IACvB,4CAAqB,CAAA;IACrB,sCAAe,CAAA;IACf,wCAAiB,CAAA;IACjB,kCAAW,CAAA;AACb,CAAC,EAjBW,mBAAmB,GAAnB,2BAAmB,KAAnB,2BAAmB,QAiB9B;AAED,IAAY,kBAsBX;AAtBD,WAAY,kBAAkB;IAC5B,uCAAiB,CAAA;IACjB,yCAAmB,CAAA;IACnB,yCAAmB,CAAA;IACnB,2CAAqB,CAAA;IACrB,2CAAqB,CAAA;IACrB,2CAAqB,CAAA;IACrB,2CAAqB,CAAA;IACrB,yCAAmB,CAAA;IACnB,qCAAe,CAAA;IACf,6CAAuB,CAAA;IACvB,2CAAqB,CAAA;IACrB,2CAAqB,CAAA;IACrB,+CAAyB,CAAA;IACzB,2CAAqB,CAAA;IACrB,6CAAuB,CAAA;IACvB,2CAAqB,CAAA;IACrB,iDAA2B,CAAA;IAC3B,2CAAqB,CAAA;IACrB,2CAAqB,CAAA;IACrB,6CAAuB,CAAA;IACvB,uDAAiC,CAAA;AACnC,CAAC,EAtBW,kBAAkB,GAAlB,0BAAkB,KAAlB,0BAAkB,QAsB7B;AAID,SAAgB,oBAAoB,CAAC,UAAkB;IACrD,OAAO,MAAM,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC,QAAQ,CAAC,UAAiC,CAAC,CAAA;AACvF,CAAC;AAFD,oDAEC;AAED,SAAgB,mBAAmB,CAAC,UAAkB;IACpD,OAAO,MAAM,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,QAAQ,CAAC,UAAgC,CAAC,CAAA;AACrF,CAAC;AAFD,kDAEC;AAED,SAAgB,gBAAgB,CAAC,UAAkB;IACjD,OAAO,oBAAoB,CAAC,UAAU,CAAC,IAAI,mBAAmB,CAAC,UAAU,CAAC,CAAA;AAC5E,CAAC;AAFD,4CAEC"}

package/utils/array.d.ts

@@ -0,0 +1,4 @@
+export declare function shuffledArray<T>(array: T[]): T[];
+export declare function chunkedArray<T>(array: T[], chunkSize: number): (T | undefined)[][];
+export declare function flattenArray<T>(array: T[][]): T[];
+export declare function zippedArrays<T, R>(a1: T[], a2: R[]): [T, R][];

package/utils/array.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zippedArrays = exports.flattenArray = exports.chunkedArray = exports.shuffledArray = void 0;
+function shuffledArray(array) {
+    var shuffled = new Array(array.length);
+    for (var i = array.length - 1; i > 0; i--) {
+        var j = Math.floor(Math.random() * (i + 1));
+        shuffled[i] = array[j];
+        shuffled[j] = array[i];
+    }
+    return shuffled;
+}
+exports.shuffledArray = shuffledArray;
+function chunkedArray(array, chunkSize) {
+    var chunkSizeInverse = 1 / chunkSize;
+    var chunks = new Array(Math.ceil(array.length * chunkSizeInverse));
+    for (var i = 0; i < array.length; i += chunkSize) {
+        chunks[Math.floor(i * chunkSizeInverse)] = array.slice(i, i + chunkSize);
+    }
+    return chunks;
+}
+exports.chunkedArray = chunkedArray;
+function flattenArray(array) {
+    return array.reduce(function (flatten, next) { return flatten.concat(next); }, []);
+}
+exports.flattenArray = flattenArray;
+function zippedArrays(a1, a2) {
+    var length = Math.min(a1.length, a2.length);
+    var zipped = new Array(length);
+    for (var i = 0; i < length; i++) {
+        zipped[i] = [a1[i], a2[i]];
+    }
+    return zipped;
+}
+exports.zippedArrays = zippedArrays;
+//# sourceMappingURL=array.js.map

package/utils/array.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.js","sourceRoot":"","sources":["../../src/utils/array.ts"],"names":[],"mappings":";;;AAAA,SAAgB,aAAa,CAAI,KAAU;IACzC,IAAM,QAAQ,GAAQ,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;IAE7C,KAAK,IAAI,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE;QACzC,IAAM,CAAC,GAAW,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;QACrD,QAAQ,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;QACtB,QAAQ,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;KACvB;IAED,OAAO,QAAQ,CAAA;AACjB,CAAC;AAVD,sCAUC;AAED,SAAgB,YAAY,CAAI,KAAU,EAAE,SAAiB;IAC3D,IAAM,gBAAgB,GAAW,CAAC,GAAG,SAAS,CAAA;IAC9C,IAAM,MAAM,GAAwB,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,gBAAgB,CAAC,CAAC,CAAA;IAEzF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,SAAS,EAAE;QAChD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,CAAA;KACzE;IAED,OAAO,MAAM,CAAA;AACf,CAAC;AATD,oCASC;AAED,SAAgB,YAAY,CAAI,KAAY;IAC1C,OAAO,KAAK,CAAC,MAAM,CAAC,UAAC,OAAY,EAAE,IAAS,IAAK,OAAA,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,EAApB,CAAoB,EAAE,EAAE,CAAC,CAAA;AAC5E,CAAC;AAFD,oCAEC;AAED,SAAgB,YAAY,CAAO,EAAO,EAAE,EAAO;IACjD,IAAM,MAAM,GAAW,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,CAAA;IACrD,IAAM,MAAM,GAAa,IAAI,KAAK,CAAC,MAAM,CAAC,CAAA;IAE1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE;QAC/B,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;KAC3B;IAED,OAAO,MAAM,CAAA;AACf,CAAC;AATD,oCASC"}

package/utils/assert.d.ts

@@ -0,0 +1,2 @@
+export declare const assertNever: (x: never) => void;
+export declare function assertFields(name: string, object: any, ...fields: string[]): void;

package/utils/assert.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertFields = exports.assertNever = void 0;
+var errors_1 = require("../errors");
+var coinlib_error_1 = require("../errors/coinlib-error");
+var assertNever = function (x) { return undefined; };
+exports.assertNever = assertNever;
+function assertFields(name, object) {
+    var fields = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        fields[_i - 2] = arguments[_i];
+    }
+    fields.forEach(function (field) {
+        if (object[field] === undefined || object[field] === null) {
+            throw new errors_1.ConditionViolationError(coinlib_error_1.Domain.UTILS, "".concat(name, ", required: ").concat(fields.join(', '), ", but ").concat(field, " is missing."));
+        }
+    });
+}
+exports.assertFields = assertFields;
+//# sourceMappingURL=assert.js.map

package/utils/assert.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.js","sourceRoot":"","sources":["../../src/utils/assert.ts"],"names":[],"mappings":";;;AAAA,oCAAmD;AACnD,yDAAgD;AAEzC,IAAM,WAAW,GAAuB,UAAC,CAAQ,IAAW,OAAA,SAAS,EAAT,CAAS,CAAA;AAA/D,QAAA,WAAW,eAAoD;AAE5E,SAAgB,YAAY,CAAC,IAAY,EAAE,MAAW;IAAE,gBAAmB;SAAnB,UAAmB,EAAnB,qBAAmB,EAAnB,IAAmB;QAAnB,+BAAmB;;IACzE,MAAM,CAAC,OAAO,CAAC,UAAC,KAAa;QAC3B,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,SAAS,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE;YACzD,MAAM,IAAI,gCAAuB,CAAC,sBAAM,CAAC,KAAK,EAAE,UAAG,IAAI,yBAAe,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAS,KAAK,iBAAc,CAAC,CAAA;SACrH;IACH,CAAC,CAAC,CAAA;AACJ,CAAC;AAND,oCAMC"}

package/utils/base64Check.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+declare const bs64check: {
+    encode(input: any): string;
+    decode(input: Buffer | string): Buffer;
+    checkSum: (payload: Buffer | string) => any;
+};
+export default bs64check;

package/utils/base64Check.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var createHash = require("../dependencies/src/create-hash-1.2.0/index");
+var errors_1 = require("../errors");
+var coinlib_error_1 = require("../errors/coinlib-error");
+var sha256hash = function (input) {
+    var hash = createHash('sha256');
+    hash.update(input);
+    return hash.digest();
+};
+var checkSum = function (payload) {
+    return sha256hash(sha256hash(payload)).slice(0, 4);
+};
+var bs64check = {
+    encode: function (input) {
+        if (!Buffer.isBuffer(input)) {
+            input = Buffer.from(input);
+        }
+        var checksum = checkSum(input);
+        var payloadWithChecksum = Buffer.concat([input, checksum], input.length + 4);
+        return payloadWithChecksum.toString('base64');
+    },
+    decode: function (input) {
+        if (!Buffer.isBuffer(input)) {
+            input = Buffer.from(input, 'base64');
+        }
+        var payload = input.slice(0, -4);
+        var checksum = input.slice(-4);
+        var newChecksum = checkSum(payload);
+        // tslint:disable-next-line:no-bitwise
+        if ((checksum[0] ^ newChecksum[0]) | (checksum[1] ^ newChecksum[1]) | (checksum[2] ^ newChecksum[2]) | (checksum[3] ^ newChecksum[3])) {
+            throw new errors_1.ConditionViolationError(coinlib_error_1.Domain.UTILS, 'bs64check checksum does not match');
+        }
+        return payload;
+    },
+    checkSum: checkSum
+};
+exports.default = bs64check;
+//# sourceMappingURL=base64Check.js.map

package/utils/base64Check.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64Check.js","sourceRoot":"","sources":["../../src/utils/base64Check.ts"],"names":[],"mappings":";;AAAA,wEAA0E;AAC1E,oCAAmD;AACnD,yDAAgD;AAEhD,IAAM,UAAU,GAAG,UAAC,KAAK;IACvB,IAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAA;IACjC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IAElB,OAAO,IAAI,CAAC,MAAM,EAAE,CAAA;AACtB,CAAC,CAAA;AAED,IAAM,QAAQ,GAAG,UAAC,OAAwB;IACxC,OAAO,UAAU,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AACpD,CAAC,CAAA;AAED,IAAM,SAAS,GAAG;IAChB,MAAM,YAAC,KAAU;QACf,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;YAC3B,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;SAC3B;QAED,IAAM,QAAQ,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;QAChC,IAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,QAAQ,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;QAE9E,OAAO,mBAAmB,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAA;IAC/C,CAAC;IACD,MAAM,YAAC,KAAsB;QAC3B,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE;YAC3B,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAA;SACrC;QAED,IAAM,OAAO,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;QAClC,IAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;QAChC,IAAM,WAAW,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAA;QAErC,sCAAsC;QACtC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE;YACrI,MAAM,IAAI,gCAAuB,CAAC,sBAAM,CAAC,KAAK,EAAE,mCAAmC,CAAC,CAAA;SACrF;QAED,OAAO,OAAO,CAAA;IAChB,CAAC;IACD,QAAQ,UAAA;CACT,CAAA;AAED,kBAAe,SAAS,CAAA"}

package/utils/blake2b.d.ts

@@ -0,0 +1,7 @@
+export declare function blake2bAsHex(data: Uint8Array | string, bitLength: number, config?: {
+    withPrefix: boolean;
+    key?: Uint8Array;
+}): string;
+export declare function blake2bAsBytes(data: Uint8Array | string, bitLength: number, config?: {
+    key?: Uint8Array;
+}): Uint8Array;

package/utils/blake2b.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blake2bAsBytes = exports.blake2bAsHex = void 0;
+var blake2b = require("../dependencies/src/blake2b-6268e6dd678661e0acc4359e9171b97eb1ebf8ac");
+var hex_1 = require("./hex");
+function blake2bAsHex(data, bitLength, config) {
+    if (config === void 0) { config = { withPrefix: false }; }
+    var hash = blake2bAsBytes(data, bitLength, { key: config.key });
+    var hex = Buffer.from(hash).toString('hex');
+    return config.withPrefix ? (0, hex_1.addHexPrefix)(hex) : hex;
+}
+exports.blake2bAsHex = blake2bAsHex;
+function blake2bAsBytes(data, bitLength, config) {
+    if (config === void 0) { config = {}; }
+    var byteLength = Math.ceil(bitLength / 8);
+    var hashU8a = new Uint8Array(byteLength);
+    var hash = blake2b(byteLength, config.key);
+    hash.update((0, hex_1.hexToBytes)(data));
+    hash.digest(hashU8a);
+    return hashU8a;
+}
+exports.blake2bAsBytes = blake2bAsBytes;
+//# sourceMappingURL=blake2b.js.map

package/utils/blake2b.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blake2b.js","sourceRoot":"","sources":["../../src/utils/blake2b.ts"],"names":[],"mappings":";;;AAAA,8FAAgG;AAEhG,6BAAgD;AAEhD,SAAgB,YAAY,CAC1B,IAAyB,EACzB,SAAiB,EACjB,MAAyE;IAAzE,uBAAA,EAAA,WAAsD,UAAU,EAAE,KAAK,EAAE;IAEzE,IAAM,IAAI,GAAG,cAAc,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,CAAC,CAAA;IACjE,IAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;IAE7C,OAAO,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,IAAA,kBAAY,EAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAA;AACpD,CAAC;AATD,oCASC;AAED,SAAgB,cAAc,CAAC,IAAyB,EAAE,SAAiB,EAAE,MAAiC;IAAjC,uBAAA,EAAA,WAAiC;IAC5G,IAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC,CAAA;IAC3C,IAAM,OAAO,GAAG,IAAI,UAAU,CAAC,UAAU,CAAC,CAAA;IAE1C,IAAM,IAAI,GAAG,OAAO,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG,CAAC,CAAA;IAC5C,IAAI,CAAC,MAAM,CAAC,IAAA,gBAAU,EAAC,IAAI,CAAC,CAAC,CAAA;IAC7B,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;IAEpB,OAAO,OAAO,CAAA;AAChB,CAAC;AATD,wCASC"}

package/utils/buffer.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="node" />
+export declare const bufferFrom: (data: any, encoding: BufferEncoding) => Buffer;

package/utils/buffer.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufferFrom = void 0;
+var bufferFrom = function (data, encoding) {
+    return Buffer.from(data, encoding);
+};
+exports.bufferFrom = bufferFrom;
+//# sourceMappingURL=buffer.js.map

package/utils/buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.js","sourceRoot":"","sources":["../../src/utils/buffer.ts"],"names":[],"mappings":";;;AAAO,IAAM,UAAU,GAAG,UAAC,IAAS,EAAE,QAAwB;IAC5D,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAA;AACpC,CAAC,CAAA;AAFY,QAAA,UAAU,cAEtB"}

package/utils/cache.d.ts

@@ -0,0 +1,15 @@
+interface CacheConfig<T> {
+    cacheValue: boolean;
+    validate?: (value: T) => boolean;
+}
+export declare class Cache {
+    expirationTime: number;
+    constructor(expirationTime: number);
+    private readonly cachedValues;
+    private readonly promises;
+    get<T>(key: string): Promise<T>;
+    save<T>(key: string, promise: Promise<T>, config?: CacheConfig<T>): Promise<T>;
+    delete(key: string): void;
+    private isValidOrDelete;
+}
+export {};

package/utils/cache.js

@@ -0,0 +1,97 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = void 0;
+var Cache = /** @class */ (function () {
+    function Cache(expirationTime) {
+        this.expirationTime = expirationTime;
+        this.cachedValues = new Map();
+        this.promises = new Map();
+    }
+    Cache.prototype.get = function (key) {
+        return __awaiter(this, void 0, void 0, function () {
+            var promise, cached;
+            return __generator(this, function (_a) {
+                promise = this.promises.get(key);
+                if (promise) {
+                    return [2 /*return*/, promise];
+                }
+                cached = this.cachedValues.get(key);
+                if (cached && this.isValidOrDelete(key, cached)) {
+                    return [2 /*return*/, cached.value];
+                }
+                return [2 /*return*/, Promise.reject('No valid cached value.')];
+            });
+        });
+    };
+    Cache.prototype.save = function (key, promise, config) {
+        if (config === void 0) { config = { cacheValue: true }; }
+        return __awaiter(this, void 0, void 0, function () {
+            var newPromise;
+            var _this = this;
+            return __generator(this, function (_a) {
+                newPromise = promise
+                    .then(function (value) {
+                    if (value !== undefined && value !== null && config.cacheValue) {
+                        _this.cachedValues.set(key, {
+                            value: value,
+                            timestamp: new Date().getTime()
+                        });
+                    }
+                    return value;
+                })
+                    .finally(function () { return _this.promises.delete(key); });
+                this.promises.set(key, newPromise);
+                return [2 /*return*/, newPromise];
+            });
+        });
+    };
+    Cache.prototype.delete = function (key) {
+        this.promises.delete(key);
+    };
+    Cache.prototype.isValidOrDelete = function (key, cached) {
+        var expired = cached.timestamp + this.expirationTime < new Date().getTime() || (cached.validate !== undefined && !cached.validate(cached.value));
+        if (expired) {
+            this.cachedValues.delete(key);
+        }
+        return !expired;
+    };
+    return Cache;
+}());
+exports.Cache = Cache;
+//# sourceMappingURL=cache.js.map

package/utils/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../src/utils/cache.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWA;IACE,eAA0B,cAAsB;QAAtB,mBAAc,GAAd,cAAc,CAAQ;QAE/B,iBAAY,GAAkC,IAAI,GAAG,EAAE,CAAA;QACvD,aAAQ,GAA8B,IAAI,GAAG,EAAE,CAAA;IAHb,CAAC;IAKvC,mBAAG,GAAhB,UAAoB,GAAW;;;;gBACvB,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;gBACtC,IAAI,OAAO,EAAE;oBACX,sBAAO,OAAO,EAAA;iBACf;gBAEK,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;gBACzC,IAAI,MAAM,IAAI,IAAI,CAAC,eAAe,CAAC,GAAG,EAAE,MAAM,CAAC,EAAE;oBAC/C,sBAAO,MAAM,CAAC,KAAK,EAAA;iBACpB;gBAED,sBAAO,OAAO,CAAC,MAAM,CAAC,wBAAwB,CAAC,EAAA;;;KAChD;IAEY,oBAAI,GAAjB,UAAqB,GAAW,EAAE,OAAmB,EAAE,MAA6C;QAA7C,uBAAA,EAAA,WAA2B,UAAU,EAAE,IAAI,EAAE;;;;;gBAC5F,UAAU,GAAG,OAAO;qBACvB,IAAI,CAAC,UAAC,KAAK;oBACV,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,IAAI,MAAM,CAAC,UAAU,EAAE;wBAC9D,KAAI,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE;4BACzB,KAAK,OAAA;4BACL,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE;yBAChC,CAAC,CAAA;qBACH;oBAED,OAAO,KAAK,CAAA;gBACd,CAAC,CAAC;qBACD,OAAO,CAAC,cAAM,OAAA,KAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,EAAzB,CAAyB,CAAC,CAAA;gBAE3C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,UAAU,CAAC,CAAA;gBAElC,sBAAO,UAAU,EAAA;;;KAClB;IAEM,sBAAM,GAAb,UAAc,GAAW;QACvB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;IAC3B,CAAC;IAEO,+BAAe,GAAvB,UAAwB,GAAW,EAAE,MAAwB;QAC3D,IAAM,OAAO,GACX,MAAM,CAAC,SAAS,GAAG,IAAI,CAAC,cAAc,GAAG,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;QAEpI,IAAI,OAAO,EAAE;YACX,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;SAC9B;QAED,OAAO,CAAC,OAAO,CAAA;IACjB,CAAC;IACH,YAAC;AAAD,CAAC,AArDD,IAqDC;AArDY,sBAAK"}

package/utils/error.d.ts

@@ -0,0 +1 @@
+export declare function invalidArgumentTypeError(name: string, expected: string, actual: string): Error;

package/utils/error.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invalidArgumentTypeError = void 0;
+function invalidArgumentTypeError(name, expected, actual) {
+    return new Error("".concat(name, ": expected ").concat(expected, " but got ").concat(actual, "."));
+}
+exports.invalidArgumentTypeError = invalidArgumentTypeError;
+//# sourceMappingURL=error.js.map

package/utils/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","sourceRoot":"","sources":["../../src/utils/error.ts"],"names":[],"mappings":";;;AAAA,SAAgB,wBAAwB,CAAC,IAAY,EAAE,QAAgB,EAAE,MAAc;IACrF,OAAO,IAAI,KAAK,CAAC,UAAG,IAAI,wBAAc,QAAQ,sBAAY,MAAM,MAAG,CAAC,CAAA;AACtE,CAAC;AAFD,4DAEC"}

package/utils/hex.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import BigNumber from '../dependencies/src/bignumber.js-9.0.0/bignumber';
+export declare type NumberBytesEncoding = 'default' | '2sComplement';
+export declare function addHexPrefix(raw: string): string;
+export declare function stripHexPrefix(hex: string): string;
+export declare function isHex(value: string): boolean;
+export declare function toHexBuffer(value: number | BigNumber, bitLength?: number, encoding?: NumberBytesEncoding): Buffer;
+export declare function toHexStringRaw(value: number | BigNumber, bitLength?: number, encoding?: NumberBytesEncoding): string;
+export declare function toHexString(value: number | BigNumber, bitLength?: number, encoding?: NumberBytesEncoding): string;
+export declare function hexToBytes(hex: string | Uint8Array | Buffer, bitLength?: number): Buffer;
+export declare function bytesToHex(bytes: Uint8Array | Buffer | string, config?: {
+    withPrefix: boolean;
+}): string;
+export declare function changeEndianness(hex: string): string;