@airgap/stellar 0.13.45-beta.3 → 0.13.45-beta.4

package/v1/protocol/stellarAssets/StellarAsset.js

@@ -1,36 +1,99 @@
 "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 __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.createStellarAssetProtocol = createStellarAssetProtocol;
-const coinlib_core_1 = require("@airgap/coinlib-core");
-const module_kit_1 = require("@airgap/module-kit");
-const protocol_1 = require("../../types/protocol");
-const StellarProtocol_1 = require("../StellarProtocol");
-const index_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/axios-0.19.0/index"));
-const bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
-const errors_1 = require("@airgap/coinlib-core/errors");
-const stellar_sdk_1 = require("@stellar/stellar-sdk");
-class StellarAssetProtocolImpl {
-    constructor(metadata, options) {
-        const completeOptions = (0, StellarProtocol_1.createStellarProtocolOptions)(options.network);
+exports.createStellarAssetProtocol = void 0;
+var coinlib_core_1 = require("@airgap/coinlib-core");
+var module_kit_1 = require("@airgap/module-kit");
+var protocol_1 = require("../../types/protocol");
+var StellarProtocol_1 = require("../StellarProtocol");
+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 errors_1 = require("@airgap/coinlib-core/errors");
+var stellar_sdk_1 = require("@stellar/stellar-sdk");
+var StellarAssetProtocolImpl = /** @class */ (function () {
+    function StellarAssetProtocolImpl(metadata, options) {
+        var completeOptions = (0, StellarProtocol_1.createStellarProtocolOptions)(options.network);
         this.metadata = metadata;
         this.stellar = (0, StellarProtocol_1.createStellarProtocol)(completeOptions);
     }
-    async getCryptoConfiguration() {
-        return this.stellar.getCryptoConfiguration();
-    }
-    async getKeyPairFromDerivative(derivative) {
-        return this.stellar.getKeyPairFromDerivative(derivative);
-    }
-    async signTransactionWithSecretKey(transaction, secretKey) {
-        return this.stellar.signTransactionWithSecretKey(transaction, secretKey);
-    }
-    async getAddressFromPublicKey(publicKey) {
-        return this.stellar.getAddressFromPublicKey(publicKey);
-    }
-    getDetailsFromTransaction(transaction, publicKey) {
+    StellarAssetProtocolImpl.prototype.getCryptoConfiguration = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.stellar.getCryptoConfiguration()];
+            });
+        });
+    };
+    StellarAssetProtocolImpl.prototype.getKeyPairFromDerivative = function (derivative) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.stellar.getKeyPairFromDerivative(derivative)];
+            });
+        });
+    };
+    StellarAssetProtocolImpl.prototype.signTransactionWithSecretKey = function (transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.stellar.signTransactionWithSecretKey(transaction, secretKey)];
+            });
+        });
+    };
+    StellarAssetProtocolImpl.prototype.getAddressFromPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.stellar.getAddressFromPublicKey(publicKey)];
+            });
+        });
+    };
+    StellarAssetProtocolImpl.prototype.getDetailsFromTransaction = function (transaction, publicKey) {
         switch (transaction.type) {
             case 'signed':
                 return this.getDetailsFromEncodedTransaction(transaction.transaction, publicKey);
@@ -40,252 +103,396 @@ class StellarAssetProtocolImpl {
                 (0, coinlib_core_1.assertNever)(transaction);
                 throw new errors_1.UnsupportedError(coinlib_core_1.Domain.STELLAR, 'Unsupported transaction type.');
         }
-    }
-    async getDetailsFromEncodedTransaction(transaction, publicKey) {
-        const transactions = [];
-        const tx = stellar_sdk_1.TransactionBuilder.fromXDR(transaction, stellar_sdk_1.Networks.PUBLIC);
-        for (const txDetails of tx.operations) {
-            let amount;
-            let op;
-            let to;
-            let fee;
-            let isInbound;
-            let type;
-            if (txDetails.type === protocol_1.StellarTransactionType.PAYMENT) {
-                op = txDetails;
-                const multiply = new bignumber_1.default(10).exponentiatedBy(Number(this.metadata.decimals));
-                amount = new bignumber_1.default(op.amount).multipliedBy(multiply).toString();
-                fee = tx.fee;
-                to = op.destination;
-                type = protocol_1.StellarTransactionType.PAYMENT;
-                isInbound = to.toLowerCase() === publicKey.value.toLowerCase();
-            }
-            else if (txDetails.type === protocol_1.StellarTransactionType.CHANGE_TRUST) {
-                op = txDetails;
-                amount = new bignumber_1.default(0).toString();
-                const asetType = op.line;
-                to = asetType.getIssuer();
-                fee = new bignumber_1.default(tx.fee).dividedBy(tx.operations.length).toString();
-                isInbound = to.toLowerCase() === publicKey.value.toLowerCase();
-                type = protocol_1.StellarTransactionType.CHANGE_TRUST;
-            }
-            else {
-                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.STELLAR, 'Unsupported operation type.');
-            }
-            const memo = tx.memo.type === 'text' || tx.memo.type === 'id'
-                ? tx.memo.value?.toString()
-                : tx.memo.type === 'hash' || tx.memo.type === 'return'
-                    ? tx.memo.value?.toString('hex')
-                    : undefined;
-            transactions.push({
-                from: [tx.source],
-                to: [to || ''],
-                isInbound,
-                amount: (0, module_kit_1.newAmount)(amount, 'blockchain'),
-                fee: (0, module_kit_1.newAmount)(fee, 'blockchain'),
-                network: this.stellar.options.network,
-                arbitraryData: memo,
-                type,
-                json: JSON.stringify(tx)
+    };
+    StellarAssetProtocolImpl.prototype.getDetailsFromEncodedTransaction = function (transaction, publicKey) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var transactions, tx, _i, _c, txDetails, amount, op, to, fee, isInbound, type, multiply, asetType, memo;
+            return __generator(this, function (_d) {
+                transactions = [];
+                tx = stellar_sdk_1.TransactionBuilder.fromXDR(transaction, stellar_sdk_1.Networks.PUBLIC);
+                for (_i = 0, _c = tx.operations; _i < _c.length; _i++) {
+                    txDetails = _c[_i];
+                    amount = void 0;
+                    op = void 0;
+                    to = void 0;
+                    fee = void 0;
+                    isInbound = void 0;
+                    type = void 0;
+                    if (txDetails.type === protocol_1.StellarTransactionType.PAYMENT) {
+                        op = txDetails;
+                        multiply = new bignumber_1.default(10).exponentiatedBy(Number(this.metadata.decimals));
+                        amount = new bignumber_1.default(op.amount).multipliedBy(multiply).toString();
+                        fee = tx.fee;
+                        to = op.destination;
+                        type = protocol_1.StellarTransactionType.PAYMENT;
+                        isInbound = to.toLowerCase() === publicKey.value.toLowerCase();
+                    }
+                    else if (txDetails.type === protocol_1.StellarTransactionType.CHANGE_TRUST) {
+                        op = txDetails;
+                        amount = new bignumber_1.default(0).toString();
+                        asetType = op.line;
+                        to = asetType.getIssuer();
+                        fee = new bignumber_1.default(tx.fee).dividedBy(tx.operations.length).toString();
+                        isInbound = to.toLowerCase() === publicKey.value.toLowerCase();
+                        type = protocol_1.StellarTransactionType.CHANGE_TRUST;
+                    }
+                    else {
+                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.STELLAR, 'Unsupported operation type.');
+                    }
+                    memo = tx.memo.type === 'text' || tx.memo.type === 'id'
+                        ? (_a = tx.memo.value) === null || _a === void 0 ? void 0 : _a.toString()
+                        : tx.memo.type === 'hash' || tx.memo.type === 'return'
+                            ? (_b = tx.memo.value) === null || _b === void 0 ? void 0 : _b.toString('hex')
+                            : undefined;
+                    transactions.push({
+                        from: [tx.source],
+                        to: [to || ''],
+                        isInbound: isInbound,
+                        amount: (0, module_kit_1.newAmount)(amount, 'blockchain'),
+                        fee: (0, module_kit_1.newAmount)(fee, 'blockchain'),
+                        network: this.stellar.options.network,
+                        arbitraryData: memo,
+                        type: type,
+                        json: JSON.stringify(tx)
+                    });
+                }
+                return [2 /*return*/, transactions];
             });
-        }
-        return transactions;
-    }
-    async getNetwork() {
-        return this.stellar.getNetwork();
-    }
-    async getTransactionsForPublicKey(publicKey, limit, cursor) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getTransactionsForAddress(address, limit, cursor);
-    }
-    async getBalanceOfPublicKey(publicKey, configuration) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        return this.getBalanceOfAddress(address);
-    }
-    async getTransactionMaxAmountWithPublicKey(publicKey, to, configuration) {
-        try {
-            const balance = await this.getBalanceOfPublicKey(publicKey);
-            return (0, module_kit_1.newAmount)(balance.total.value, 'blockchain');
-        }
-        catch (error) {
-            throw new coinlib_core_1.NetworkError(coinlib_core_1.Domain.STELLAR, error);
-        }
-    }
-    async getTransactionFeeWithPublicKey(publicKey, details, configuration) {
-        return this.stellar.getTransactionFeeWithPublicKey(publicKey, details, configuration);
-    }
-    async prepareTransactionWithPublicKey(publicKey, details, configuration) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        const account = await this.stellar.server.loadAccount(address);
-        const fee = configuration?.fee !== undefined ? configuration?.fee?.value : stellar_sdk_1.BASE_FEE;
-        const txBuilder = new stellar_sdk_1.TransactionBuilder(account, {
-            fee,
-            networkPassphrase: stellar_sdk_1.Networks.PUBLIC
         });
-        for (const detail of details) {
-            let destinationExists = true;
-            try {
-                await this.stellar.server.loadAccount(detail.to);
-            }
-            catch (e) {
-                if (e.response?.status === 404) {
-                    destinationExists = false;
+    };
+    StellarAssetProtocolImpl.prototype.getNetwork = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.stellar.getNetwork()];
+            });
+        });
+    };
+    StellarAssetProtocolImpl.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)];
                 }
-                else {
-                    throw e;
+            });
+        });
+    };
+    StellarAssetProtocolImpl.prototype.getBalanceOfPublicKey = function (publicKey, configuration) {
+        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)];
                 }
-            }
-            const divisor = new bignumber_1.default(10).exponentiatedBy(Number(this.metadata.decimals));
-            const amount = new bignumber_1.default(detail.amount.value).dividedBy(divisor).toString();
-            if (destinationExists) {
-                txBuilder.addOperation(stellar_sdk_1.Operation.payment({
-                    destination: detail.to,
-                    asset: new stellar_sdk_1.Asset(this.metadata.assetCode, this.metadata.issuer),
-                    amount
-                }));
-            }
-            else {
-                throw new errors_1.UnsupportedError(coinlib_core_1.Domain.STELLAR, `Destination account ${detail.to} does not exist.`);
-            }
-        }
-        if (configuration?.arbitraryData) {
-            const memo = configuration?.arbitraryData;
-            txBuilder.addMemo(stellar_sdk_1.Memo.id(memo));
-        }
-        const tx = txBuilder.setTimeout(600).build();
-        return (0, module_kit_1.newUnsignedTransaction)({
-            transaction: tx.toXDR()
+            });
         });
-    }
-    async broadcastTransaction(transaction) {
-        return this.stellar.broadcastTransaction(transaction);
-    }
-    async getTransactionsForAddress(address, limit, cursor) {
-        try {
-            const endpoint = cursor?.next ?? `/accounts/${address}/payments?limit=${100}&order=desc&join=transactions`;
-            const url = `${this.stellar.options.network.rpcUrl}${endpoint}`;
-            const response = await index_1.default.get(url);
-            const data = response.data;
-            const paymentTransactions = data._embedded?.records ?? [];
-            const divisor = new bignumber_1.default(10).exponentiatedBy(Number(this.metadata.decimals));
-            const transactions = paymentTransactions
-                .filter((tx) => (tx.type === 'payment' || tx.type === 'path_payment_strict_send' || tx.type == undefined) &&
-                tx.asset_code === this.metadata.assetCode &&
-                tx.asset_issuer === this.metadata.issuer)
-                .map((tx) => {
-                const txData = tx.transaction;
-                const amount = new bignumber_1.default(tx.amount).multipliedBy(divisor).toString();
-                const isInbound = tx.to.toLowerCase() === address.toLowerCase();
-                return {
-                    from: [tx.from],
-                    to: [tx.to],
-                    isInbound,
-                    amount: (0, module_kit_1.newAmount)(amount, 'blockchain'),
-                    fee: (0, module_kit_1.newAmount)(txData.fee_charged, 'blockchain'),
-                    network: this.stellar.options.network,
-                    timestamp: Math.floor(new Date(tx.created_at).getTime() / 1000),
-                    status: {
-                        type: tx.transaction_successful ? 'applied' : 'failed',
-                        hash: tx.transaction_hash,
-                        block: txData.ledger.toString()
-                    },
-                    arbitraryData: txData.memo
-                };
+    };
+    StellarAssetProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balance, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.getBalanceOfPublicKey(publicKey)];
+                    case 1:
+                        balance = _a.sent();
+                        return [2 /*return*/, (0, module_kit_1.newAmount)(balance.total.value, 'blockchain')];
+                    case 2:
+                        error_1 = _a.sent();
+                        throw new coinlib_core_1.NetworkError(coinlib_core_1.Domain.STELLAR, error_1);
+                    case 3: return [2 /*return*/];
+                }
             });
-            return {
-                transactions,
-                cursor: {
-                    hasNext: data._links?.next?.href !== undefined,
-                    next: data._links?.next?.href?.replace(this.stellar.options.network.rpcUrl, '') ?? ''
+        });
+    };
+    StellarAssetProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.stellar.getTransactionFeeWithPublicKey(publicKey, details, configuration)];
+            });
+        });
+    };
+    StellarAssetProtocolImpl.prototype.prepareTransactionWithPublicKey = function (publicKey, details, configuration) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function () {
+            var address, account, fee, txBuilder, _i, details_1, detail, destinationExists, e_1, divisor, amount, memo, tx;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _c.sent();
+                        return [4 /*yield*/, this.stellar.server.loadAccount(address)];
+                    case 2:
+                        account = _c.sent();
+                        fee = (configuration === null || configuration === void 0 ? void 0 : configuration.fee) !== undefined ? (_a = configuration === null || configuration === void 0 ? void 0 : configuration.fee) === null || _a === void 0 ? void 0 : _a.value : stellar_sdk_1.BASE_FEE;
+                        txBuilder = new stellar_sdk_1.TransactionBuilder(account, {
+                            fee: fee,
+                            networkPassphrase: stellar_sdk_1.Networks.PUBLIC
+                        });
+                        _i = 0, details_1 = details;
+                        _c.label = 3;
+                    case 3:
+                        if (!(_i < details_1.length)) return [3 /*break*/, 9];
+                        detail = details_1[_i];
+                        destinationExists = true;
+                        _c.label = 4;
+                    case 4:
+                        _c.trys.push([4, 6, , 7]);
+                        return [4 /*yield*/, this.stellar.server.loadAccount(detail.to)];
+                    case 5:
+                        _c.sent();
+                        return [3 /*break*/, 7];
+                    case 6:
+                        e_1 = _c.sent();
+                        if (((_b = e_1.response) === null || _b === void 0 ? void 0 : _b.status) === 404) {
+                            destinationExists = false;
+                        }
+                        else {
+                            throw e_1;
+                        }
+                        return [3 /*break*/, 7];
+                    case 7:
+                        divisor = new bignumber_1.default(10).exponentiatedBy(Number(this.metadata.decimals));
+                        amount = new bignumber_1.default(detail.amount.value).dividedBy(divisor).toString();
+                        if (destinationExists) {
+                            txBuilder.addOperation(stellar_sdk_1.Operation.payment({
+                                destination: detail.to,
+                                asset: new stellar_sdk_1.Asset(this.metadata.assetCode, this.metadata.issuer),
+                                amount: amount
+                            }));
+                        }
+                        else {
+                            throw new errors_1.UnsupportedError(coinlib_core_1.Domain.STELLAR, "Destination account ".concat(detail.to, " does not exist."));
+                        }
+                        _c.label = 8;
+                    case 8:
+                        _i++;
+                        return [3 /*break*/, 3];
+                    case 9:
+                        if (configuration === null || configuration === void 0 ? void 0 : configuration.arbitraryData) {
+                            memo = configuration === null || configuration === void 0 ? void 0 : configuration.arbitraryData;
+                            txBuilder.addMemo(stellar_sdk_1.Memo.id(memo));
+                        }
+                        tx = txBuilder.setTimeout(600).build();
+                        return [2 /*return*/, (0, module_kit_1.newUnsignedTransaction)({
+                                transaction: tx.toXDR()
+                            })];
                 }
-            };
-        }
-        catch (error) {
-            return {
-                transactions: [],
-                cursor: {
-                    hasNext: false,
-                    next: ''
+            });
+        });
+    };
+    StellarAssetProtocolImpl.prototype.broadcastTransaction = function (transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.stellar.broadcastTransaction(transaction)];
+            });
+        });
+    };
+    StellarAssetProtocolImpl.prototype.getTransactionsForAddress = function (address, limit, cursor) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        return __awaiter(this, void 0, void 0, function () {
+            var endpoint, url, response, data, paymentTransactions, divisor_1, transactions, error_2;
+            var _this = this;
+            return __generator(this, function (_k) {
+                switch (_k.label) {
+                    case 0:
+                        _k.trys.push([0, 2, , 3]);
+                        endpoint = (_a = cursor === null || cursor === void 0 ? void 0 : cursor.next) !== null && _a !== void 0 ? _a : "/accounts/".concat(address, "/payments?limit=").concat(100, "&order=desc&join=transactions");
+                        url = "".concat(this.stellar.options.network.rpcUrl).concat(endpoint);
+                        return [4 /*yield*/, index_1.default.get(url)];
+                    case 1:
+                        response = _k.sent();
+                        data = response.data;
+                        paymentTransactions = (_c = (_b = data._embedded) === null || _b === void 0 ? void 0 : _b.records) !== null && _c !== void 0 ? _c : [];
+                        divisor_1 = new bignumber_1.default(10).exponentiatedBy(Number(this.metadata.decimals));
+                        transactions = paymentTransactions
+                            .filter(function (tx) {
+                            return (tx.type === 'payment' || tx.type === 'path_payment_strict_send' || tx.type == undefined) &&
+                                tx.asset_code === _this.metadata.assetCode &&
+                                tx.asset_issuer === _this.metadata.issuer;
+                        })
+                            .map(function (tx) {
+                            var txData = tx.transaction;
+                            var amount = new bignumber_1.default(tx.amount).multipliedBy(divisor_1).toString();
+                            var isInbound = tx.to.toLowerCase() === address.toLowerCase();
+                            return {
+                                from: [tx.from],
+                                to: [tx.to],
+                                isInbound: isInbound,
+                                amount: (0, module_kit_1.newAmount)(amount, 'blockchain'),
+                                fee: (0, module_kit_1.newAmount)(txData.fee_charged, 'blockchain'),
+                                network: _this.stellar.options.network,
+                                timestamp: Math.floor(new Date(tx.created_at).getTime() / 1000),
+                                status: {
+                                    type: tx.transaction_successful ? 'applied' : 'failed',
+                                    hash: tx.transaction_hash,
+                                    block: txData.ledger.toString()
+                                },
+                                arbitraryData: txData.memo
+                            };
+                        });
+                        return [2 /*return*/, {
+                                transactions: transactions,
+                                cursor: {
+                                    hasNext: ((_e = (_d = data._links) === null || _d === void 0 ? void 0 : _d.next) === null || _e === void 0 ? void 0 : _e.href) !== undefined,
+                                    next: (_j = (_h = (_g = (_f = data._links) === null || _f === void 0 ? void 0 : _f.next) === null || _g === void 0 ? void 0 : _g.href) === null || _h === void 0 ? void 0 : _h.replace(this.stellar.options.network.rpcUrl, '')) !== null && _j !== void 0 ? _j : ''
+                                }
+                            }];
+                    case 2:
+                        error_2 = _k.sent();
+                        return [2 /*return*/, {
+                                transactions: [],
+                                cursor: {
+                                    hasNext: false,
+                                    next: ''
+                                }
+                            }];
+                    case 3: return [2 /*return*/];
                 }
-            };
-        }
-    }
-    async getBalanceOfAddress(address, configuration) {
-        try {
-            const account = await this.stellar.server.loadAccount(address);
-            const balanceEntry = account.balances.find((b) => (b.asset_type === 'credit_alphanum4' || b.asset_type === 'credit_alphanum12') &&
-                b.asset_code === this.metadata.assetCode &&
-                b.asset_issuer === this.metadata.issuer);
-            const divisor = new bignumber_1.default(10).exponentiatedBy(Number(this.metadata.decimals));
-            const btnBalance = new bignumber_1.default(balanceEntry?.balance ?? 0).multipliedBy(divisor).toString();
-            return {
-                total: (0, module_kit_1.newAmount)(btnBalance, 'blockchain')
-            };
-        }
-        catch (error) {
-            return {
-                total: (0, module_kit_1.newAmount)('0', 'blockchain')
-            };
-        }
-    }
+            });
+        });
+    };
+    StellarAssetProtocolImpl.prototype.getBalanceOfAddress = function (address, configuration) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var account, balanceEntry, divisor, btnBalance, error_3;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.stellar.server.loadAccount(address)];
+                    case 1:
+                        account = _b.sent();
+                        balanceEntry = account.balances.find(function (b) {
+                            return (b.asset_type === 'credit_alphanum4' || b.asset_type === 'credit_alphanum12') &&
+                                b.asset_code === _this.metadata.assetCode &&
+                                b.asset_issuer === _this.metadata.issuer;
+                        });
+                        divisor = new bignumber_1.default(10).exponentiatedBy(Number(this.metadata.decimals));
+                        btnBalance = new bignumber_1.default((_a = balanceEntry === null || balanceEntry === void 0 ? void 0 : balanceEntry.balance) !== null && _a !== void 0 ? _a : 0).multipliedBy(divisor).toString();
+                        return [2 /*return*/, {
+                                total: (0, module_kit_1.newAmount)(btnBalance, 'blockchain')
+                            }];
+                    case 2:
+                        error_3 = _b.sent();
+                        return [2 /*return*/, {
+                                total: (0, module_kit_1.newAmount)('0', 'blockchain')
+                            }];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
     // SubProtocol
-    async getType() {
-        return 'token';
-    }
-    async mainProtocol() {
-        return coinlib_core_1.MainProtocolSymbols.STELLAR;
-    }
-    async getMetadata() {
-        const stellarMetadata = await this.stellar.getMetadata();
-        return {
-            ...stellarMetadata,
-            name: this.metadata.name,
-            identifier: this.metadata.identifier,
-            units: {
-                [this.metadata.assetCode]: {
-                    symbol: { value: this.metadata.assetCode },
-                    decimals: this.metadata.decimals
+    StellarAssetProtocolImpl.prototype.getType = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, 'token'];
+            });
+        });
+    };
+    StellarAssetProtocolImpl.prototype.mainProtocol = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, coinlib_core_1.MainProtocolSymbols.STELLAR];
+            });
+        });
+    };
+    StellarAssetProtocolImpl.prototype.getMetadata = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var stellarMetadata;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.stellar.getMetadata()];
+                    case 1:
+                        stellarMetadata = _b.sent();
+                        return [2 /*return*/, __assign(__assign({}, stellarMetadata), { name: this.metadata.name, identifier: this.metadata.identifier, units: (_a = {},
+                                    _a[this.metadata.assetCode] = {
+                                        symbol: { value: this.metadata.assetCode },
+                                        decimals: this.metadata.decimals
+                                    },
+                                    _a), mainUnit: this.metadata.assetCode })];
                 }
-            },
-            mainUnit: this.metadata.assetCode
-        };
-    }
-    async getTrustBalance(publicKey) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        try {
-            const account = await this.stellar.server.loadAccount(address);
-            const balanceEntry = account.balances.find((b) => (b.asset_type === 'credit_alphanum4' || b.asset_type === 'credit_alphanum12') &&
-                b.asset_code === this.metadata.assetCode &&
-                b.asset_issuer === this.metadata.issuer);
-            const btnBalance = new bignumber_1.default(balanceEntry?.limit ?? 0).toString();
-            return {
-                total: (0, module_kit_1.newAmount)(btnBalance, 'blockchain')
-            };
-        }
-        catch (error) {
-            return {
-                total: (0, module_kit_1.newAmount)('0', 'blockchain')
-            };
-        }
-    }
-    async setTrustline(publicKey, assetMeta, limit) {
-        const address = await this.getAddressFromPublicKey(publicKey);
-        const account = await this.stellar.server.loadAccount(address);
-        const txBuilder = new stellar_sdk_1.TransactionBuilder(account, {
-            fee: stellar_sdk_1.BASE_FEE,
-            networkPassphrase: stellar_sdk_1.Networks.PUBLIC
+            });
         });
-        txBuilder.addOperation(stellar_sdk_1.Operation.changeTrust({
-            asset: new stellar_sdk_1.Asset(assetMeta.assetCode, assetMeta.issuer),
-            limit: limit ? limit : undefined
-        }));
-        const tx = txBuilder.setTimeout(600).build();
-        return (0, module_kit_1.newUnsignedTransaction)({
-            transaction: tx.toXDR()
+    };
+    StellarAssetProtocolImpl.prototype.getTrustBalance = function (publicKey) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var address, account, balanceEntry, btnBalance, error_4;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: 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*/, this.stellar.server.loadAccount(address)];
+                    case 3:
+                        account = _b.sent();
+                        balanceEntry = account.balances.find(function (b) {
+                            return (b.asset_type === 'credit_alphanum4' || b.asset_type === 'credit_alphanum12') &&
+                                b.asset_code === _this.metadata.assetCode &&
+                                b.asset_issuer === _this.metadata.issuer;
+                        });
+                        btnBalance = new bignumber_1.default((_a = balanceEntry === null || balanceEntry === void 0 ? void 0 : balanceEntry.limit) !== null && _a !== void 0 ? _a : 0).toString();
+                        return [2 /*return*/, {
+                                total: (0, module_kit_1.newAmount)(btnBalance, 'blockchain')
+                            }];
+                    case 4:
+                        error_4 = _b.sent();
+                        return [2 /*return*/, {
+                                total: (0, module_kit_1.newAmount)('0', 'blockchain')
+                            }];
+                    case 5: return [2 /*return*/];
+                }
+            });
         });
-    }
-}
-function createStellarAssetProtocol(metadata, options = {}) {
+    };
+    StellarAssetProtocolImpl.prototype.setTrustline = function (publicKey, assetMeta, limit) {
+        return __awaiter(this, void 0, void 0, function () {
+            var address, account, txBuilder, tx;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getAddressFromPublicKey(publicKey)];
+                    case 1:
+                        address = _a.sent();
+                        return [4 /*yield*/, this.stellar.server.loadAccount(address)];
+                    case 2:
+                        account = _a.sent();
+                        txBuilder = new stellar_sdk_1.TransactionBuilder(account, {
+                            fee: stellar_sdk_1.BASE_FEE,
+                            networkPassphrase: stellar_sdk_1.Networks.PUBLIC
+                        });
+                        txBuilder.addOperation(stellar_sdk_1.Operation.changeTrust({
+                            asset: new stellar_sdk_1.Asset(assetMeta.assetCode, assetMeta.issuer),
+                            limit: limit ? limit : undefined
+                        }));
+                        tx = txBuilder.setTimeout(600).build();
+                        return [2 /*return*/, (0, module_kit_1.newUnsignedTransaction)({
+                                transaction: tx.toXDR()
+                            })];
+                }
+            });
+        });
+    };
+    return StellarAssetProtocolImpl;
+}());
+function createStellarAssetProtocol(metadata, options) {
+    if (options === void 0) { options = {}; }
     return new StellarAssetProtocolImpl(metadata, options);
 }
+exports.createStellarAssetProtocol = createStellarAssetProtocol;
 //# sourceMappingURL=StellarAsset.js.map