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

package/protocols/ICoinOnlineProtocol.d.ts

@@ -0,0 +1,46 @@
+import { AirGapTransactionStatus, IAirGapTransactionResult } from '../interfaces/IAirGapTransaction';
+import { IProtocolTransactionCursor } from './../interfaces/IAirGapTransaction';
+import { FeeDefaults, ICoinBaseProtocol } from './ICoinBaseProtocol';
+import { ICoinSubProtocol } from './ICoinSubProtocol';
+export interface ICoinOnlineProtocol extends ICoinBaseProtocol {
+    getBlockExplorerLinkForAddress(address: string): Promise<string>;
+    getBlockExplorerLinkForTxId(txId: string): Promise<string>;
+    getTransactionsFromPublicKey(publicKey: string, limit: number, cursor?: IProtocolTransactionCursor): Promise<IAirGapTransactionResult>;
+    getTransactionsFromExtendedPublicKey(extendedPublicKey: string, limit: number, cursor?: IProtocolTransactionCursor): Promise<IAirGapTransactionResult>;
+    getTransactionsFromAddresses(addresses: string[], limit: number, cursor?: IProtocolTransactionCursor): Promise<IAirGapTransactionResult>;
+    getBalanceOfAddresses(addresses: string[], data?: {
+        [key: string]: unknown;
+    }): Promise<string>;
+    getBalanceOfPublicKey(publicKey: string, data?: {
+        addressIndex?: number;
+        [key: string]: unknown;
+    }): Promise<string>;
+    getBalanceOfExtendedPublicKey(extendedPublicKey: string, offset: number, data?: {
+        [key: string]: unknown;
+    }): Promise<string>;
+    getAvailableBalanceOfAddresses(addresses: string[], data?: {
+        [key: string]: unknown;
+    }): Promise<string>;
+    getTransactionStatuses(transactionHash: string[]): Promise<AirGapTransactionStatus[]>;
+    getBalanceOfPublicKeyForSubProtocols(publicKey: string, subProtocols: ICoinSubProtocol[]): Promise<string[]>;
+    estimateMaxTransactionValueFromExtendedPublicKey(extendedPublicKey: string, recipients: string[], fee?: string, data?: {
+        [key: string]: unknown;
+    }): Promise<string>;
+    estimateMaxTransactionValueFromPublicKey(publicKey: string, recipients: string[], fee?: string, data?: {
+        addressIndex?: number;
+        [key: string]: unknown;
+    }): Promise<string>;
+    estimateFeeDefaultsFromExtendedPublicKey(publicKey: string, recipients: string[], values: string[], data?: {
+        [key: string]: unknown;
+    }): Promise<FeeDefaults>;
+    estimateFeeDefaultsFromPublicKey(publicKey: string, recipients: string[], values: string[], data?: {
+        [key: string]: unknown;
+    }): Promise<FeeDefaults>;
+    prepareTransactionFromExtendedPublicKey(extendedPublicKey: string, offset: number, recipients: string[], values: string[], fee: string, extras?: {
+        [key: string]: unknown;
+    }): Promise<any>;
+    prepareTransactionFromPublicKey(publicKey: string, recipients: string[], values: string[], fee: string, extras?: {
+        [key: string]: unknown;
+    }): Promise<any>;
+    broadcastTransaction(rawTransaction: any): Promise<string>;
+}

package/protocols/ICoinOnlineProtocol.js

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

package/protocols/ICoinOnlineProtocol.js.map

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

package/protocols/ICoinProtocol.d.ts

@@ -0,0 +1,9 @@
+import { ICoinOfflineProtocol } from './ICoinOfflineProtocol';
+import { ICoinOnlineProtocol } from './ICoinOnlineProtocol';
+export { FeeDefaults } from './ICoinBaseProtocol';
+export interface CurrencyUnit {
+    unitSymbol: string;
+    factor: string;
+}
+export interface ICoinProtocol extends ICoinOnlineProtocol, ICoinOfflineProtocol {
+}

package/protocols/ICoinProtocol.js

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

package/protocols/ICoinProtocol.js.map

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

package/protocols/ICoinSubProtocol.d.ts

@@ -0,0 +1,22 @@
+import { ICoinProtocol } from './ICoinProtocol';
+export declare enum SubProtocolType {
+    ACCOUNT = "account",
+    TOKEN = "token"
+}
+export interface ICoinSubProtocol extends ICoinProtocol {
+    /**
+     * @deprecated Use `getIsSubProtocol()` instead.
+     */
+    isSubProtocol: boolean;
+    /**
+     * @deprecated Use `getSubProtocolType()` instead.
+     */
+    subProtocolType: SubProtocolType;
+    /**
+     * @deprecated Use `getContractAddress()` instead.
+     */
+    contractAddress?: string;
+    getIsSubProtocol(): Promise<boolean>;
+    getSubProtocolType(): Promise<SubProtocolType>;
+    getContractAddress(): Promise<string | undefined>;
+}

package/protocols/ICoinSubProtocol.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubProtocolType = void 0;
+var SubProtocolType;
+(function (SubProtocolType) {
+    SubProtocolType["ACCOUNT"] = "account";
+    SubProtocolType["TOKEN"] = "token";
+})(SubProtocolType = exports.SubProtocolType || (exports.SubProtocolType = {}));
+//# sourceMappingURL=ICoinSubProtocol.js.map

package/protocols/ICoinSubProtocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ICoinSubProtocol.js","sourceRoot":"","sources":["../../src/protocols/ICoinSubProtocol.ts"],"names":[],"mappings":";;;AAEA,IAAY,eAGX;AAHD,WAAY,eAAe;IACzB,sCAAmB,CAAA;IACnB,kCAAe,CAAA;AACjB,CAAC,EAHW,eAAe,GAAf,uBAAe,KAAf,uBAAe,QAG1B"}

package/protocols/NonExtendedProtocol.d.ts

@@ -0,0 +1,17 @@
+import { IAirGapAddressResult } from '../interfaces/IAirGapAddress';
+import { IAirGapTransactionResult, IProtocolTransactionCursor } from '../interfaces/IAirGapTransaction';
+import { FeeDefaults } from './ICoinProtocol';
+export declare abstract class NonExtendedProtocol {
+    getExtendedPublicKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string): Promise<string>;
+    getExtendedPublicKeyFromHexSecret(secret: string, derivationPath: string): Promise<string>;
+    getExtendedPrivateKeyFromMnemonic(mnemonic: string, derivationPath: string, password?: string): Promise<string>;
+    getExtendedPrivateKeyFromHexSecret(secret: string, derivationPath: string): Promise<string>;
+    getBalanceOfExtendedPublicKey(extendedPublicKey: string, offset: number): Promise<string>;
+    signWithExtendedPrivateKey(extendedPrivateKey: string, transaction: any, childDerivationPath: string): Promise<string>;
+    getAddressFromExtendedPublicKey(extendedPublicKey: string, visibilityDerivationIndex: number, addressDerivationIndex: number): Promise<IAirGapAddressResult>;
+    getAddressesFromExtendedPublicKey(extendedPublicKey: string, visibilityDerivationIndex: number, addressCount: number, offset: number): Promise<IAirGapAddressResult[]>;
+    estimateMaxTransactionValueFromExtendedPublicKey(extendedPublicKey: string, recipients: string[], fee: string): Promise<string>;
+    estimateFeeDefaultsFromExtendedPublicKey(publicKey: string, recipients: string[], values: string[], data?: any): Promise<FeeDefaults>;
+    getTransactionsFromExtendedPublicKey(extendedPublicKey: string, limit: number, cursor: IProtocolTransactionCursor): Promise<IAirGapTransactionResult>;
+    prepareTransactionFromExtendedPublicKey(extendedPublicKey: string, offset: number, recipients: string[], values: string[], fee: string): Promise<any>;
+}

package/protocols/NonExtendedProtocol.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonExtendedProtocol = void 0;
+var NonExtendedProtocol = /** @class */ (function () {
+    function NonExtendedProtocol() {
+    }
+    NonExtendedProtocol.prototype.getExtendedPublicKeyFromMnemonic = function (mnemonic, derivationPath, password) {
+        throw Promise.reject('extended public key support not implemented');
+    };
+    NonExtendedProtocol.prototype.getExtendedPublicKeyFromHexSecret = function (secret, derivationPath) {
+        throw Promise.reject('extended public key support not implemented');
+    };
+    NonExtendedProtocol.prototype.getExtendedPrivateKeyFromMnemonic = function (mnemonic, derivationPath, password) {
+        throw Promise.reject('extended private key support not implemented');
+    };
+    NonExtendedProtocol.prototype.getExtendedPrivateKeyFromHexSecret = function (secret, derivationPath) {
+        throw Promise.reject('extended private key support not implemented');
+    };
+    NonExtendedProtocol.prototype.getBalanceOfExtendedPublicKey = function (extendedPublicKey, offset) {
+        return Promise.reject('extended public balance not implemented');
+    };
+    NonExtendedProtocol.prototype.signWithExtendedPrivateKey = function (extendedPrivateKey, transaction, childDerivationPath) {
+        return Promise.reject('extended private key signing for not implemented');
+    };
+    NonExtendedProtocol.prototype.getAddressFromExtendedPublicKey = function (extendedPublicKey, visibilityDerivationIndex, addressDerivationIndex) {
+        return Promise.resolve({
+            address: '',
+            cursor: { hasNext: false }
+        });
+    };
+    NonExtendedProtocol.prototype.getAddressesFromExtendedPublicKey = function (extendedPublicKey, visibilityDerivationIndex, addressCount, offset) {
+        return Promise.resolve([]);
+    };
+    NonExtendedProtocol.prototype.estimateMaxTransactionValueFromExtendedPublicKey = function (extendedPublicKey, recipients, fee) {
+        return Promise.reject('estimating max value using extended public key not implemented');
+    };
+    NonExtendedProtocol.prototype.estimateFeeDefaultsFromExtendedPublicKey = function (publicKey, recipients, values, data) {
+        return Promise.reject('estimating fee defaults using extended public key not implemented');
+    };
+    NonExtendedProtocol.prototype.getTransactionsFromExtendedPublicKey = function (extendedPublicKey, limit, cursor) {
+        return Promise.reject('fetching txs using extended public key not implemented');
+    };
+    NonExtendedProtocol.prototype.prepareTransactionFromExtendedPublicKey = function (extendedPublicKey, offset, recipients, values, fee) {
+        return Promise.reject('extended public key tx not implemented');
+    };
+    return NonExtendedProtocol;
+}());
+exports.NonExtendedProtocol = NonExtendedProtocol;
+//# sourceMappingURL=NonExtendedProtocol.js.map

package/protocols/NonExtendedProtocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NonExtendedProtocol.js","sourceRoot":"","sources":["../../src/protocols/NonExtendedProtocol.ts"],"names":[],"mappings":";;;AAKA;IAAA;IA2EA,CAAC;IA1EQ,8DAAgC,GAAvC,UAAwC,QAAgB,EAAE,cAAsB,EAAE,QAAiB;QACjG,MAAM,OAAO,CAAC,MAAM,CAAC,6CAA6C,CAAC,CAAA;IACrE,CAAC;IAEM,+DAAiC,GAAxC,UAAyC,MAAc,EAAE,cAAsB;QAC7E,MAAM,OAAO,CAAC,MAAM,CAAC,6CAA6C,CAAC,CAAA;IACrE,CAAC;IAEM,+DAAiC,GAAxC,UAAyC,QAAgB,EAAE,cAAsB,EAAE,QAAiB;QAClG,MAAM,OAAO,CAAC,MAAM,CAAC,8CAA8C,CAAC,CAAA;IACtE,CAAC;IAEM,gEAAkC,GAAzC,UAA0C,MAAc,EAAE,cAAsB;QAC9E,MAAM,OAAO,CAAC,MAAM,CAAC,8CAA8C,CAAC,CAAA;IACtE,CAAC;IAEM,2DAA6B,GAApC,UAAqC,iBAAyB,EAAE,MAAc;QAC5E,OAAO,OAAO,CAAC,MAAM,CAAC,yCAAyC,CAAC,CAAA;IAClE,CAAC;IAEM,wDAA0B,GAAjC,UAAkC,kBAA0B,EAAE,WAAgB,EAAE,mBAA2B;QACzG,OAAO,OAAO,CAAC,MAAM,CAAC,kDAAkD,CAAC,CAAA;IAC3E,CAAC;IAEM,6DAA+B,GAAtC,UACE,iBAAyB,EACzB,yBAAiC,EACjC,sBAA8B;QAE9B,OAAO,OAAO,CAAC,OAAO,CAAC;YACrB,OAAO,EAAE,EAAE;YACX,MAAM,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE;SAC3B,CAAC,CAAA;IACJ,CAAC;IAEM,+DAAiC,GAAxC,UACE,iBAAyB,EACzB,yBAAiC,EACjC,YAAoB,EACpB,MAAc;QAEd,OAAO,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;IAC5B,CAAC;IAEM,8EAAgD,GAAvD,UAAwD,iBAAyB,EAAE,UAAoB,EAAE,GAAW;QAClH,OAAO,OAAO,CAAC,MAAM,CAAC,gEAAgE,CAAC,CAAA;IACzF,CAAC;IAEM,sEAAwC,GAA/C,UACE,SAAiB,EACjB,UAAoB,EACpB,MAAgB,EAChB,IAAU;QAEV,OAAO,OAAO,CAAC,MAAM,CAAC,mEAAmE,CAAC,CAAA;IAC5F,CAAC;IAEM,kEAAoC,GAA3C,UACE,iBAAyB,EACzB,KAAa,EACb,MAAkC;QAElC,OAAO,OAAO,CAAC,MAAM,CAAC,wDAAwD,CAAC,CAAA;IACjF,CAAC;IAEM,qEAAuC,GAA9C,UACE,iBAAyB,EACzB,MAAc,EACd,UAAoB,EACpB,MAAgB,EAChB,GAAW;QAEX,OAAO,OAAO,CAAC,MAAM,CAAC,wCAAwC,CAAC,CAAA;IACjE,CAAC;IACH,0BAAC;AAAD,CAAC,AA3ED,IA2EC;AA3EqB,kDAAmB"}

package/protocols/Secp256k1CryptoClient.d.ts

@@ -0,0 +1,8 @@
+import { CryptoClient } from './CryptoClient';
+export declare abstract class Secp256k1CryptoClient extends CryptoClient {
+    encryptAsymmetric(payload: string, publicKey: string): Promise<string>;
+    decryptAsymmetric(encryptedPayload: string, keypair: {
+        publicKey: string;
+        privateKey: string;
+    }): Promise<string>;
+}

package/protocols/Secp256k1CryptoClient.js

@@ -0,0 +1,79 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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.Secp256k1CryptoClient = void 0;
+var index_1 = require("../dependencies/src/eciesjs-0.3.9/src/index");
+var CryptoClient_1 = require("./CryptoClient");
+var Secp256k1CryptoClient = /** @class */ (function (_super) {
+    __extends(Secp256k1CryptoClient, _super);
+    function Secp256k1CryptoClient() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Secp256k1CryptoClient.prototype.encryptAsymmetric = function (payload, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, (0, index_1.encrypt)(publicKey, Buffer.from(payload)).toString('hex')];
+            });
+        });
+    };
+    Secp256k1CryptoClient.prototype.decryptAsymmetric = function (encryptedPayload, keypair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, (0, index_1.decrypt)(keypair.privateKey, Buffer.from(encryptedPayload, 'hex')).toString()];
+            });
+        });
+    };
+    return Secp256k1CryptoClient;
+}(CryptoClient_1.CryptoClient));
+exports.Secp256k1CryptoClient = Secp256k1CryptoClient;
+//# sourceMappingURL=Secp256k1CryptoClient.js.map

package/protocols/Secp256k1CryptoClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Secp256k1CryptoClient.js","sourceRoot":"","sources":["../../src/protocols/Secp256k1CryptoClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,qEAA8E;AAE9E,+CAA6C;AAE7C;IAAoD,yCAAY;IAAhE;;IAQA,CAAC;IAPc,iDAAiB,GAA9B,UAA+B,OAAe,EAAE,SAAiB;;;gBAC/D,sBAAO,IAAA,eAAO,EAAC,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAA;;;KAChE;IAEY,iDAAiB,GAA9B,UAA+B,gBAAwB,EAAE,OAAkD;;;gBACzG,sBAAO,IAAA,eAAO,EAAC,OAAO,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC,CAAC,QAAQ,EAAE,EAAA;;;KACpF;IACH,4BAAC;AAAD,CAAC,AARD,CAAoD,2BAAY,GAQ/D;AARqB,sDAAqB"}

package/protocols/Sr25519CryptoClient.d.ts

@@ -0,0 +1,8 @@
+import { CryptoClient } from './CryptoClient';
+export declare abstract class Sr25519CryptoClient extends CryptoClient {
+    encryptAsymmetric(payload: string, publicKey: string): Promise<string>;
+    decryptAsymmetric(encryptedPayload: string, keypair: {
+        publicKey: string;
+        privateKey: string;
+    }): Promise<string>;
+}

package/protocols/Sr25519CryptoClient.js

@@ -0,0 +1,82 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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.Sr25519CryptoClient = void 0;
+var errors_1 = require("../errors");
+var coinlib_error_1 = require("../errors/coinlib-error");
+var CryptoClient_1 = require("./CryptoClient");
+var Sr25519CryptoClient = /** @class */ (function (_super) {
+    __extends(Sr25519CryptoClient, _super);
+    function Sr25519CryptoClient() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Sr25519CryptoClient.prototype.encryptAsymmetric = function (payload, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                // Currently not supported: https://github.com/polkadot-js/common/issues/633
+                throw new errors_1.NotImplementedError(coinlib_error_1.Domain.UTILS, "encryptAsymmetric() not implemented.");
+            });
+        });
+    };
+    Sr25519CryptoClient.prototype.decryptAsymmetric = function (encryptedPayload, keypair) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                // Currently not supported: https://github.com/polkadot-js/common/issues/633
+                throw new errors_1.NotImplementedError(coinlib_error_1.Domain.UTILS, "decryptAsymmetric() not implemented.");
+            });
+        });
+    };
+    return Sr25519CryptoClient;
+}(CryptoClient_1.CryptoClient));
+exports.Sr25519CryptoClient = Sr25519CryptoClient;
+//# sourceMappingURL=Sr25519CryptoClient.js.map

package/protocols/Sr25519CryptoClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sr25519CryptoClient.js","sourceRoot":"","sources":["../../src/protocols/Sr25519CryptoClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,oCAA+C;AAC/C,yDAAgD;AAChD,+CAA6C;AAE7C;IAAkD,uCAAY;IAA9D;;IAUA,CAAC;IATc,+CAAiB,GAA9B,UAA+B,OAAe,EAAE,SAAiB;;;gBAC/D,4EAA4E;gBAC5E,MAAM,IAAI,4BAAmB,CAAC,sBAAM,CAAC,KAAK,EAAE,sCAAsC,CAAC,CAAA;;;KACpF;IAEY,+CAAiB,GAA9B,UAA+B,gBAAwB,EAAE,OAAkD;;;gBACzG,4EAA4E;gBAC5E,MAAM,IAAI,4BAAmB,CAAC,sBAAM,CAAC,KAAK,EAAE,sCAAsC,CAAC,CAAA;;;KACpF;IACH,0BAAC;AAAD,CAAC,AAVD,CAAkD,2BAAY,GAU7D;AAVqB,kDAAmB"}

package/types/signed-transaction.d.ts

@@ -0,0 +1,4 @@
+export interface SignedTransaction {
+    transaction: string;
+    accountIdentifier: string;
+}

package/types/signed-transaction.js

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

package/types/signed-transaction.js.map

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

package/types/unsigned-transaction.d.ts

@@ -0,0 +1,5 @@
+export interface UnsignedTransaction {
+    transaction: any;
+    publicKey: string;
+    callbackURL?: string;
+}

package/types/unsigned-transaction.js

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

package/types/unsigned-transaction.js.map

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

package/utils/AES.d.ts

@@ -0,0 +1,10 @@
+export declare class AES {
+    readonly AES_KEY_SIZE: number;
+    readonly KEY_DERIVATION_ITERATION_COUNT: number;
+    readonly ALGORITHM: 'aes-256-gcm';
+    readonly encoding: 'base64' | 'hex';
+    constructor(AES_KEY_SIZE?: number, KEY_DERIVATION_ITERATION_COUNT?: number, ALGORITHM?: 'aes-256-gcm', encoding?: 'base64' | 'hex');
+    encryptString(plainText: string, privateKey: string): Promise<string>;
+    decryptString(encryptedValue: string, privateKey: string): Promise<string>;
+    private deriveKeyFromPrivateKey;
+}

package/utils/AES.js

@@ -0,0 +1,165 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.AES = void 0;
+var crypto = __importStar(require("crypto"));
+var errors_1 = require("../errors");
+var coinlib_error_1 = require("../errors/coinlib-error");
+var hex_1 = require("./hex");
+// https://github.com/microsoft/botbuilder-js/blob/master/libraries/botframework-config/src/encrypt.ts#L20
+var AES = /** @class */ (function () {
+    function AES(AES_KEY_SIZE, KEY_DERIVATION_ITERATION_COUNT, ALGORITHM, encoding) {
+        if (AES_KEY_SIZE === void 0) { AES_KEY_SIZE = 256; }
+        if (KEY_DERIVATION_ITERATION_COUNT === void 0) { KEY_DERIVATION_ITERATION_COUNT = 10000; }
+        if (ALGORITHM === void 0) { ALGORITHM = 'aes-256-gcm'; }
+        if (encoding === void 0) { encoding = 'hex'; }
+        this.AES_KEY_SIZE = AES_KEY_SIZE;
+        this.KEY_DERIVATION_ITERATION_COUNT = KEY_DERIVATION_ITERATION_COUNT;
+        this.ALGORITHM = ALGORITHM;
+        this.encoding = encoding;
+    }
+    AES.prototype.encryptString = function (plainText, privateKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var keyBytes, ivBytes, ivText, cipher, encryptedValue, authTagText;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!plainText || plainText.length === 0) {
+                            throw new errors_1.ConditionViolationError(coinlib_error_1.Domain.UTILS, 'you must pass an input message');
+                        }
+                        if (!privateKey || privateKey.length === 0) {
+                            throw new errors_1.ConditionViolationError(coinlib_error_1.Domain.UTILS, 'you must pass a privateKey');
+                        }
+                        return [4 /*yield*/, this.deriveKeyFromPrivateKey(privateKey)
+                            // Generates 16 byte cryptographically strong pseudo-random data as IV
+                            // https://nodejs.org/api/crypto.html#crypto_crypto_randombytes_size_callback
+                        ];
+                    case 1:
+                        keyBytes = _a.sent();
+                        ivBytes = crypto.randomBytes(16);
+                        ivText = ivBytes.toString(this.encoding);
+                        cipher = crypto.createCipheriv(this.ALGORITHM, keyBytes, ivBytes);
+                        encryptedValue = cipher.update(plainText, 'utf8', this.encoding);
+                        encryptedValue += cipher.final(this.encoding);
+                        authTagText = cipher.getAuthTag().toString(this.encoding);
+                        return [2 /*return*/, "".concat(ivText, "!").concat(encryptedValue, "!").concat(authTagText)];
+                }
+            });
+        });
+    };
+    AES.prototype.decryptString = function (encryptedValue, privateKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var parts, ivText, encryptedText, authTagText, ivBytes, keyBytes, authTagBytes, decipher, value;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!encryptedValue || encryptedValue.length === 0) {
+                            return [2 /*return*/, encryptedValue];
+                        }
+                        if (!privateKey || privateKey.length === 0) {
+                            throw new errors_1.ConditionViolationError(coinlib_error_1.Domain.UTILS, 'you must pass a privateKey');
+                        }
+                        parts = encryptedValue.split('!');
+                        if (parts.length !== 3) {
+                            throw new errors_1.ConditionViolationError(coinlib_error_1.Domain.UTILS, 'The encrypted value is not in a valid format');
+                        }
+                        ivText = parts[0];
+                        encryptedText = parts[1];
+                        authTagText = parts[2];
+                        ivBytes = Buffer.from(ivText, this.encoding);
+                        return [4 /*yield*/, this.deriveKeyFromPrivateKey(privateKey)];
+                    case 1:
+                        keyBytes = _a.sent();
+                        authTagBytes = Buffer.from(authTagText, this.encoding);
+                        if (ivBytes.length !== 16) {
+                            throw new errors_1.InvalidValueError(coinlib_error_1.Domain.UTILS, 'The IV length is invalid');
+                        }
+                        if (keyBytes.length !== 32) {
+                            throw new errors_1.InvalidValueError(coinlib_error_1.Domain.UTILS, 'The key length is invalid');
+                        }
+                        if (authTagBytes.length !== 16) {
+                            throw new errors_1.InvalidValueError(coinlib_error_1.Domain.UTILS, 'The authtag length is invalid');
+                        }
+                        decipher = crypto.createDecipheriv(this.ALGORITHM, keyBytes, ivBytes);
+                        decipher.setAuthTag(authTagBytes);
+                        value = decipher.update(encryptedText, this.encoding, 'utf8');
+                        value += decipher.final('utf8');
+                        return [2 /*return*/, value];
+                }
+            });
+        });
+    };
+    AES.prototype.deriveKeyFromPrivateKey = function (privateKey) {
+        var _this = this;
+        var password = (0, hex_1.isHex)(privateKey) ? Buffer.from(privateKey, 'hex') : privateKey;
+        return new Promise(function (resolve, reject) {
+            crypto.pbkdf2(password, '', _this.KEY_DERIVATION_ITERATION_COUNT, 32, 'sha512', function (pbkdf2Error, key) {
+                if (pbkdf2Error) {
+                    reject(pbkdf2Error);
+                }
+                resolve(key);
+            });
+        });
+    };
+    return AES;
+}());
+exports.AES = AES;
+//# sourceMappingURL=AES.js.map

package/utils/AES.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AES.js","sourceRoot":"","sources":["../../src/utils/AES.ts"],"names":[],"mappings":"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"}

package/utils/ErrorWithData.d.ts

@@ -0,0 +1,4 @@
+export declare class ErrorWithData extends Error {
+    data: unknown;
+    constructor(message: string, data: unknown);
+}

package/utils/ErrorWithData.js

@@ -0,0 +1,29 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorWithData = void 0;
+var ErrorWithData = /** @class */ (function (_super) {
+    __extends(ErrorWithData, _super);
+    function ErrorWithData(message, data) {
+        var _this = _super.call(this, message) || this;
+        _this.data = data;
+        return _this;
+    }
+    return ErrorWithData;
+}(Error));
+exports.ErrorWithData = ErrorWithData;
+//# sourceMappingURL=ErrorWithData.js.map

package/utils/ErrorWithData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ErrorWithData.js","sourceRoot":"","sources":["../../src/utils/ErrorWithData.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAAA;IAAmC,iCAAK;IAEtC,uBAAY,OAAe,EAAE,IAAa;QAA1C,YACE,kBAAM,OAAO,CAAC,SAEf;QADC,KAAI,CAAC,IAAI,GAAG,IAAI,CAAA;;IAClB,CAAC;IACH,oBAAC;AAAD,CAAC,AAND,CAAmC,KAAK,GAMvC;AANY,sCAAa"}