@airgap/stellar 0.13.41-beta.0

package/v1/protocol/StellarCryptoClient.js

@@ -0,0 +1,104 @@
+"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.StellarCryptoClient = void 0;
+var errors_1 = require("@airgap/coinlib-core/errors");
+var coinlib_error_1 = require("@airgap/coinlib-core/errors/coinlib-error");
+var Ed25519CryptoClient_1 = require("@airgap/coinlib-core/protocols/Ed25519CryptoClient");
+var stellar_sdk_1 = require("@stellar/stellar-sdk");
+var MESSAGE_PREFIX = 'Stellar Signed Message:\n';
+var MAX_MESSAGE_LENGTH = 0xfd;
+var prepareSignedMessage = function (message) {
+    var prefix = Buffer.from(MESSAGE_PREFIX, 'utf8');
+    var content = Buffer.from(message, 'utf8');
+    if (content.length >= MAX_MESSAGE_LENGTH) {
+        throw new errors_1.InvalidValueError(coinlib_error_1.Domain.STELLAR, 'Message exceeds maximum length');
+    }
+    return Buffer.concat([Buffer.from([prefix.length]), prefix, Buffer.from([content.length]), content]);
+};
+var StellarCryptoClient = /** @class */ (function (_super) {
+    __extends(StellarCryptoClient, _super);
+    function StellarCryptoClient() {
+        return _super.call(this) || this;
+    }
+    StellarCryptoClient.prototype.signMessage = function (message, keypair) {
+        return __awaiter(this, void 0, void 0, function () {
+            var preparedMessage, kp, signature;
+            return __generator(this, function (_a) {
+                preparedMessage = prepareSignedMessage(message);
+                if (!stellar_sdk_1.StrKey.isValidEd25519SecretSeed(keypair.privateKey)) {
+                    throw new errors_1.InvalidValueError(coinlib_error_1.Domain.STELLAR, 'Invalid Stellar secret key format');
+                }
+                kp = stellar_sdk_1.Keypair.fromSecret(keypair.privateKey);
+                signature = kp.sign(preparedMessage);
+                return [2 /*return*/, Buffer.from(signature).toString('hex')];
+            });
+        });
+    };
+    StellarCryptoClient.prototype.verifyMessage = function (message, signature, publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var preparedMessage, kp;
+            return __generator(this, function (_a) {
+                preparedMessage = prepareSignedMessage(message);
+                if (!stellar_sdk_1.StrKey.isValidEd25519PublicKey(publicKey)) {
+                    return [2 /*return*/, false];
+                }
+                kp = stellar_sdk_1.Keypair.fromPublicKey(publicKey);
+                return [2 /*return*/, kp.verify(preparedMessage, Buffer.from(signature, 'hex'))];
+            });
+        });
+    };
+    return StellarCryptoClient;
+}(Ed25519CryptoClient_1.Ed25519CryptoClient));
+exports.StellarCryptoClient = StellarCryptoClient;
+//# sourceMappingURL=StellarCryptoClient.js.map

package/v1/protocol/StellarCryptoClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StellarCryptoClient.js","sourceRoot":"","sources":["../../../src/v1/protocol/StellarCryptoClient.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,sDAA+D;AAC/D,2EAAkE;AAClE,0FAAwF;AACxF,oDAAsD;AAEtD,IAAM,cAAc,GAAG,2BAA2B,CAAA;AAClD,IAAM,kBAAkB,GAAG,IAAI,CAAA;AAE/B,IAAM,oBAAoB,GAAG,UAAC,OAAe;IAC3C,IAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,CAAA;IAClD,IAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;IAE5C,IAAI,OAAO,CAAC,MAAM,IAAI,kBAAkB,EAAE;QACxC,MAAM,IAAI,0BAAiB,CAAC,sBAAM,CAAC,OAAO,EAAE,gCAAgC,CAAC,CAAA;KAC9E;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,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAA;AACtG,CAAC,CAAA;AAED;IAAyC,uCAAmB;IAC1D;eACE,iBAAO;IACT,CAAC;IAEY,yCAAW,GAAxB,UAAyB,OAAe,EAAE,OAA+B;;;;gBACjE,eAAe,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAA;gBAErD,IAAI,CAAC,oBAAM,CAAC,wBAAwB,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;oBACxD,MAAM,IAAI,0BAAiB,CAAC,sBAAM,CAAC,OAAO,EAAE,mCAAmC,CAAC,CAAA;iBACjF;gBAEK,EAAE,GAAG,qBAAO,CAAC,UAAU,CAAC,OAAO,CAAC,UAAU,CAAC,CAAA;gBAC3C,SAAS,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,CAAC,CAAA;gBAE1C,sBAAO,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAA;;;KAC9C;IAEY,2CAAa,GAA1B,UAA2B,OAAe,EAAE,SAAiB,EAAE,SAAiB;;;;gBACxE,eAAe,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAA;gBAErD,IAAI,CAAC,oBAAM,CAAC,uBAAuB,CAAC,SAAS,CAAC,EAAE;oBAC9C,sBAAO,KAAK,EAAA;iBACb;gBAEK,EAAE,GAAG,qBAAO,CAAC,aAAa,CAAC,SAAS,CAAC,CAAA;gBAC3C,sBAAO,EAAE,CAAC,MAAM,CAAC,eAAe,EAAE,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,EAAA;;;KACjE;IACH,0BAAC;AAAD,CAAC,AA5BD,CAAyC,yCAAmB,GA4B3D;AA5BY,kDAAmB"}

package/v1/protocol/StellarProtocol.d.ts

@@ -0,0 +1,42 @@
+import { Address, AirGapProtocol, AirGapTransaction, Balance, CryptoDerivative, FeeDefaults, KeyPair, ProtocolMetadata, PublicKey, RecursivePartial, SecretKey, TransactionFullConfiguration, TransactionDetails, AirGapTransactionsWithCursor, Amount, TransactionSimpleConfiguration } from '@airgap/module-kit';
+import { StellarCryptoConfiguration } from '../types/crypto';
+import { StellarProtocolNetwork, StellarProtocolOptions, StellarUnits } from '../types/protocol';
+import { StellarSignedTransaction, StellarTransactionCursor, StellarUnsignedTransaction } from '../types/transaction';
+export interface StellarProtocol extends AirGapProtocol<{
+    AddressResult: Address;
+    ProtocolNetwork: StellarProtocolNetwork;
+    CryptoConfiguration: StellarCryptoConfiguration;
+    SignedTransaction: StellarSignedTransaction;
+    TransactionCursor: StellarTransactionCursor;
+    Units: StellarUnits;
+    FeeEstimation: FeeDefaults<StellarUnits>;
+    UnsignedTransaction: StellarUnsignedTransaction;
+}, 'FetchDataForAddress'> {
+}
+export declare class StellarProtocolImpl implements StellarProtocol {
+    private readonly options;
+    constructor(options?: RecursivePartial<StellarProtocolOptions>);
+    getTransactionsForPublicKey(publicKey: PublicKey, limit: number, cursor?: StellarTransactionCursor | undefined): Promise<AirGapTransactionsWithCursor<StellarTransactionCursor, StellarUnits>>;
+    getTransactionsForAddress(address: Address, limit: number, cursor?: StellarTransactionCursor | undefined): Promise<AirGapTransactionsWithCursor<StellarTransactionCursor, StellarUnits>>;
+    getTransactionMaxAmountWithPublicKey(publicKey: PublicKey, to: Address[], configuration?: TransactionFullConfiguration<StellarUnits>): Promise<Amount<StellarUnits>>;
+    getTransactionFeeWithPublicKey(publicKey: PublicKey, details: TransactionDetails<StellarUnits>[], configuration?: TransactionSimpleConfiguration): Promise<FeeDefaults<StellarUnits>>;
+    private readonly units;
+    private readonly feeDefaults;
+    private readonly metadata;
+    getMetadata(): Promise<ProtocolMetadata<StellarUnits>>;
+    getAddressFromPublicKey(publicKey: PublicKey): Promise<string>;
+    getDetailsFromTransaction(transaction: StellarSignedTransaction | StellarUnsignedTransaction, _publicKey: PublicKey): Promise<AirGapTransaction<StellarUnits>[]>;
+    private getDetailsFromEncodedTransaction;
+    private readonly cryptoConfiguration;
+    getCryptoConfiguration(): Promise<StellarCryptoConfiguration>;
+    getKeyPairFromDerivative(derivative: CryptoDerivative): Promise<KeyPair>;
+    signTransactionWithSecretKey(transaction: StellarUnsignedTransaction, secretKey: SecretKey): Promise<StellarSignedTransaction>;
+    getNetwork(): Promise<StellarProtocolNetwork>;
+    getBalanceOfPublicKey(publicKey: PublicKey): Promise<Balance<StellarUnits>>;
+    getBalanceOfAddress(address: string): Promise<Balance<StellarUnits>>;
+    prepareTransactionWithPublicKey(publicKey: PublicKey, details: TransactionDetails<StellarUnits>[], configuration?: TransactionFullConfiguration<StellarUnits>): Promise<StellarUnsignedTransaction>;
+    broadcastTransaction(transaction: StellarSignedTransaction): Promise<string>;
+}
+export declare function createStellarProtocol(options?: RecursivePartial<StellarProtocolOptions>): StellarProtocol;
+export declare const STELLAR_MAINNET_PROTOCOL_NETWORK: StellarProtocolNetwork;
+export declare function createStellarProtocolOptions(network?: Partial<StellarProtocolNetwork>): StellarProtocolOptions;

package/v1/protocol/StellarProtocol.js

@@ -0,0 +1,511 @@
+"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.createStellarProtocolOptions = exports.STELLAR_MAINNET_PROTOCOL_NETWORK = exports.createStellarProtocol = exports.StellarProtocolImpl = 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 errors_1 = require("@airgap/coinlib-core/errors");
+var module_kit_1 = require("@airgap/module-kit");
+var stellar_sdk_1 = require("@stellar/stellar-sdk");
+var bignumber_1 = __importDefault(require("@airgap/coinlib-core/dependencies/src/bignumber.js-9.0.0/bignumber"));
+var StellarAddress_1 = require("../data/StellarAddress");
+var StellarProtocolImpl = /** @class */ (function () {
+    function StellarProtocolImpl(options) {
+        if (options === void 0) { options = {}; }
+        // public async signMessageWithKeyPair(message: string, keyPair: KeyPair): Promise<Signature> {
+        //   const secretValue = keyPair.secretKey.value
+        //   const privateKeyHex =
+        //     keyPair.secretKey.format === 'hex' ? secretValue : Buffer.from(StrKey.decodeEd25519SecretSeed(secretValue)).toString('hex')
+        //   const stellarFormat = StrKey.isValidEd25519SecretSeed(secretValue)
+        //   if (!stellarFormat && !isHex(secretValue)) {
+        //     throw new ConditionViolationError(Domain.STELLAR, 'Invalid private key format.')
+        //   }
+        //   const signatureHex = await this.cryptoClient.signMessage(message, { privateKey: privateKeyHex })
+        //   return newSignature(signatureHex, 'hex')
+        // }
+        // public async decryptAsymmetricWithKeyPair(payload: string, keyPair: KeyPair | ExtendedKeyPair): Promise<string> {
+        //   if (keyPair.secretKey.format !== 'hex') {
+        //     throw new ConditionViolationError(Domain.STELLAR, 'Secret key is of an unexpected format.')
+        //   }
+        //   if (keyPair.publicKey.type !== 'pub') {
+        //     throw new ConditionViolationError(Domain.STELLAR, 'Public key must be of type "pub"')
+        //   }
+        //   const hexPublicKey = convertPublicKey(keyPair.publicKey, 'hex')
+        //   return this.cryptoClient.decryptAsymmetric(payload, { publicKey: hexPublicKey.value, privateKey: keyPair.secretKey.value })
+        // }
+        // public async encryptAsymmetricWithPublicKey(payload: string, publicKey: PublicKey): Promise<string> {
+        //   const hexPublicKey: PublicKey = convertPublicKey(publicKey, 'hex')
+        //   return this.cryptoClient.encryptAsymmetric(payload, hexPublicKey.value)
+        // }
+        // encryptAESWithSecretKey(payload: string, secretKey: SecretKey): Promise<string> {
+        //   if (secretKey.format !== 'hex') {
+        //     throw new ConditionViolationError(Domain.STELLAR, 'Secret key is of an unexpected format.')
+        //   }
+        //   return this.cryptoClient.encryptAES(payload, secretKey.value)
+        // }
+        // public async decryptAESWithSecretKey(payload: string, secretKey: SecretKey): Promise<string> {
+        //   if (secretKey.format !== 'hex') {
+        //     throw new ConditionViolationError(Domain.STELLAR, 'Secret key is of an unexpected format.')
+        //   }
+        //   return this.cryptoClient.decryptAES(payload, secretKey.value)
+        // }
+        this.units = {
+            XLM: {
+                symbol: { value: 'XLM', market: 'xlm' },
+                decimals: 7
+            }
+        };
+        this.feeDefaults = {
+            low: (0, module_kit_1.newAmount)(stellar_sdk_1.BASE_FEE, 'XLM').blockchain(this.units),
+            medium: (0, module_kit_1.newAmount)(stellar_sdk_1.BASE_FEE, 'XLM').blockchain(this.units),
+            high: (0, module_kit_1.newAmount)(stellar_sdk_1.BASE_FEE, 'XLM').blockchain(this.units)
+        };
+        this.metadata = {
+            identifier: coinlib_core_1.MainProtocolSymbols.XLM,
+            name: 'Stellar',
+            units: this.units,
+            mainUnit: 'XLM',
+            fee: {
+                defaults: this.feeDefaults
+            },
+            account: {
+                standardDerivationPath: "m/44h/148h/0h",
+                address: {
+                    isCaseSensitive: false,
+                    placeholder: 'GABC...',
+                    regex: '^G[0-9A-Z]{55}$'
+                }
+            },
+            transaction: {
+                arbitraryData: {
+                    inner: { name: 'memo' }
+                }
+            }
+        };
+        // public async verifyMessageWithPublicKey(message: string, signature: Signature, publicKey: PublicKey): Promise<boolean> {
+        //   return this.cryptoClient.verifyMessage(message, signature.value, publicKey.value)
+        // }
+        // Offline methods
+        this.cryptoConfiguration = {
+            algorithm: 'ed25519'
+        };
+        this.options = createStellarProtocolOptions(options.network);
+        // this.cryptoClient = new StellarCryptoClient()
+    }
+    StellarProtocolImpl.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)];
+                }
+            });
+        });
+    };
+    StellarProtocolImpl.prototype.getTransactionsForAddress = function (address, limit, cursor) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        return __awaiter(this, void 0, void 0, function () {
+            var endpoint, url, response, data, paymentTransactions, transactions, error_1;
+            var _this = this;
+            return __generator(this, function (_l) {
+                switch (_l.label) {
+                    case 0:
+                        _l.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(limit, "&order=desc&join=transactions");
+                        url = "".concat(this.options.network.rpcUrl).concat(endpoint);
+                        return [4 /*yield*/, index_1.default.get(url)];
+                    case 1:
+                        response = _l.sent();
+                        data = response.data;
+                        paymentTransactions = (_c = (_b = data._embedded) === null || _b === void 0 ? void 0 : _b.records) !== null && _c !== void 0 ? _c : [];
+                        transactions = paymentTransactions
+                            .filter(function (tx) { return tx.type === 'payment'; })
+                            .map(function (tx) {
+                            var txData = tx.transaction;
+                            return {
+                                from: [tx.from],
+                                to: [tx.to],
+                                isInbound: tx.to.toLowerCase() === address.toLowerCase(),
+                                amount: (0, module_kit_1.newAmount)(tx.amount, 'blockchain'),
+                                fee: (0, module_kit_1.newAmount)((parseInt(txData.fee_charged) / 10000000).toFixed(7), 'blockchain'),
+                                network: _this.options.network,
+                                timestamp: new Date(tx.created_at).getTime(),
+                                status: {
+                                    type: tx.transaction_successful ? 'applied' : 'failed',
+                                    hash: tx.transaction_hash,
+                                    block: txData.ledger.toString()
+                                },
+                                arbitraryData: txData.memo_type === 'text'
+                                    ? txData.memo
+                                    : txData.memo_type === 'hash'
+                                        ? "Hash: ".concat(txData.memo)
+                                        : txData.memo_type === 'id'
+                                            ? "ID: ".concat(txData.memo)
+                                            : undefined
+                            };
+                        });
+                        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.options.network.rpcUrl, '')) !== null && _j !== void 0 ? _j : ''
+                                }
+                            }];
+                    case 2:
+                        error_1 = _l.sent();
+                        if (((_k = error_1.response) === null || _k === void 0 ? void 0 : _k.status) === 404) {
+                            return [2 /*return*/, {
+                                    transactions: [],
+                                    cursor: {
+                                        hasNext: false,
+                                        next: ''
+                                    }
+                                }];
+                        }
+                        throw new errors_1.NetworkError(coinlib_core_1.Domain.STELLAR, error_1);
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    StellarProtocolImpl.prototype.getTransactionMaxAmountWithPublicKey = function (publicKey, to, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var balance, balanceBn, fee, amountWithoutFees, error_2;
+            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();
+                        balanceBn = new bignumber_1.default(balance.total.value || '0');
+                        fee = void 0;
+                        if ((configuration === null || configuration === void 0 ? void 0 : configuration.fee) !== undefined) {
+                            fee = new bignumber_1.default((0, module_kit_1.newAmount)(configuration.fee).blockchain(this.units).value);
+                        }
+                        else {
+                            fee = new bignumber_1.default(to.length * Number(stellar_sdk_1.BASE_FEE)).dividedBy(10000000);
+                        }
+                        if (fee.gte(balanceBn)) {
+                            fee = new bignumber_1.default(0);
+                        }
+                        amountWithoutFees = balanceBn.minus(fee);
+                        return [2 /*return*/, (0, module_kit_1.newAmount)(amountWithoutFees.toFixed(), 'blockchain')];
+                    case 2:
+                        error_2 = _a.sent();
+                        throw new errors_1.NetworkError(coinlib_core_1.Domain.STELLAR, error_2);
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    StellarProtocolImpl.prototype.getTransactionFeeWithPublicKey = function (publicKey, details, configuration) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.feeDefaults];
+            });
+        });
+    };
+    StellarProtocolImpl.prototype.getMetadata = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.metadata];
+            });
+        });
+    };
+    StellarProtocolImpl.prototype.getAddressFromPublicKey = function (publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, StellarAddress_1.StellarAddress.from(publicKey).asString()];
+            });
+        });
+    };
+    StellarProtocolImpl.prototype.getDetailsFromTransaction = function (transaction, _publicKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (transaction.type) {
+                    case 'signed':
+                        return [2 /*return*/, this.getDetailsFromEncodedTransaction(transaction.transaction, _publicKey)];
+                    case 'unsigned':
+                        return [2 /*return*/, this.getDetailsFromEncodedTransaction(transaction.transaction, _publicKey)];
+                    default:
+                        (0, coinlib_core_1.assertNever)(transaction);
+                        throw new errors_1.UnsupportedError(coinlib_core_1.Domain.STELLAR, 'Unsupported transaction type.');
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    StellarProtocolImpl.prototype.getDetailsFromEncodedTransaction = function (transaction, publicKey) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        return __awaiter(this, void 0, void 0, function () {
+            var transactions, tx, op, isInbound, feeXLM, memoText;
+            return __generator(this, function (_h) {
+                transactions = [];
+                tx = stellar_sdk_1.TransactionBuilder.fromXDR(transaction, stellar_sdk_1.Networks.TESTNET);
+                op = tx.operations[0];
+                isInbound = ((_a = op.source) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === publicKey.value.toLowerCase();
+                feeXLM = (parseInt(tx.fee) / 1e7).toFixed(7);
+                memoText = ((_b = tx.memo) === null || _b === void 0 ? void 0 : _b.type) === 'text'
+                    ? (_c = tx.memo.value) === null || _c === void 0 ? void 0 : _c.toString()
+                    : ((_d = tx.memo) === null || _d === void 0 ? void 0 : _d.type) === 'hash'
+                        ? "Hash: ".concat((_e = tx.memo.value) === null || _e === void 0 ? void 0 : _e.toString('hex'))
+                        : ((_f = tx.memo) === null || _f === void 0 ? void 0 : _f.type) === 'id'
+                            ? "ID: ".concat((_g = tx.memo.value) === null || _g === void 0 ? void 0 : _g.toString())
+                            : undefined;
+                transactions.push({
+                    from: [tx.source],
+                    to: [op.source || ''],
+                    isInbound: isInbound,
+                    amount: (0, module_kit_1.newAmount)(op.amount, 'blockchain'),
+                    fee: (0, module_kit_1.newAmount)(feeXLM, 'blockchain'),
+                    network: this.options.network,
+                    arbitraryData: memoText
+                });
+                return [2 /*return*/, transactions];
+            });
+        });
+    };
+    StellarProtocolImpl.prototype.getCryptoConfiguration = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cryptoConfiguration];
+            });
+        });
+    };
+    StellarProtocolImpl.prototype.getKeyPairFromDerivative = function (derivative) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, {
+                        secretKey: (0, module_kit_1.newSecretKey)(derivative.secretKey, 'hex'),
+                        publicKey: (0, module_kit_1.newPublicKey)(derivative.publicKey, 'hex')
+                    }];
+            });
+        });
+    };
+    StellarProtocolImpl.prototype.signTransactionWithSecretKey = function (transaction, secretKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tx, keyPair;
+            return __generator(this, function (_a) {
+                tx = stellar_sdk_1.TransactionBuilder.fromXDR(transaction.transaction, stellar_sdk_1.Networks.TESTNET);
+                keyPair = stellar_sdk_1.Keypair.fromSecret(secretKey.value);
+                tx.sign(keyPair);
+                return [2 /*return*/, (0, module_kit_1.newSignedTransaction)({
+                        transaction: tx.toXDR()
+                    })];
+            });
+        });
+    };
+    StellarProtocolImpl.prototype.getNetwork = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.options.network];
+            });
+        });
+    };
+    StellarProtocolImpl.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)];
+                }
+            });
+        });
+    };
+    StellarProtocolImpl.prototype.getBalanceOfAddress = function (address) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var data, balance, error_3;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, index_1.default.get("".concat(this.options.network.rpcUrl, "/accounts/").concat(address))];
+                    case 1:
+                        data = (_b.sent()).data;
+                        balance = data.balances.find(function (b) { return b.asset_type === 'native'; });
+                        return [2 /*return*/, {
+                                total: (0, module_kit_1.newAmount)(balance.balance, 'blockchain')
+                            }];
+                    case 2:
+                        error_3 = _b.sent();
+                        if (((_a = error_3.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+                            return [2 /*return*/, { total: (0, module_kit_1.newAmount)('0', 'blockchain') }];
+                        }
+                        throw new errors_1.NetworkError(coinlib_core_1.Domain.STELLAR, error_3);
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    StellarProtocolImpl.prototype.prepareTransactionWithPublicKey = function (publicKey, details, configuration) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var server, account, txBuilder, _i, details_1, detail, destinationExists, e_1, tx;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        server = new stellar_sdk_1.Horizon.Server(this.options.network.rpcUrl);
+                        return [4 /*yield*/, server.loadAccount(publicKey.value)];
+                    case 1:
+                        account = _b.sent();
+                        txBuilder = new stellar_sdk_1.TransactionBuilder(account, {
+                            fee: stellar_sdk_1.BASE_FEE,
+                            networkPassphrase: stellar_sdk_1.Networks.TESTNET
+                        });
+                        _i = 0, details_1 = details;
+                        _b.label = 2;
+                    case 2:
+                        if (!(_i < details_1.length)) return [3 /*break*/, 8];
+                        detail = details_1[_i];
+                        destinationExists = true;
+                        _b.label = 3;
+                    case 3:
+                        _b.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, server.loadAccount(detail.to)];
+                    case 4:
+                        _b.sent();
+                        return [3 /*break*/, 6];
+                    case 5:
+                        e_1 = _b.sent();
+                        if (((_a = e_1.response) === null || _a === void 0 ? void 0 : _a.status) === 404) {
+                            destinationExists = false;
+                        }
+                        else {
+                            throw e_1;
+                        }
+                        return [3 /*break*/, 6];
+                    case 6:
+                        if (destinationExists) {
+                            txBuilder.addOperation(stellar_sdk_1.Operation.payment({
+                                destination: detail.to,
+                                asset: stellar_sdk_1.Asset.native(),
+                                amount: (0, module_kit_1.newAmount)(detail.amount).blockchain(this.units).value
+                            }));
+                        }
+                        else {
+                            txBuilder.addOperation(stellar_sdk_1.Operation.createAccount({
+                                destination: detail.to,
+                                startingBalance: (0, module_kit_1.newAmount)(detail.amount).blockchain(this.units).value
+                            }));
+                        }
+                        _b.label = 7;
+                    case 7:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 8:
+                        if (configuration === null || configuration === void 0 ? void 0 : configuration.arbitraryData) {
+                            txBuilder.addMemo(stellar_sdk_1.Memo.text(configuration.arbitraryData));
+                        }
+                        tx = txBuilder.setTimeout(30).build();
+                        return [2 /*return*/, (0, module_kit_1.newUnsignedTransaction)({
+                                transaction: tx.toXDR()
+                            })];
+                }
+            });
+        });
+    };
+    StellarProtocolImpl.prototype.broadcastTransaction = function (transaction) {
+        return __awaiter(this, void 0, void 0, function () {
+            var params, data;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        params = new URLSearchParams();
+                        params.append('tx', transaction.transaction);
+                        return [4 /*yield*/, index_1.default.post("".concat(this.options.network.rpcUrl, "/transactions"), params.toString(), {
+                                headers: {
+                                    'Content-Type': 'application/x-www-form-urlencoded'
+                                }
+                            })];
+                    case 1:
+                        data = (_a.sent()).data;
+                        return [2 /*return*/, data.hash];
+                }
+            });
+        });
+    };
+    return StellarProtocolImpl;
+}());
+exports.StellarProtocolImpl = StellarProtocolImpl;
+function createStellarProtocol(options) {
+    if (options === void 0) { options = {}; }
+    return new StellarProtocolImpl(options);
+}
+exports.createStellarProtocol = createStellarProtocol;
+exports.STELLAR_MAINNET_PROTOCOL_NETWORK = {
+    name: 'Mainnet',
+    type: 'mainnet',
+    rpcUrl: 'https://horizon-testnet.stellar.org',
+    blockExplorerUrl: 'https://stellar.expert/explorer/testnet'
+};
+var DEFAULT_STELLAR_PROTOCOL_NETWORK = exports.STELLAR_MAINNET_PROTOCOL_NETWORK;
+function createStellarProtocolOptions(network) {
+    if (network === void 0) { network = {}; }
+    return {
+        network: __assign(__assign({}, DEFAULT_STELLAR_PROTOCOL_NETWORK), network)
+    };
+}
+exports.createStellarProtocolOptions = createStellarProtocolOptions;
+// function flattenArray(
+//   transactions: AirGapTransaction<StellarUnits>[][]
+// ): AirGapTransaction<StellarUnits>[] | PromiseLike<AirGapTransaction<StellarUnits>[]> {
+//   throw new Error('Function not implemented.')
+// }
+//# sourceMappingURL=StellarProtocol.js.map