@cityofzion/bs-solana 0.0.1 → 2.0.0

package/dist/services/blockchain-data/TatumRpcBDSSolana.js

@@ -0,0 +1,408 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _TatumRpcBDSSolana_instances, _TatumRpcBDSSolana_network, _TatumRpcBDSSolana_feeToken, _TatumRpcBDSSolana_connection, _TatumRpcBDSSolana_mainnetApiKey, _TatumRpcBDSSolana_testnetApiKey, _TatumRpcBDSSolana_functionByProgramIdAndMethod, _TatumRpcBDSSolana_parseSplTransferCheckedInstruction, _TatumRpcBDSSolana_parseSplTransferInstruction, _TatumRpcBDSSolana_parseSystemInstruction, _TatumRpcBDSSolana_parseInstruction;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TatumRpcBDSSolana = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+const BSSolanaConstants_1 = require("../../constants/BSSolanaConstants");
+const web3_js_1 = __importDefault(require("@solana/web3.js"));
+const solanaSplSDK = __importStar(require("@solana/spl-token"));
+const BSSolanaCachedMethodsHelper_1 = require("../../helpers/BSSolanaCachedMethodsHelper");
+const BSSolanaHelper_1 = require("../../helpers/BSSolanaHelper");
+class TatumRpcBDSSolana {
+    static getTatumConnection(network, apiKey) {
+        return new web3_js_1.default.Connection(this.tatumUrlByNetworkId[network.id], {
+            httpHeaders: {
+                'x-api-key': apiKey,
+            },
+        });
+    }
+    constructor(network, feeToken, mainnetApiKey, testnetApiKey) {
+        _TatumRpcBDSSolana_instances.add(this);
+        this.maxTimeToConfirmTransactionInMs = 1000 * 60;
+        _TatumRpcBDSSolana_network.set(this, void 0);
+        _TatumRpcBDSSolana_feeToken.set(this, void 0);
+        _TatumRpcBDSSolana_connection.set(this, void 0);
+        _TatumRpcBDSSolana_mainnetApiKey.set(this, void 0);
+        _TatumRpcBDSSolana_testnetApiKey.set(this, void 0);
+        _TatumRpcBDSSolana_functionByProgramIdAndMethod.set(this, {
+            [solanaSplSDK.TOKEN_PROGRAM_ID.toString()]: {
+                transferChecked: __classPrivateFieldGet(this, _TatumRpcBDSSolana_instances, "m", _TatumRpcBDSSolana_parseSplTransferCheckedInstruction).bind(this),
+                transfer: __classPrivateFieldGet(this, _TatumRpcBDSSolana_instances, "m", _TatumRpcBDSSolana_parseSplTransferInstruction).bind(this),
+            },
+            [web3_js_1.default.SystemProgram.programId.toString()]: {
+                transfer: __classPrivateFieldGet(this, _TatumRpcBDSSolana_instances, "m", _TatumRpcBDSSolana_parseSystemInstruction).bind(this),
+            },
+        });
+        __classPrivateFieldSet(this, _TatumRpcBDSSolana_network, network, "f");
+        __classPrivateFieldSet(this, _TatumRpcBDSSolana_feeToken, feeToken, "f");
+        __classPrivateFieldSet(this, _TatumRpcBDSSolana_mainnetApiKey, mainnetApiKey, "f");
+        __classPrivateFieldSet(this, _TatumRpcBDSSolana_testnetApiKey, testnetApiKey, "f");
+        __classPrivateFieldSet(this, _TatumRpcBDSSolana_connection, TatumRpcBDSSolana.getTatumConnection(network, BSSolanaHelper_1.BSSolanaHelper.isMainnet(network) ? mainnetApiKey : testnetApiKey), "f");
+    }
+    getFullTransactionsByAddress(_params) {
+        throw new Error('Method not implemented.');
+    }
+    exportFullTransactionsByAddress(_params) {
+        throw new Error('Method not implemented.');
+    }
+    getTransaction(txid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const transaction = yield __classPrivateFieldGet(this, _TatumRpcBDSSolana_connection, "f").getParsedTransaction(txid, {
+                maxSupportedTransactionVersion: 0,
+            });
+            if (!transaction)
+                throw new Error('Transaction not found');
+            if (!transaction.blockTime)
+                throw new Error('Block time not found');
+            if (!transaction.meta)
+                throw new Error('Transaction meta not found');
+            const transfers = [];
+            const allInstructions = [
+                ...transaction.transaction.message.instructions,
+                ...((_b = (_a = transaction.meta.innerInstructions) === null || _a === void 0 ? void 0 : _a.flatMap(item => item.instructions)) !== null && _b !== void 0 ? _b : []),
+            ].filter((item) => 'parsed' in item);
+            for (const instruction of allInstructions) {
+                try {
+                    const transfer = yield __classPrivateFieldGet(this, _TatumRpcBDSSolana_instances, "m", _TatumRpcBDSSolana_parseInstruction).call(this, instruction, allInstructions);
+                    if (transfer)
+                        transfers.push(transfer);
+                }
+                catch (_c) {
+                    /* empty */
+                }
+            }
+            const feeBn = blockchain_service_1.BSBigNumberHelper.fromDecimals(transaction.meta.fee, __classPrivateFieldGet(this, _TatumRpcBDSSolana_feeToken, "f").decimals);
+            const fee = blockchain_service_1.BSBigNumberHelper.toNumber(feeBn);
+            return {
+                block: transaction.slot,
+                hash: transaction.transaction.signatures[0],
+                notifications: [],
+                time: new Date(transaction.blockTime).getTime() / 1000,
+                transfers,
+                fee,
+                type: 'default',
+            };
+        });
+    }
+    getTransactionsByAddress(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const publicKey = new web3_js_1.default.PublicKey(params.address);
+            const signaturesResponse = yield __classPrivateFieldGet(this, _TatumRpcBDSSolana_connection, "f").getSignaturesForAddress(publicKey, {
+                limit: 15,
+                before: params.nextPageParams,
+            });
+            const transactions = [];
+            const promises = signaturesResponse.map((signatureResponse) => __awaiter(this, void 0, void 0, function* () {
+                const transaction = yield this.getTransaction(signatureResponse.signature);
+                transactions.push(transaction);
+            }));
+            yield Promise.allSettled(promises);
+            return {
+                transactions,
+                nextPageParams: signaturesResponse.length === 15 ? (_a = signaturesResponse.at(-1)) === null || _a === void 0 ? void 0 : _a.signature : undefined,
+            };
+        });
+    }
+    getContract(_contractHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error('Method not implemented.');
+        });
+    }
+    getTokenInfo(tokenHash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (tokenHash === BSSolanaConstants_1.BSSolanaConstants.NATIVE_TOKEN.hash) {
+                return BSSolanaConstants_1.BSSolanaConstants.NATIVE_TOKEN;
+            }
+            const token = yield BSSolanaCachedMethodsHelper_1.BSSolanaCachedMethodsHelper.getMetaplexMetadata(tokenHash, __classPrivateFieldGet(this, _TatumRpcBDSSolana_connection, "f"));
+            if (!token || token.model === 'nft') {
+                throw new Error(`Token not found: ${tokenHash}`);
+            }
+            return {
+                symbol: token.currency.symbol,
+                name: token.name,
+                decimals: token.decimals,
+                hash: tokenHash,
+            };
+        });
+    }
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const publicKey = new web3_js_1.default.PublicKey(address);
+            const nativeBalance = yield __classPrivateFieldGet(this, _TatumRpcBDSSolana_connection, "f").getBalance(publicKey);
+            const splBalance = yield __classPrivateFieldGet(this, _TatumRpcBDSSolana_connection, "f").getParsedTokenAccountsByOwner(publicKey, {
+                programId: solanaSplSDK.TOKEN_PROGRAM_ID,
+            });
+            const nativeBalanceBn = blockchain_service_1.BSBigNumberHelper.fromDecimals(nativeBalance, BSSolanaConstants_1.BSSolanaConstants.NATIVE_TOKEN.decimals);
+            const nativeBalanceAmount = blockchain_service_1.BSBigNumberHelper.toNumber(nativeBalanceBn);
+            const balances = [
+                {
+                    amount: nativeBalanceAmount,
+                    token: BSSolanaConstants_1.BSSolanaConstants.NATIVE_TOKEN,
+                },
+            ];
+            const promises = splBalance.value.map((item) => __awaiter(this, void 0, void 0, function* () {
+                const token = yield this.getTokenInfo(item.account.data.parsed.info.mint);
+                const amountBn = blockchain_service_1.BSBigNumberHelper.fromDecimals(item.account.data.parsed.info.tokenAmount.amount, token.decimals);
+                if (amountBn.isNaN() || amountBn.isLessThanOrEqualTo(0))
+                    return;
+                const amount = blockchain_service_1.BSBigNumberHelper.toNumber(amountBn);
+                balances.push({
+                    amount,
+                    token,
+                });
+            }));
+            yield Promise.allSettled(promises);
+            return balances;
+        });
+    }
+    getBlockHeight() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield __classPrivateFieldGet(this, _TatumRpcBDSSolana_connection, "f").getBlockHeight();
+        });
+    }
+    getRpcList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const list = [];
+            const urls = BSSolanaConstants_1.BSSolanaConstants.RPC_LIST_BY_NETWORK_ID[__classPrivateFieldGet(this, _TatumRpcBDSSolana_network, "f").id];
+            if (!urls) {
+                throw new Error('RPC list not found');
+            }
+            const promises = urls.map(url => {
+                // eslint-disable-next-line no-async-promise-executor
+                return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                    const timeout = setTimeout(() => {
+                        resolve();
+                    }, 5000);
+                    try {
+                        const connection = TatumRpcBDSSolana.getTatumConnection(Object.assign(Object.assign({}, __classPrivateFieldGet(this, _TatumRpcBDSSolana_network, "f")), { url }), BSSolanaHelper_1.BSSolanaHelper.isMainnet(__classPrivateFieldGet(this, _TatumRpcBDSSolana_network, "f")) ? __classPrivateFieldGet(this, _TatumRpcBDSSolana_mainnetApiKey, "f") : __classPrivateFieldGet(this, _TatumRpcBDSSolana_testnetApiKey, "f"));
+                        const timeStart = Date.now();
+                        const height = yield connection.getBlockHeight();
+                        const latency = Date.now() - timeStart;
+                        list.push({
+                            url,
+                            height,
+                            latency,
+                        });
+                    }
+                    catch (_a) {
+                        /* empty */
+                    }
+                    finally {
+                        resolve();
+                        clearTimeout(timeout);
+                    }
+                }));
+            });
+            yield Promise.allSettled(promises);
+            return list;
+        });
+    }
+}
+exports.TatumRpcBDSSolana = TatumRpcBDSSolana;
+_TatumRpcBDSSolana_network = new WeakMap(), _TatumRpcBDSSolana_feeToken = new WeakMap(), _TatumRpcBDSSolana_connection = new WeakMap(), _TatumRpcBDSSolana_mainnetApiKey = new WeakMap(), _TatumRpcBDSSolana_testnetApiKey = new WeakMap(), _TatumRpcBDSSolana_functionByProgramIdAndMethod = new WeakMap(), _TatumRpcBDSSolana_instances = new WeakSet(), _TatumRpcBDSSolana_parseSplTransferCheckedInstruction = function _TatumRpcBDSSolana_parseSplTransferCheckedInstruction(instruction, allInstructions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const info = instruction.parsed.info;
+        if (!info.destination || !info.source || !info.mint) {
+            throw new Error('Unsupported instruction format');
+        }
+        const contractHash = info.mint;
+        const metaplex = yield BSSolanaCachedMethodsHelper_1.BSSolanaCachedMethodsHelper.getMetaplexMetadata(contractHash, __classPrivateFieldGet(this, _TatumRpcBDSSolana_connection, "f"));
+        if (!metaplex) {
+            throw new Error('Metaplex metadata not found');
+        }
+        const toTokenAddress = yield BSSolanaCachedMethodsHelper_1.BSSolanaCachedMethodsHelper.getSplAddress(info.destination, contractHash, allInstructions, __classPrivateFieldGet(this, _TatumRpcBDSSolana_connection, "f"));
+        if (!toTokenAddress) {
+            throw new Error('To account not found');
+        }
+        const to = toTokenAddress.toBase58();
+        const fromTokenAddress = yield BSSolanaCachedMethodsHelper_1.BSSolanaCachedMethodsHelper.getSplAddress(info.source, contractHash, allInstructions, __classPrivateFieldGet(this, _TatumRpcBDSSolana_connection, "f"));
+        if (!fromTokenAddress) {
+            throw new Error('From account not found');
+        }
+        const from = fromTokenAddress.toBase58();
+        if ((metaplex === null || metaplex === void 0 ? void 0 : metaplex.model) === 'nft') {
+            if (!((_a = metaplex.collection) === null || _a === void 0 ? void 0 : _a.address)) {
+                throw new Error('Collection address not found');
+            }
+            return {
+                type: 'nft',
+                from,
+                to,
+                tokenHash: contractHash,
+                collectionHash: metaplex.collection.address.toBase58(),
+            };
+        }
+        const token = {
+            symbol: metaplex.currency.symbol,
+            name: metaplex.name,
+            decimals: metaplex.decimals,
+            hash: contractHash,
+        };
+        const amountBn = blockchain_service_1.BSBigNumberHelper.fromDecimals(info.tokenAmount.amount, token.decimals);
+        const amount = blockchain_service_1.BSBigNumberHelper.toNumber(amountBn);
+        return {
+            type: 'token',
+            amount,
+            contractHash,
+            from,
+            to,
+            token,
+        };
+    });
+}, _TatumRpcBDSSolana_parseSplTransferInstruction = function _TatumRpcBDSSolana_parseSplTransferInstruction(instruction, allInstructions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const info = instruction.parsed.info;
+        if (!info.destination || !info.source || !info.amount) {
+            throw new Error('Unsupported instruction format');
+        }
+        const toTokenAccount = yield BSSolanaCachedMethodsHelper_1.BSSolanaCachedMethodsHelper.getSplAccount(info.destination, __classPrivateFieldGet(this, _TatumRpcBDSSolana_connection, "f"));
+        if (!toTokenAccount) {
+            throw new Error('To account not found');
+        }
+        const contractHash = toTokenAccount.mint.toBase58();
+        const metaplex = yield BSSolanaCachedMethodsHelper_1.BSSolanaCachedMethodsHelper.getMetaplexMetadata(contractHash, __classPrivateFieldGet(this, _TatumRpcBDSSolana_connection, "f"));
+        if (!metaplex) {
+            throw new Error('Metaplex metadata not found');
+        }
+        let to;
+        if (info.destination === toTokenAccount.address.toBase58()) {
+            const toTokenAddress = yield BSSolanaCachedMethodsHelper_1.BSSolanaCachedMethodsHelper.getSplAddress(info.destination, contractHash, allInstructions, __classPrivateFieldGet(this, _TatumRpcBDSSolana_connection, "f"));
+            if (!toTokenAddress) {
+                throw new Error('To account not found');
+            }
+            to = toTokenAddress.toBase58();
+        }
+        else {
+            to = toTokenAccount.address.toBase58();
+        }
+        const fromTokenAddress = yield BSSolanaCachedMethodsHelper_1.BSSolanaCachedMethodsHelper.getSplAddress(info.source, contractHash, allInstructions, __classPrivateFieldGet(this, _TatumRpcBDSSolana_connection, "f"));
+        if (!fromTokenAddress) {
+            throw new Error('From account not found');
+        }
+        const from = fromTokenAddress.toBase58();
+        if ((metaplex === null || metaplex === void 0 ? void 0 : metaplex.model) === 'nft') {
+            if (!((_a = metaplex.collection) === null || _a === void 0 ? void 0 : _a.address)) {
+                throw new Error('Collection address not found');
+            }
+            return {
+                type: 'nft',
+                from,
+                to,
+                collectionHash: metaplex.collection.address.toBase58(),
+                tokenHash: contractHash,
+            };
+        }
+        const token = {
+            symbol: metaplex.currency.symbol,
+            name: metaplex.name,
+            decimals: metaplex.decimals,
+            hash: contractHash,
+        };
+        const amountBn = blockchain_service_1.BSBigNumberHelper.fromDecimals(info.tokenAmount.amount, token.decimals);
+        const amount = blockchain_service_1.BSBigNumberHelper.toNumber(amountBn);
+        return {
+            type: 'token',
+            amount,
+            contractHash,
+            from,
+            to,
+            token,
+        };
+    });
+}, _TatumRpcBDSSolana_parseSystemInstruction = function _TatumRpcBDSSolana_parseSystemInstruction(instruction) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const info = instruction.parsed.info;
+        const method = instruction.parsed.type;
+        if (info.lamports === undefined || info.source === undefined || method !== 'transfer' || !info.destination) {
+            throw new Error('Unsupported instruction format');
+        }
+        const amountBn = blockchain_service_1.BSBigNumberHelper.fromDecimals(info.lamports, BSSolanaConstants_1.BSSolanaConstants.NATIVE_TOKEN.decimals);
+        const amount = blockchain_service_1.BSBigNumberHelper.toNumber(amountBn);
+        return {
+            type: 'token',
+            amount,
+            from: info.source,
+            to: info.destination,
+            contractHash: BSSolanaConstants_1.BSSolanaConstants.NATIVE_TOKEN.hash,
+            token: BSSolanaConstants_1.BSSolanaConstants.NATIVE_TOKEN,
+        };
+    });
+}, _TatumRpcBDSSolana_parseInstruction = function _TatumRpcBDSSolana_parseInstruction(instruction, allInstructions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        if (!instruction.parsed.type || !instruction.parsed.info) {
+            throw new Error('Unsupported instruction format');
+        }
+        const programId = instruction.programId.toString();
+        const method = instruction.parsed.type;
+        const func = (_a = __classPrivateFieldGet(this, _TatumRpcBDSSolana_functionByProgramIdAndMethod, "f")[programId]) === null || _a === void 0 ? void 0 : _a[method];
+        if (func) {
+            return yield func(instruction, allInstructions);
+        }
+        throw new Error('Unsupported instruction');
+    });
+};
+TatumRpcBDSSolana.tatumUrlByNetworkId = {
+    'mainnet-beta': 'https://solana-mainnet.gateway.tatum.io/',
+    devnet: 'https://solana-devnet.gateway.tatum.io',
+};

package/dist/services/exchange/MoralisEDSSolana.d.ts

@@ -0,0 +1,8 @@
+import { CryptoCompareEDS, ExchangeDataService, GetTokenPriceHistoryParams, GetTokenPricesParams, Network, TokenPricesHistoryResponse, TokenPricesResponse } from '@cityofzion/blockchain-service';
+import { BSSolanaNetworkId } from '../../constants/BSSolanaConstants';
+export declare class MoralisEDSSolana extends CryptoCompareEDS implements ExchangeDataService {
+    #private;
+    constructor(network: Network<BSSolanaNetworkId>, apiKey: string);
+    getTokenPrices({ tokens }: GetTokenPricesParams): Promise<TokenPricesResponse[]>;
+    getTokenPriceHistory(params: GetTokenPriceHistoryParams): Promise<TokenPricesHistoryResponse[]>;
+}

package/dist/services/exchange/MoralisEDSSolana.js

@@ -0,0 +1,104 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _MoralisEDSSolana_network, _MoralisEDSSolana_client, _MoralisEDSSolana_pairAddressCache;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoralisEDSSolana = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+const BSSolanaHelper_1 = require("../../helpers/BSSolanaHelper");
+const BSSolanaConstants_1 = require("../../constants/BSSolanaConstants");
+const axios_1 = __importDefault(require("axios"));
+const dayjs_1 = __importDefault(require("dayjs"));
+class MoralisEDSSolana extends blockchain_service_1.CryptoCompareEDS {
+    constructor(network, apiKey) {
+        super();
+        _MoralisEDSSolana_network.set(this, void 0);
+        _MoralisEDSSolana_client.set(this, void 0);
+        _MoralisEDSSolana_pairAddressCache.set(this, new Map());
+        __classPrivateFieldSet(this, _MoralisEDSSolana_network, network, "f");
+        __classPrivateFieldSet(this, _MoralisEDSSolana_client, axios_1.default.create({
+            baseURL: 'https://solana-gateway.moralis.io',
+            headers: {
+                'X-API-Key': apiKey,
+            },
+        }), "f");
+    }
+    getTokenPrices(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ tokens }) {
+            if (!BSSolanaHelper_1.BSSolanaHelper.isMainnet(__classPrivateFieldGet(this, _MoralisEDSSolana_network, "f")))
+                throw new Error('Exchange is only available on mainnet');
+            const promises = tokens.map((token) => __awaiter(this, void 0, void 0, function* () {
+                const hash = token.hash === BSSolanaConstants_1.BSSolanaConstants.NATIVE_TOKEN.hash ? BSSolanaConstants_1.BSSolanaConstants.NATIVE_WRAPPED_HASH : token.hash;
+                let usdPrice = 0;
+                try {
+                    const priceResponse = yield __classPrivateFieldGet(this, _MoralisEDSSolana_client, "f").get(`token/mainnet/${hash}/price`);
+                    usdPrice = priceResponse.data.usdPrice;
+                    __classPrivateFieldGet(this, _MoralisEDSSolana_pairAddressCache, "f").set(token.hash, priceResponse.data.pairAddress);
+                }
+                catch (_a) {
+                    /* empty */
+                }
+                return {
+                    token,
+                    usdPrice,
+                };
+            }));
+            return yield Promise.all(promises);
+        });
+    }
+    getTokenPriceHistory(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!BSSolanaHelper_1.BSSolanaHelper.isMainnet(__classPrivateFieldGet(this, _MoralisEDSSolana_network, "f")))
+                throw new Error('Exchange is only available on mainnet');
+            const tokenHash = params.token.hash === BSSolanaConstants_1.BSSolanaConstants.NATIVE_TOKEN.hash
+                ? BSSolanaConstants_1.BSSolanaConstants.NATIVE_WRAPPED_HASH
+                : params.token.hash;
+            let pairAddress = __classPrivateFieldGet(this, _MoralisEDSSolana_pairAddressCache, "f").get(tokenHash);
+            if (!pairAddress) {
+                const priceResponse = yield __classPrivateFieldGet(this, _MoralisEDSSolana_client, "f").get(`token/mainnet/${tokenHash}/price`);
+                __classPrivateFieldGet(this, _MoralisEDSSolana_pairAddressCache, "f").set(tokenHash, priceResponse.data.pairAddress);
+                pairAddress = priceResponse.data.pairAddress;
+            }
+            const toDate = (0, dayjs_1.default)().unix();
+            const fromDate = (0, dayjs_1.default)().subtract(params.limit, params.type).unix();
+            const pricesHistoryResponse = yield __classPrivateFieldGet(this, _MoralisEDSSolana_client, "f").get(`token/mainnet/pairs/${pairAddress}/ohlcv`, {
+                params: {
+                    timeframe: params.type === 'day' ? '1d' : '1h',
+                    currency: 'usd',
+                    limit: params.limit,
+                    toDate,
+                    fromDate,
+                },
+            });
+            const pricesHistory = pricesHistoryResponse.data.result.map(price => ({
+                timestamp: (0, dayjs_1.default)(price.timestamp).unix(),
+                token: params.token,
+                usdPrice: price.close,
+            }));
+            return pricesHistory;
+        });
+    }
+}
+exports.MoralisEDSSolana = MoralisEDSSolana;
+_MoralisEDSSolana_network = new WeakMap(), _MoralisEDSSolana_client = new WeakMap(), _MoralisEDSSolana_pairAddressCache = new WeakMap();

package/dist/services/explorer/SolScanESSolana.d.ts

@@ -0,0 +1,13 @@
+import { BuildNftUrlParams, ExplorerService, Network, TokenService } from '@cityofzion/blockchain-service';
+import { BSSolanaNetworkId } from '../../constants/BSSolanaConstants';
+export declare class SolScanESSolana implements ExplorerService {
+    #private;
+    constructor(network: Network<BSSolanaNetworkId>, tokenService: TokenService);
+    buildTransactionUrl(hash: string): string;
+    buildContractUrl(contractHash: string): string;
+    buildNftUrl({ tokenHash }: BuildNftUrlParams): string;
+    getAddressTemplateUrl(): string | undefined;
+    getTxTemplateUrl(): string;
+    getNftTemplateUrl(): string;
+    getContractTemplateUrl(): string;
+}

package/dist/services/explorer/SolScanESSolana.js

@@ -0,0 +1,50 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SolScanESSolana_baseUrl, _SolScanESSolana_queryParams, _SolScanESSolana_tokenService;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolScanESSolana = void 0;
+const BSSolanaHelper_1 = require("../../helpers/BSSolanaHelper");
+class SolScanESSolana {
+    constructor(network, tokenService) {
+        _SolScanESSolana_baseUrl.set(this, 'https://solscan.io');
+        _SolScanESSolana_queryParams.set(this, '');
+        _SolScanESSolana_tokenService.set(this, void 0);
+        if (!BSSolanaHelper_1.BSSolanaHelper.isMainnet(network)) {
+            __classPrivateFieldSet(this, _SolScanESSolana_queryParams, `?cluster=${network.id}`, "f");
+        }
+        __classPrivateFieldSet(this, _SolScanESSolana_tokenService, tokenService, "f");
+    }
+    buildTransactionUrl(hash) {
+        return `${__classPrivateFieldGet(this, _SolScanESSolana_baseUrl, "f")}/tx/${__classPrivateFieldGet(this, _SolScanESSolana_tokenService, "f").normalizeHash(hash)}${__classPrivateFieldGet(this, _SolScanESSolana_queryParams, "f")}`;
+    }
+    buildContractUrl(contractHash) {
+        return `${__classPrivateFieldGet(this, _SolScanESSolana_baseUrl, "f")}/token/${__classPrivateFieldGet(this, _SolScanESSolana_tokenService, "f").normalizeHash(contractHash)}${__classPrivateFieldGet(this, _SolScanESSolana_queryParams, "f")}`;
+    }
+    buildNftUrl({ tokenHash }) {
+        return this.buildContractUrl(tokenHash);
+    }
+    getAddressTemplateUrl() {
+        return `${__classPrivateFieldGet(this, _SolScanESSolana_baseUrl, "f")}/account/{address}${__classPrivateFieldGet(this, _SolScanESSolana_queryParams, "f")}`;
+    }
+    getTxTemplateUrl() {
+        return `${__classPrivateFieldGet(this, _SolScanESSolana_baseUrl, "f")}/tx/{txId}${__classPrivateFieldGet(this, _SolScanESSolana_queryParams, "f")}`;
+    }
+    getNftTemplateUrl() {
+        return `${__classPrivateFieldGet(this, _SolScanESSolana_baseUrl, "f")}/token/{tokenHash}${__classPrivateFieldGet(this, _SolScanESSolana_queryParams, "f")}`;
+    }
+    getContractTemplateUrl() {
+        return `${__classPrivateFieldGet(this, _SolScanESSolana_baseUrl, "f")}/token/{hash}${__classPrivateFieldGet(this, _SolScanESSolana_queryParams, "f")}`;
+    }
+}
+exports.SolScanESSolana = SolScanESSolana;
+_SolScanESSolana_baseUrl = new WeakMap(), _SolScanESSolana_queryParams = new WeakMap(), _SolScanESSolana_tokenService = new WeakMap();

package/dist/services/ledger/Web3LedgerServiceSolana.d.ts

@@ -0,0 +1,13 @@
+import { Account, LedgerService, LedgerServiceEmitter, GetLedgerTransport, UntilIndexRecord } from '@cityofzion/blockchain-service';
+import { BSSolana } from '../../BSSolana';
+import Transport from '@ledgerhq/hw-transport';
+import solanaSDK from '@solana/web3.js';
+export declare class Web3LedgerServiceSolana<BSName extends string = string> implements LedgerService<BSName> {
+    #private;
+    emitter: LedgerServiceEmitter;
+    getLedgerTransport?: GetLedgerTransport<BSName>;
+    constructor(blockchainService: BSSolana<BSName>, getLedgerTransport?: GetLedgerTransport<BSName>);
+    getAccounts(transport: Transport, untilIndexByBlockchainService?: UntilIndexRecord<BSName>): Promise<Account<BSName>[]>;
+    getAccount(transport: Transport, index: number): Promise<Account<BSName>>;
+    signTransaction(transport: Transport, transaction: solanaSDK.Transaction, account: Account<BSName>): Promise<Buffer<ArrayBufferLike>>;
+}