@airgap/aeternity 0.13.7-beta.21 → 0.13.7-beta.23

package/v1/protocol/AeternityCryptoClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AeternityCryptoClient.js","sourceRoot":"","sources":["../../../src/v1/protocol/AeternityCryptoClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,sDAA+D;AAC/D,2EAAkE;AAClE,0FAAwF;AACxF,8CAAiD;AAEjD,IAAM,uBAAuB,GAAG,UAAC,OAAe;IAC9C,IAAM,MAAM,GAAW,MAAM,CAAC,IAAI,CAAC,6BAA6B,EAAE,MAAM,CAAC,CAAA;IACzE,IAAM,aAAa,GAAW,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;IAC1D,IAAI,aAAa,CAAC,MAAM,IAAI,IAAI,EAAE;QAChC,MAAM,IAAI,0BAAiB,CAAC,sBAAM,CAAC,SAAS,EAAE,kBAAkB,CAAC,CAAA;KAClE;IAED,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAA;AAClH,CAAC,CAAA;AAED;IAA2C,yCAAmB;IAC5D;eACE,iBAAO;IACT,CAAC;IAEY,2CAAW,GAAxB,UAAyB,OAAe,EAAE,OAA+B;;;;gBACjE,aAAa,GAAW,uBAAuB,CAAC,OAAO,CAAC,CAAA;gBACxD,YAAY,GAAe,IAAA,cAAI,EAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,CAAC,EAAE,aAAa,CAAC,CAAA;gBAE5F,sBAAO,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAA;;;KACjD;IAEY,6CAAa,GAA1B,UAA2B,OAAe,EAAE,SAAiB,EAAE,SAAiB;;;;gBACxE,YAAY,GAAW,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;gBACpD,aAAa,GAAW,uBAAuB,CAAC,OAAO,CAAC,CAAA;gBAE9D,sBAAO,IAAA,gBAAM,EAAC,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,aAAa,EAAE,YAAY,CAAC,EAAA;;;KAC1E;IACH,4BAAC;AAAD,CAAC,AAlBD,CAA2C,yCAAmB,GAkB7D;AAlBY,sDAAqB"}

package/v1/protocol/AeternityProtocol.d.ts

@@ -0,0 +1,50 @@
+import { Address, AirGapProtocol, AirGapTransaction, AirGapTransactionsWithCursor, Amount, Balance, FeeDefaults, KeyPair, ProtocolMetadata, PublicKey, RecursivePartial, Secret, SecretKey, Signature, TransactionConfiguration, TransactionDetails } from '@airgap/module-kit';
+import { AeternityProtocolNetwork, AeternityProtocolOptions, AeternityUnits } from '../types/protocol';
+import { AeternitySignedTransaction, AeternityTransactionCursor, AeternityUnsignedTransaction } from '../types/transaction';
+export interface AeternityProtocol extends AirGapProtocol<{
+    AddressResult: Address;
+    ProtocolNetwork: AeternityProtocolNetwork;
+    SignedTransaction: AeternitySignedTransaction;
+    TransactionCursor: AeternityTransactionCursor;
+    Units: AeternityUnits;
+    FeeEstimation: FeeDefaults<AeternityUnits>;
+    UnsignedTransaction: AeternityUnsignedTransaction;
+}, 'Crypto', 'FetchDataForAddress'> {
+    convertTransactionToBase58(preparedTx: AeternityUnsignedTransaction): Promise<AeternityUnsignedTransaction>;
+}
+export declare class AeternityProtocolImpl implements AeternityProtocol {
+    private readonly cryptoClient;
+    private readonly options;
+    constructor(options?: RecursivePartial<AeternityProtocolOptions>);
+    private readonly units;
+    private readonly feeDefaults;
+    private readonly metadata;
+    getMetadata(): Promise<ProtocolMetadata<AeternityUnits>>;
+    getAddressFromPublicKey(publicKey: PublicKey): Promise<string>;
+    getDetailsFromTransaction(transaction: AeternitySignedTransaction | AeternityUnsignedTransaction, _publicKey: PublicKey): Promise<AirGapTransaction<AeternityUnits>[]>;
+    private getDetailsFromEncodedTransaction;
+    verifyMessageWithPublicKey(message: string, signature: Signature, publicKey: PublicKey): Promise<boolean>;
+    encryptAsymmetricWithPublicKey(payload: string, publicKey: PublicKey): Promise<string>;
+    getKeyPairFromSecret(secret: Secret, derivationPath?: string): Promise<KeyPair>;
+    private getKeyPairFromHexSecret;
+    private getKeyPairFromMnemonic;
+    signTransactionWithSecretKey(transaction: AeternityUnsignedTransaction, secretKey: SecretKey): Promise<AeternitySignedTransaction>;
+    signMessageWithKeyPair(message: string, keyPair: KeyPair): Promise<Signature>;
+    decryptAsymmetricWithKeyPair(payload: string, keyPair: KeyPair): Promise<string>;
+    encryptAESWithSecretKey(payload: string, secretKey: SecretKey): Promise<string>;
+    decryptAESWithSecretKey(payload: string, secretKey: SecretKey): Promise<string>;
+    getNetwork(): Promise<AeternityProtocolNetwork>;
+    getTransactionsForPublicKey(publicKey: PublicKey, limit: number, cursor?: AeternityTransactionCursor): Promise<AirGapTransactionsWithCursor<AeternityTransactionCursor, AeternityUnits>>;
+    getTransactionsForAddress(address: string, limit: number, cursor?: AeternityTransactionCursor): Promise<AirGapTransactionsWithCursor<AeternityTransactionCursor, AeternityUnits>>;
+    getBalanceOfPublicKey(publicKey: PublicKey): Promise<Balance<AeternityUnits>>;
+    getBalanceOfAddress(address: string): Promise<Balance<AeternityUnits>>;
+    getTransactionMaxAmountWithPublicKey(publicKey: PublicKey, to: string[], configuration?: TransactionConfiguration<AeternityUnits>): Promise<Amount<AeternityUnits>>;
+    getTransactionFeeWithPublicKey(_publicKey: PublicKey, _details: TransactionDetails<AeternityUnits>[]): Promise<FeeDefaults<AeternityUnits>>;
+    prepareTransactionWithPublicKey(publicKey: PublicKey, details: TransactionDetails<AeternityUnits>[], configuration?: TransactionConfiguration<AeternityUnits>): Promise<AeternityUnsignedTransaction>;
+    private networkId;
+    broadcastTransaction(transaction: AeternitySignedTransaction): Promise<string>;
+    convertTransactionToBase58(preparedTx: AeternityUnsignedTransaction): Promise<AeternityUnsignedTransaction>;
+}
+export declare function createAeternityProtocol(options?: RecursivePartial<AeternityProtocolOptions>): AeternityProtocol;
+export declare const AETERNITY_MAINNET_PROTOCOL_NETWORK: AeternityProtocolNetwork;
+export declare function createAeternityProtocolOptions(network?: Partial<AeternityProtocolNetwork>): AeternityProtocolOptions;

package/v1/protocol/AeternityProtocol.js

@@ -0,0 +1,603 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAeternityProtocolOptions = exports.AETERNITY_MAINNET_PROTOCOL_NETWORK = exports.createAeternityProtocol = exports.AeternityProtocolImpl = void 0;
+var coinlib_core_1 = require("@airgap/coinlib-core");
+var index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
+var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+var index_2 = require("@airgap/coinlib-core/dependencies/src/bip39-2.5.0/index");
+var bs58check = __importStar(require("@airgap/coinlib-core/dependencies/src/bs58check-2.1.2/index"));
+var index_3 = require("@airgap/coinlib-core/dependencies/src/hd-wallet-js-b216450e56954a6e82ace0aade9474673de5d9d5/src/index");
+var rlp = __importStar(require("@airgap/coinlib-core/dependencies/src/rlp-2.2.3/index"));
+var errors_1 = require("@airgap/coinlib-core/errors");
+var base64Check_1 = __importDefault(require("@airgap/coinlib-core/utils/base64Check"));
+var hex_1 = require("@airgap/coinlib-core/utils/hex");
+var module_kit_1 = require("@airgap/module-kit");
+var ed25519_1 = require("@stablelib/ed25519");
+var AeternityAddress_1 = require("../data/AeternityAddress");
+var key_1 = require("../utils/key");
+var signature_1 = require("../utils/signature");
+var transaction_1 = require("../utils/transaction");
+var AeternityCryptoClient_1 = require("./AeternityCryptoClient");
+// Implementation
+var AeternityProtocolImpl = /** @class */ (function () {
+    function AeternityProtocolImpl(options) {
+        if (options === void 0) { options = {}; }
+        // Common
+        this.units = {
+            AE: {
+                symbol: { value: 'AE', market: 'ae' },
+                decimals: 18
+            }
+        };
+        this.feeDefaults = {
+            low: (0, module_kit_1.newAmount)(0.00021, 'AE').blockchain(this.units),
+            medium: (0, module_kit_1.newAmount)(0.000315, 'AE').blockchain(this.units),
+            high: (0, module_kit_1.newAmount)(0.00084, 'AE').blockchain(this.units)
+        };
+        this.metadata = {
+            identifier: coinlib_core_1.MainProtocolSymbols.AE,
+            name: 'æternity',
+            units: this.units,
+            mainUnit: 'AE',
+            fee: {
+                defaults: this.feeDefaults
+            },
+            account: {
+                standardDerivationPath: "m/44h/457h/0h/0h/0h",
+                address: {
+                    isCaseSensitive: true,
+                    placeholder: 'ak_abc...',
+                    regex: '^ak_+[1-9A-Za-z]{49,50}$'
+                }
+            },
+            transaction: {
+                arbitraryData: {
+                    inner: { name: 'payload' }
+                }
+            }
+        };
+        this.options = createAeternityProtocolOptions(options.network);
+        this.cryptoClient = new AeternityCryptoClient_1.AeternityCryptoClient();
+    }
+    AeternityProtocolImpl.prototype.getMetadata = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.metadata];
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.getAddressFromPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, AeternityAddress_1.AeternityAddress.from(publicKey).asString()];
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.getDetailsFromTransaction = function (transaction, _publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var rlpEncodedTx, rlpDecodedTx;
+            return __generator(this, function (_a) {
+                switch (transaction.type) {
+                    case 'signed':
+                        rlpEncodedTx = (0, transaction_1.decodeTx)(transaction.transaction);
+                        rlpDecodedTx = rlp.decode(rlpEncodedTx, false);
+                        return [2 /*return*/, this.getDetailsFromEncodedTransaction("tx_".concat(base64Check_1.default.encode(rlpDecodedTx[3])))];
+                    case 'unsigned':
+                        return [2 /*return*/, this.getDetailsFromEncodedTransaction(transaction.transaction)];
+                    default:
+                        (0, coinlib_core_1.assertNever)(transaction);
+                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.AETERNITY, 'Unsupported transaction type.');
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.getDetailsFromEncodedTransaction = function (tx) {
+        return __awaiter(this, void 0, void 0, function () {
+            var rlpEncodedTx, rlpDecodedTx, from, to, airgapTx;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        rlpEncodedTx = (0, transaction_1.decodeTx)(tx);
+                        rlpDecodedTx = rlp.decode(rlpEncodedTx, false);
+                        return [4 /*yield*/, this.getAddressFromPublicKey((0, module_kit_1.newPublicKey)(rlpDecodedTx[2].slice(1).toString('hex'), 'hex'))];
+                    case 1:
+                        from = _a.sent();
+                        return [4 /*yield*/, this.getAddressFromPublicKey((0, module_kit_1.newPublicKey)(rlpDecodedTx[3].slice(1).toString('hex'), 'hex'))];
+                    case 2:
+                        to = _a.sent();
+                        airgapTx = {
+                            from: [from],
+                            to: [to],
+                            isInbound: false,
+                            amount: (0, module_kit_1.newAmount)(parseInt(rlpDecodedTx[4].toString('hex'), 16), 'blockchain'),
+                            fee: (0, module_kit_1.newAmount)(parseInt(rlpDecodedTx[5].toString('hex'), 16), 'blockchain'),
+                            network: this.options.network,
+                            arbitraryData: (rlpDecodedTx[8] || '').toString('utf8')
+                        };
+                        return [2 /*return*/, [airgapTx]];
+                }
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.verifyMessageWithPublicKey = function (message, signature, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexSignature, hexPublicKey;
+            return __generator(this, function (_a) {
+                hexSignature = (0, signature_1.convertSignature)(signature, 'hex');
+                hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
+                return [2 /*return*/, this.cryptoClient.verifyMessage(message, hexSignature.value, hexPublicKey.value)];
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.encryptAsymmetricWithPublicKey = function (payload, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexPublicKey;
+            return __generator(this, function (_a) {
+                hexPublicKey = (0, key_1.convertPublicKey)(publicKey, 'hex');
+                return [2 /*return*/, this.cryptoClient.encryptAsymmetric(payload, hexPublicKey.value)];
+            });
+        });
+    };
+    // Offline
+    AeternityProtocolImpl.prototype.getKeyPairFromSecret = function (secret, derivationPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (secret.type) {
+                    case 'hex':
+                        return [2 /*return*/, this.getKeyPairFromHexSecret(secret.value, derivationPath)];
+                    case 'mnemonic':
+                        return [2 /*return*/, this.getKeyPairFromMnemonic(secret.value, derivationPath, secret.password)];
+                    default:
+                        (0, coinlib_core_1.assertNever)(secret);
+                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.AETERNITY, 'Unsupported secret type.');
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.getKeyPairFromHexSecret = function (secret, derivationPath) {
+        return __awaiter(this, void 0, void 0, function () {
+            var keyPair;
+            return __generator(this, function (_a) {
+                keyPair = (0, index_3.generateWalletUsingDerivationPath)(Buffer.from(secret, 'hex'), derivationPath);
+                return [2 /*return*/, {
+                        secretKey: (0, module_kit_1.newSecretKey)(Buffer.from(keyPair.secretKey).toString('hex'), 'hex'),
+                        publicKey: (0, module_kit_1.newPublicKey)(Buffer.from(keyPair.publicKey).toString('hex'), 'hex')
+                    }];
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.getKeyPairFromMnemonic = function (mnemonic, derivationPath, password) {
+        return __awaiter(this, void 0, void 0, function () {
+            var secret;
+            return __generator(this, function (_a) {
+                secret = (0, index_2.mnemonicToSeed)(mnemonic, password);
+                return [2 /*return*/, this.getKeyPairFromHexSecret(secret.toString('hex'), derivationPath)];
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.signTransactionWithSecretKey = function (transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var rawTx, signature, txObj, txArray, rlpEncodedTx, signedEncodedTx;
+            return __generator(this, function (_a) {
+                if (secretKey.format !== 'hex') {
+                    throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.AETERNITY, 'Secret key is of an unexpected format.');
+                }
+                rawTx = (0, transaction_1.decodeTx)(transaction.transaction);
+                signature = (0, ed25519_1.sign)(Buffer.from(secretKey.value, 'hex'), Buffer.concat([Buffer.from(transaction.networkId), rawTx]));
+                txObj = {
+                    tag: (0, hex_1.toHexBuffer)(11),
+                    version: (0, hex_1.toHexBuffer)(1),
+                    signatures: [Buffer.from(signature)],
+                    transaction: rawTx
+                };
+                txArray = Object.keys(txObj).map(function (a) { return txObj[a]; });
+                rlpEncodedTx = rlp.encode(txArray);
+                signedEncodedTx = "tx_".concat(base64Check_1.default.encode(rlpEncodedTx));
+                return [2 /*return*/, (0, module_kit_1.newSignedTransaction)({ transaction: signedEncodedTx })];
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.signMessageWithKeyPair = function (message, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (keyPair.secretKey.format !== 'hex') {
+                            throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.AETERNITY, 'Secret key is of an unexpected format.');
+                        }
+                        _a = module_kit_1.newSignature;
+                        return [4 /*yield*/, this.cryptoClient.signMessage(message, { privateKey: keyPair.secretKey.value })];
+                    case 1: return [2 /*return*/, _a.apply(void 0, [_b.sent(), 'hex'])];
+                }
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.decryptAsymmetricWithKeyPair = function (payload, keyPair) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hexPublicKey;
+            return __generator(this, function (_a) {
+                if (keyPair.secretKey.format !== 'hex') {
+                    throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.AETERNITY, 'Secret key is of an unexpected format.');
+                }
+                hexPublicKey = (0, key_1.convertPublicKey)(keyPair.publicKey, 'hex');
+                return [2 /*return*/, this.cryptoClient.decryptAsymmetric(payload, { publicKey: hexPublicKey.value, privateKey: keyPair.secretKey.value })];
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.encryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (secretKey.format !== 'hex') {
+                    throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.AETERNITY, 'Secret key is of an unexpected format.');
+                }
+                return [2 /*return*/, this.cryptoClient.encryptAES(payload, secretKey.value)];
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.decryptAESWithSecretKey = function (payload, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (secretKey.format !== 'hex') {
+                    throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.AETERNITY, 'Secret key is of an unexpected format.');
+                }
+                return [2 /*return*/, this.cryptoClient.decryptAES(payload, secretKey.value)];
+            });
+        });
+    };
+    // Online
+    AeternityProtocolImpl.prototype.getNetwork = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.network];
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.getTransactionsForPublicKey = function (publicKey, limit, cursor) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getTransactionsForAddress(address, limit, cursor)];
+                }
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.getTransactionsForAddress = function (address, limit, cursor) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var endpoint, url, response, _c, nodeTransactions, next, transactions;
+            var _this = this;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        endpoint = cursor === undefined ? "/txs/backward?account=".concat(address, "&limit=").concat(limit) : cursor.next;
+                        url = endpoint !== undefined ? "".concat(this.options.network.rpcUrl, "/mdw/").concat(endpoint.replace(/^\/+/, '')) : undefined;
+                        if (!(url !== undefined)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, index_1.default.get(url)];
+                    case 1:
+                        _c = _d.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _c = undefined;
+                        _d.label = 3;
+                    case 3:
+                        response = _c;
+                        nodeTransactions = ((_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.data) || [];
+                        next = (0, module_kit_1.normalizeToUndefined)((_b = response === null || response === void 0 ? void 0 : response.data) === null || _b === void 0 ? void 0 : _b.next);
+                        transactions = nodeTransactions.map(function (obj) {
+                            var parsedTimestamp = parseInt(obj.micro_time, 10);
+                            return {
+                                from: [obj.tx.sender_id],
+                                to: [obj.tx.recipient_id],
+                                isInbound: address === obj.tx.recipient_id,
+                                amount: (0, module_kit_1.newAmount)(obj.tx.amount, 'blockchain'),
+                                fee: (0, module_kit_1.newAmount)(obj.tx.fee, 'blockchain'),
+                                network: _this.options.network,
+                                timestamp: !isNaN(parsedTimestamp) ? Math.round(parsedTimestamp / 1000) : undefined,
+                                status: {
+                                    type: 'unknown',
+                                    hash: obj.hash,
+                                    block: obj.block_height
+                                },
+                                details: obj.tx.payload ? [(0, module_kit_1.newPlainUIText)('Payload'), obj.tx.payload] : undefined
+                            };
+                        });
+                        return [2 /*return*/, {
+                                transactions: transactions,
+                                cursor: {
+                                    hasNext: next !== undefined,
+                                    next: next
+                                }
+                            }];
+                }
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.getBalanceOfPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [2 /*return*/, this.getBalanceOfAddress(address)];
+                }
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.getBalanceOfAddress = function (address) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balance, data, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/v2/accounts/").concat(address))];
+                    case 1:
+                        data = (_a.sent()).data;
+                        balance = new bignumber_1.default(data.balance);
+                        return [3 /*break*/, 3];
+                    case 2:
+                        error_1 = _a.sent();
+                        // if node returns 404 (which means 'no account found'), go with 0 balance
+                        if (error_1.response && error_1.response.status !== 404) {
+                            throw new errors_1.NetworkError(coinlib_core_1.Domain.AETERNITY, error_1);
+                        }
+                        balance = new bignumber_1.default(0);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/, { total: (0, module_kit_1.newAmount)(balance.toString(10), 'blockchain') }];
+                }
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balance, balanceBn, fee, transactionDetails, feeEstimation, amountWithoutFees;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
+                    case 1:
+                        balance = _a.sent();
+                        balanceBn = new bignumber_1.default((0, module_kit_1.newAmount)(balance.total).blockchain(this.units).value);
+                        if (!((configuration === null || configuration === void 0 ? void 0 : configuration.fee) !== undefined)) return [3 /*break*/, 2];
+                        fee = new bignumber_1.default((0, module_kit_1.newAmount)(configuration.fee).blockchain(this.units).value);
+                        return [3 /*break*/, 4];
+                    case 2:
+                        transactionDetails = to.map(function (address) { return ({
+                            to: address,
+                            amount: (0, module_kit_1.newAmount)(balanceBn.div(to.length).toString(), 'blockchain')
+                        }); });
+                        return [4 /*yield*/, this.getTransactionFeeWithPublicKey(publicKey, transactionDetails)];
+                    case 3:
+                        feeEstimation = _a.sent();
+                        fee = new bignumber_1.default((0, module_kit_1.newAmount)(feeEstimation.medium).blockchain(this.units).value);
+                        if (fee.gte(balanceBn)) {
+                            fee = new bignumber_1.default(0);
+                        }
+                        _a.label = 4;
+                    case 4:
+                        amountWithoutFees = balanceBn.minus(fee);
+                        if (amountWithoutFees.isNegative()) {
+                            amountWithoutFees = new bignumber_1.default(0);
+                        }
+                        return [2 /*return*/, (0, module_kit_1.newAmount)(amountWithoutFees.toFixed(), 'blockchain')];
+                }
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (_publicKey, _details) {
+        return __awaiter(this, void 0, void 0, function () {
+            var feeDetaults;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, index_1.default.get(this.options.network.feesUrl)];
+                    case 1:
+                        feeDetaults = (_a.sent()).data;
+                        return [2 /*return*/, {
+                                low: (0, module_kit_1.newAmount)(feeDetaults.low, 'AE').blockchain(this.units),
+                                medium: (0, module_kit_1.newAmount)(feeDetaults.medium, 'AE').blockchain(this.units),
+                                high: (0, module_kit_1.newAmount)(feeDetaults.high, 'AE').blockchain(this.units)
+                            }];
+                }
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.prepareTransactionWithPublicKey = function (publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var nonce, address, accountResponse, error_2, balance, _a, balanceBn, feeBn, sender, recipient, value, payload, txObj, txArray, rlpEncodedTx, preparedTx;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        nonce = 1;
+                        return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _b.sent();
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/v2/accounts/").concat(address))];
+                    case 3:
+                        accountResponse = (_b.sent()).data;
+                        nonce = accountResponse.nonce + 1;
+                        return [3 /*break*/, 5];
+                    case 4:
+                        error_2 = _b.sent();
+                        // if node returns 404 (which means 'no account found'), go with nonce 0
+                        if (error_2.response && error_2.response.status !== 404) {
+                            throw new errors_1.NetworkError(coinlib_core_1.Domain.AETERNITY, error_2);
+                        }
+                        return [3 /*break*/, 5];
+                    case 5:
+                        _a = module_kit_1.newAmount;
+                        return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
+                    case 6:
+                        balance = _a.apply(void 0, [(_b.sent()).total]).blockchain(this.units);
+                        balanceBn = new bignumber_1.default(balance.value);
+                        feeBn = (configuration === null || configuration === void 0 ? void 0 : configuration.fee) !== undefined
+                            ? new bignumber_1.default((0, module_kit_1.newAmount)(configuration.fee).blockchain(this.units).value)
+                            : new bignumber_1.default((0, module_kit_1.newAmount)(this.feeDefaults.medium).blockchain(this.units).value);
+                        if (balanceBn.isLessThan(feeBn)) {
+                            throw new errors_1.BalanceError(coinlib_core_1.Domain.AETERNITY, 'not enough balance');
+                        }
+                        sender = (0, key_1.convertPublicKey)(publicKey, 'hex').value;
+                        recipient = (0, key_1.convertPublicKey)(AeternityAddress_1.AeternityAddress.from(details[0].to).toPublicKey(), 'hex').value;
+                        value = new bignumber_1.default((0, module_kit_1.newAmount)(details[0].amount).blockchain(this.units).value);
+                        payload = details[0].arbitraryData || '';
+                        txObj = {
+                            tag: (0, hex_1.toHexBuffer)(12),
+                            version: (0, hex_1.toHexBuffer)(1),
+                            sender_id: Buffer.concat([(0, hex_1.toHexBuffer)(1), Buffer.from(sender, 'hex')]),
+                            recipient_id: Buffer.concat([(0, hex_1.toHexBuffer)(1), Buffer.from(recipient, 'hex')]),
+                            amount: (0, hex_1.toHexBuffer)(value),
+                            fee: (0, hex_1.toHexBuffer)(feeBn),
+                            ttl: (0, hex_1.toHexBuffer)(0),
+                            nonce: (0, hex_1.toHexBuffer)(nonce),
+                            payload: Buffer.from(payload)
+                        };
+                        txArray = Object.keys(txObj).map(function (a) { return txObj[a]; });
+                        rlpEncodedTx = rlp.encode(txArray);
+                        preparedTx = (0, transaction_1.encodeTx)(rlpEncodedTx);
+                        return [2 /*return*/, (0, module_kit_1.newUnsignedTransaction)({
+                                transaction: preparedTx,
+                                networkId: this.networkId()
+                            })];
+                }
+            });
+        });
+    };
+    AeternityProtocolImpl.prototype.networkId = function () {
+        switch (this.options.network.type) {
+            case 'mainnet':
+                return 'ae_mainnet';
+            default:
+                throw new errors_1.ConditionViolationError(coinlib_core_1.Domain.AETERNITY, 'Network type not supported.');
+        }
+    };
+    AeternityProtocolImpl.prototype.broadcastTransaction = function (transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, index_1.default.post("".concat(this.options.network.rpcUrl, "/v2/transactions"), { tx: transaction.transaction }, { headers: { 'Content-Type': 'application/json' } })];
+                    case 1:
+                        data = (_a.sent()).data;
+                        return [2 /*return*/, data.tx_hash];
+                }
+            });
+        });
+    };
+    // Custom
+    AeternityProtocolImpl.prototype.convertTransactionToBase58 = function (preparedTx) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, (0, module_kit_1.newUnsignedTransaction)({
+                        transaction: bs58check.encode(base64Check_1.default.decode(preparedTx.transaction)),
+                        networkId: preparedTx.networkId
+                    })];
+            });
+        });
+    };
+    return AeternityProtocolImpl;
+}());
+exports.AeternityProtocolImpl = AeternityProtocolImpl;
+// Factory
+function createAeternityProtocol(options) {
+    if (options === void 0) { options = {}; }
+    return new AeternityProtocolImpl(options);
+}
+exports.createAeternityProtocol = createAeternityProtocol;
+exports.AETERNITY_MAINNET_PROTOCOL_NETWORK = {
+    name: 'Mainnet',
+    type: 'mainnet',
+    rpcUrl: 'https://mainnet.aeternity.io',
+    feesUrl: 'https://api-airgap.gke.papers.tech/fees'
+};
+var DEFAULT_AETERNITY_PROTOCOL_NETWORK = exports.AETERNITY_MAINNET_PROTOCOL_NETWORK;
+function createAeternityProtocolOptions(network) {
+    if (network === void 0) { network = {}; }
+    return {
+        network: __assign(__assign({}, DEFAULT_AETERNITY_PROTOCOL_NETWORK), network)
+    };
+}
+exports.createAeternityProtocolOptions = createAeternityProtocolOptions;
+//# sourceMappingURL=AeternityProtocol.js.map