@cityofzion/bs-solana 0.0.1 → 2.0.0

package/dist/BSSolana.d.ts

@@ -0,0 +1,36 @@
+import { Account, BlockchainDataService, BlockchainService, BSCalculableFee, BSWithExplorerService, BSWithLedger, BSWithNameService, BSWithNft, ExchangeDataService, ExplorerService, GetLedgerTransport, ITokenService, Network, NftDataService, Token, TransferParam } from '@cityofzion/blockchain-service';
+import { BSSolanaNetworkId } from './constants/BSSolanaConstants';
+import { Web3LedgerServiceSolana } from './services/ledger/Web3LedgerServiceSolana';
+type BSSolanaApiKeys = {
+    moralisApiKey: string;
+    tatumMainnetApiKey: string;
+    tatumTestnetApiKey: string;
+};
+export declare class BSSolana<BSName extends string = string> implements BlockchainService<BSName, any>, BSCalculableFee<BSName>, BSWithNameService, BSWithLedger<BSName>, BSWithNft, BSWithExplorerService {
+    #private;
+    name: BSName;
+    bip44DerivationPath: string;
+    feeToken: Token;
+    tokens: Token[];
+    nativeTokens: Token[];
+    network: Network<BSSolanaNetworkId>;
+    ledgerService: Web3LedgerServiceSolana<BSName>;
+    exchangeDataService: ExchangeDataService;
+    blockchainDataService: BlockchainDataService;
+    nftDataService: NftDataService;
+    explorerService: ExplorerService;
+    tokenService: ITokenService;
+    constructor(name: BSName, apiKeys: BSSolanaApiKeys, network?: Network<BSSolanaNetworkId>, getLedgerTransport?: GetLedgerTransport<BSName>);
+    setNetwork(partialNetwork: Network<BSSolanaNetworkId>): void;
+    testNetwork(network: Network<BSSolanaNetworkId>): Promise<void>;
+    validateAddress(address: string): boolean;
+    validateKey(key: string): boolean;
+    generateAccountFromMnemonic(mnemonic: string, index: number): Account<BSName>;
+    generateAccountFromKey(key: string): Account<BSName>;
+    generateAccountFromPublicKey(publicKey: string): Account<BSName>;
+    transfer(param: TransferParam<BSName>): Promise<string[]>;
+    calculateTransferFee(param: TransferParam<BSName>): Promise<string>;
+    resolveNameServiceDomain(domainName: string): Promise<string>;
+    validateNameServiceDomainFormat(domainName: string): boolean;
+}
+export {};

package/dist/BSSolana.js

@@ -0,0 +1,271 @@
+"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 _BSSolana_instances, _BSSolana_connection, _BSSolana_apiKeys, _BSSolana_generateKeyPairFromKey, _BSSolana_signTransaction, _BSSolana_buildTransferParams;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSSolana = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+const web3_js_1 = __importDefault(require("@solana/web3.js"));
+const solanaSplSDK = __importStar(require("@solana/spl-token"));
+const bip39 = __importStar(require("bip39"));
+const spl_name_service_1 = __importDefault(require("@bonfida/spl-name-service"));
+const slip10_js_1 = __importDefault(require("micro-key-producer/slip10.js"));
+const BSSolanaConstants_1 = require("./constants/BSSolanaConstants");
+const bs58_1 = __importDefault(require("bs58"));
+const Web3LedgerServiceSolana_1 = require("./services/ledger/Web3LedgerServiceSolana");
+const TatumRpcBDSSolana_1 = require("./services/blockchain-data/TatumRpcBDSSolana");
+const TatumRpcNDSSolana_1 = require("./services/nft-data/TatumRpcNDSSolana");
+const SolScanESSolana_1 = require("./services/explorer/SolScanESSolana");
+const MoralisEDSSolana_1 = require("./services/exchange/MoralisEDSSolana");
+const TokenServiceSolana_1 = require("./services/token/TokenServiceSolana");
+const KEY_BYTES_LENGTH = 64;
+class BSSolana {
+    constructor(name, apiKeys, network, getLedgerTransport) {
+        _BSSolana_instances.add(this);
+        _BSSolana_connection.set(this, void 0);
+        _BSSolana_apiKeys.set(this, void 0);
+        network = network !== null && network !== void 0 ? network : BSSolanaConstants_1.BSSolanaConstants.DEFAULT_NETWORK;
+        this.name = name;
+        this.bip44DerivationPath = BSSolanaConstants_1.BSSolanaConstants.DEFAULT_BIP44_DERIVATION_PATH;
+        this.ledgerService = new Web3LedgerServiceSolana_1.Web3LedgerServiceSolana(this, getLedgerTransport);
+        __classPrivateFieldSet(this, _BSSolana_apiKeys, apiKeys, "f");
+        this.setNetwork(network);
+    }
+    setNetwork(partialNetwork) {
+        this.tokens = [BSSolanaConstants_1.BSSolanaConstants.NATIVE_TOKEN];
+        this.nativeTokens = [BSSolanaConstants_1.BSSolanaConstants.NATIVE_TOKEN];
+        this.feeToken = BSSolanaConstants_1.BSSolanaConstants.NATIVE_TOKEN;
+        this.network = partialNetwork;
+        this.tokenService = new TokenServiceSolana_1.TokenServiceSolana();
+        this.blockchainDataService = new TatumRpcBDSSolana_1.TatumRpcBDSSolana(this.network, this.feeToken, __classPrivateFieldGet(this, _BSSolana_apiKeys, "f").tatumMainnetApiKey, __classPrivateFieldGet(this, _BSSolana_apiKeys, "f").tatumTestnetApiKey);
+        this.nftDataService = new TatumRpcNDSSolana_1.TatumRpcNDSSolana(this.network, __classPrivateFieldGet(this, _BSSolana_apiKeys, "f").tatumMainnetApiKey, __classPrivateFieldGet(this, _BSSolana_apiKeys, "f").tatumTestnetApiKey);
+        this.explorerService = new SolScanESSolana_1.SolScanESSolana(this.network, this.tokenService);
+        this.exchangeDataService = new MoralisEDSSolana_1.MoralisEDSSolana(this.network, __classPrivateFieldGet(this, _BSSolana_apiKeys, "f").moralisApiKey);
+        __classPrivateFieldSet(this, _BSSolana_connection, new web3_js_1.default.Connection(this.network.url), "f");
+    }
+    testNetwork(network) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = new web3_js_1.default.Connection(network.url);
+            yield connection.getBlockHeight();
+        });
+    }
+    validateAddress(address) {
+        try {
+            return web3_js_1.default.PublicKey.isOnCurve(address);
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    validateKey(key) {
+        let keyBuffer;
+        try {
+            keyBuffer = bs58_1.default.decode(key);
+        }
+        catch (_a) {
+            keyBuffer = Uint8Array.from(key.split(',').map(Number));
+        }
+        if (keyBuffer.length !== KEY_BYTES_LENGTH) {
+            return false;
+        }
+        return true;
+    }
+    generateAccountFromMnemonic(mnemonic, index) {
+        const bip44Path = this.bip44DerivationPath.replace('?', index.toString());
+        const seed = bip39.mnemonicToSeedSync(mnemonic);
+        const hd = slip10_js_1.default.fromMasterSeed(seed.toString('hex'));
+        const keypair = web3_js_1.default.Keypair.fromSeed(hd.derive(bip44Path).privateKey);
+        const key = bs58_1.default.encode(keypair.secretKey);
+        const address = keypair.publicKey.toBase58();
+        return {
+            address,
+            key,
+            type: 'privateKey',
+            bip44Path,
+            blockchain: this.name,
+        };
+    }
+    generateAccountFromKey(key) {
+        const keypair = __classPrivateFieldGet(this, _BSSolana_instances, "m", _BSSolana_generateKeyPairFromKey).call(this, key);
+        const address = keypair.publicKey.toBase58();
+        const base58Key = bs58_1.default.encode(keypair.secretKey);
+        return {
+            address,
+            key: base58Key,
+            type: 'privateKey',
+            blockchain: this.name,
+        };
+    }
+    generateAccountFromPublicKey(publicKey) {
+        return {
+            address: publicKey,
+            key: publicKey,
+            type: 'publicKey',
+            blockchain: this.name,
+        };
+    }
+    transfer(param) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { transaction, latestBlockhash } = yield __classPrivateFieldGet(this, _BSSolana_instances, "m", _BSSolana_buildTransferParams).call(this, param);
+            const signedTransaction = yield __classPrivateFieldGet(this, _BSSolana_instances, "m", _BSSolana_signTransaction).call(this, transaction, param.senderAccount);
+            const signature = yield __classPrivateFieldGet(this, _BSSolana_connection, "f").sendRawTransaction(signedTransaction);
+            const status = yield __classPrivateFieldGet(this, _BSSolana_connection, "f").confirmTransaction({
+                blockhash: latestBlockhash.blockhash,
+                lastValidBlockHeight: latestBlockhash.lastValidBlockHeight,
+                signature,
+            });
+            if (status.value.err) {
+                throw new Error('Transaction failed: ' + status.value.err);
+            }
+            return [signature];
+        });
+    }
+    calculateTransferFee(param) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { senderPublicKey, transaction } = yield __classPrivateFieldGet(this, _BSSolana_instances, "m", _BSSolana_buildTransferParams).call(this, param);
+            const { blockhash } = yield __classPrivateFieldGet(this, _BSSolana_connection, "f").getLatestBlockhash();
+            transaction.recentBlockhash = blockhash;
+            transaction.feePayer = senderPublicKey;
+            const message = transaction.compileMessage();
+            const fee = yield __classPrivateFieldGet(this, _BSSolana_connection, "f").getFeeForMessage(message);
+            if (!fee.value) {
+                throw new Error('Failed to calculate fee');
+            }
+            const feeBn = blockchain_service_1.BSBigNumberHelper.fromDecimals(fee.value, this.feeToken.decimals);
+            return blockchain_service_1.BSBigNumberHelper.toNumber(feeBn).toString();
+        });
+    }
+    resolveNameServiceDomain(domainName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield spl_name_service_1.default.resolve(__classPrivateFieldGet(this, _BSSolana_connection, "f"), domainName);
+            return address.toBase58();
+        });
+    }
+    validateNameServiceDomainFormat(domainName) {
+        return domainName.endsWith('.sol');
+    }
+}
+exports.BSSolana = BSSolana;
+_BSSolana_connection = new WeakMap(), _BSSolana_apiKeys = new WeakMap(), _BSSolana_instances = new WeakSet(), _BSSolana_generateKeyPairFromKey = function _BSSolana_generateKeyPairFromKey(key) {
+    let keyBuffer;
+    try {
+        keyBuffer = bs58_1.default.decode(key);
+    }
+    catch (_a) {
+        keyBuffer = Uint8Array.from(key.split(',').map(Number));
+    }
+    return web3_js_1.default.Keypair.fromSecretKey(keyBuffer);
+}, _BSSolana_signTransaction = function _BSSolana_signTransaction(transaction, senderAccount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (senderAccount.isHardware) {
+            if (!this.ledgerService.getLedgerTransport)
+                throw new Error('You must provide getLedgerTransport function to use Ledger');
+            if (typeof senderAccount.bip44Path !== 'string')
+                throw new Error('Your account must have bip44 path to use Ledger');
+            const transport = yield this.ledgerService.getLedgerTransport(senderAccount);
+            return yield this.ledgerService.signTransaction(transport, transaction, senderAccount);
+        }
+        transaction.sign(__classPrivateFieldGet(this, _BSSolana_instances, "m", _BSSolana_generateKeyPairFromKey).call(this, senderAccount.key));
+        return transaction.serialize();
+    });
+}, _BSSolana_buildTransferParams = function _BSSolana_buildTransferParams(param) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const latestBlockhash = yield __classPrivateFieldGet(this, _BSSolana_connection, "f").getLatestBlockhash();
+        const senderPublicKey = new web3_js_1.default.PublicKey(param.senderAccount.address);
+        const transaction = new web3_js_1.default.Transaction();
+        transaction.feePayer = senderPublicKey;
+        transaction.recentBlockhash = latestBlockhash.blockhash;
+        transaction.lastValidBlockHeight = latestBlockhash.lastValidBlockHeight;
+        for (const intent of param.intents) {
+            const amountBn = blockchain_service_1.BSBigNumberHelper.fromNumber(intent.amount);
+            const amount = Number(blockchain_service_1.BSBigNumberHelper.toDecimals(amountBn, (_a = intent.tokenDecimals) !== null && _a !== void 0 ? _a : 0));
+            const receiverPublicKey = new web3_js_1.default.PublicKey(intent.receiverAddress);
+            const normalizedTokenHash = this.tokenService.normalizeHash(intent.tokenHash);
+            const isNative = normalizedTokenHash === this.tokenService.normalizeHash(BSSolanaConstants_1.BSSolanaConstants.NATIVE_TOKEN.hash);
+            if (isNative) {
+                transaction.add(web3_js_1.default.SystemProgram.transfer({
+                    fromPubkey: senderPublicKey,
+                    toPubkey: receiverPublicKey,
+                    lamports: amount,
+                }));
+                continue;
+            }
+            const tokenMintPublicKey = new web3_js_1.default.PublicKey(normalizedTokenHash);
+            const senderTokenAddress = yield solanaSplSDK.getAssociatedTokenAddress(tokenMintPublicKey, senderPublicKey);
+            const receiverTokenAddress = yield solanaSplSDK.getAssociatedTokenAddress(tokenMintPublicKey, receiverPublicKey);
+            try {
+                yield solanaSplSDK.getAccount(__classPrivateFieldGet(this, _BSSolana_connection, "f"), receiverTokenAddress);
+            }
+            catch (error) {
+                if (error instanceof solanaSplSDK.TokenAccountNotFoundError ||
+                    error instanceof solanaSplSDK.TokenInvalidAccountOwnerError) {
+                    transaction.add(solanaSplSDK.createAssociatedTokenAccountInstruction(senderPublicKey, receiverTokenAddress, receiverPublicKey, tokenMintPublicKey));
+                }
+                else {
+                    throw error;
+                }
+            }
+            transaction.add(solanaSplSDK.createTransferInstruction(senderTokenAddress, receiverTokenAddress, senderPublicKey, amount));
+        }
+        return {
+            transaction,
+            senderPublicKey,
+            latestBlockhash,
+        };
+    });
+};

package/dist/constants/BSSolanaConstants.d.ts

@@ -0,0 +1,15 @@
+import { Network, NetworkId, Token } from '@cityofzion/blockchain-service';
+export type BSSolanaNetworkId = NetworkId<'mainnet-beta' | 'devnet'>;
+export declare class BSSolanaConstants {
+    static DEFAULT_BIP44_DERIVATION_PATH: string;
+    static RPC_LIST_BY_NETWORK_ID: Partial<Record<BSSolanaNetworkId, string[]>>;
+    static MAINNET_NETWORK_IDS: BSSolanaNetworkId[];
+    static TESTNET_NETWORK_IDS: BSSolanaNetworkId[];
+    static ALL_NETWORK_IDS: BSSolanaNetworkId[];
+    static MAINNET_NETWORKS: Network<BSSolanaNetworkId>[];
+    static TESTNET_NETWORKS: Network<BSSolanaNetworkId>[];
+    static ALL_NETWORKS: Network<BSSolanaNetworkId>[];
+    static DEFAULT_NETWORK: Network<BSSolanaNetworkId>;
+    static NATIVE_TOKEN: Token;
+    static NATIVE_WRAPPED_HASH: string;
+}

package/dist/constants/BSSolanaConstants.js

@@ -0,0 +1,34 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSSolanaConstants = void 0;
+class BSSolanaConstants {
+}
+exports.BSSolanaConstants = BSSolanaConstants;
+_a = BSSolanaConstants;
+BSSolanaConstants.DEFAULT_BIP44_DERIVATION_PATH = "m/44'/501'/?'/0'";
+BSSolanaConstants.RPC_LIST_BY_NETWORK_ID = {
+    'mainnet-beta': ['https://api.mainnet-beta.solana.com'],
+    devnet: ['https://api.devnet.solana.com'],
+};
+BSSolanaConstants.MAINNET_NETWORK_IDS = ['mainnet-beta'];
+BSSolanaConstants.TESTNET_NETWORK_IDS = ['devnet'];
+BSSolanaConstants.ALL_NETWORK_IDS = [..._a.MAINNET_NETWORK_IDS, ..._a.TESTNET_NETWORK_IDS];
+BSSolanaConstants.MAINNET_NETWORKS = [
+    {
+        id: 'mainnet-beta',
+        name: 'Mainnet Beta',
+        url: _a.RPC_LIST_BY_NETWORK_ID['mainnet-beta'][0],
+    },
+];
+BSSolanaConstants.TESTNET_NETWORKS = [
+    {
+        id: 'devnet',
+        name: 'Devnet',
+        url: _a.RPC_LIST_BY_NETWORK_ID['devnet'][0],
+    },
+];
+BSSolanaConstants.ALL_NETWORKS = [..._a.MAINNET_NETWORKS, ..._a.TESTNET_NETWORKS];
+BSSolanaConstants.DEFAULT_NETWORK = _a.MAINNET_NETWORKS[0];
+BSSolanaConstants.NATIVE_TOKEN = { symbol: 'SOL', name: 'SOL', decimals: 9, hash: '-' };
+BSSolanaConstants.NATIVE_WRAPPED_HASH = 'So11111111111111111111111111111111111111112';

package/dist/helpers/BSSolanaCachedMethodsHelper.d.ts

@@ -0,0 +1,13 @@
+import solanaSDK from '@solana/web3.js';
+import * as solanaSplSDK from '@solana/spl-token';
+import * as metaplexSDK from '@metaplex-foundation/js';
+type MetaplexMetadata = metaplexSDK.Nft | (metaplexSDK.Mint & {
+    name: string;
+});
+export declare class BSSolanaCachedMethodsHelper {
+    #private;
+    static getMetaplexMetadata(tokenHash: string, connection: solanaSDK.Connection): Promise<MetaplexMetadata | null>;
+    static getSplAddress(address: string, mint: string, instructions: solanaSDK.ParsedInstruction[], connection: solanaSDK.Connection): Promise<solanaSDK.PublicKey | null>;
+    static getSplAccount(address: string, connection: solanaSDK.Connection): Promise<solanaSplSDK.Account | null>;
+}
+export {};

package/dist/helpers/BSSolanaCachedMethodsHelper.js

@@ -0,0 +1,148 @@
+"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 __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 _a, _BSSolanaCachedMethodsHelper_splAccountCache, _BSSolanaCachedMethodsHelper_splAddressCache, _BSSolanaCachedMethodsHelper_metaplexMetadataCache;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSSolanaCachedMethodsHelper = void 0;
+const web3_js_1 = __importDefault(require("@solana/web3.js"));
+const solanaSplSDK = __importStar(require("@solana/spl-token"));
+const metaplexSDK = __importStar(require("@metaplex-foundation/js"));
+class BSSolanaCachedMethodsHelper {
+    static getMetaplexMetadata(tokenHash, connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const metadataCache = __classPrivateFieldGet(this, _a, "f", _BSSolanaCachedMethodsHelper_metaplexMetadataCache).get(tokenHash);
+            if (metadataCache !== undefined) {
+                return metadataCache;
+            }
+            let metadata = null;
+            const metaplexInstance = metaplexSDK.Metaplex.make(connection);
+            try {
+                const nftMetadata = yield metaplexInstance.nfts().findByMint({
+                    mintAddress: new web3_js_1.default.PublicKey(tokenHash),
+                });
+                if (nftMetadata.model === 'sft') {
+                    metadata = Object.assign(Object.assign({}, nftMetadata.mint), { name: nftMetadata.name });
+                }
+                else {
+                    metadata = nftMetadata;
+                }
+            }
+            catch (error) {
+                try {
+                    const tokenMetadata = yield metaplexInstance.tokens().findMintByAddress({
+                        address: new web3_js_1.default.PublicKey(tokenHash),
+                    });
+                    metadata = Object.assign(Object.assign({}, tokenMetadata), { name: tokenMetadata.currency.symbol });
+                }
+                catch (_b) {
+                    /* empty */
+                }
+            }
+            __classPrivateFieldGet(this, _a, "f", _BSSolanaCachedMethodsHelper_metaplexMetadataCache).set(tokenHash, metadata);
+            return metadata;
+        });
+    }
+    static getSplAddress(address, mint, instructions, connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const splAddress = __classPrivateFieldGet(this, _a, "f", _BSSolanaCachedMethodsHelper_splAddressCache).get(address);
+            if (splAddress !== undefined) {
+                return splAddress;
+            }
+            let owner = null;
+            // find owner in instructions, it may found a wrong address,
+            // but it is necessary in some cases where the token account is closed and can`t found
+            for (const instruction of instructions) {
+                const info = instruction.parsed.info;
+                if (instruction.parsed.type.startsWith('initializeAccount') &&
+                    info.account === address &&
+                    info.owner &&
+                    info.mint === mint) {
+                    owner = new web3_js_1.default.PublicKey(info.owner);
+                    break;
+                }
+                if (instruction.parsed.type === 'closeAccount' && info.account === address && info.owner) {
+                    owner = new web3_js_1.default.PublicKey(info.owner);
+                    break;
+                }
+            }
+            if (!owner) {
+                const account = yield this.getSplAccount(address, connection);
+                if (account) {
+                    owner = account.owner;
+                }
+            }
+            __classPrivateFieldGet(this, _a, "f", _BSSolanaCachedMethodsHelper_splAddressCache).set(address, owner);
+            return owner;
+        });
+    }
+    static getSplAccount(address, connection) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const account = __classPrivateFieldGet(this, _a, "f", _BSSolanaCachedMethodsHelper_splAccountCache).get(address);
+            if (account !== undefined) {
+                return account;
+            }
+            let tokenAccount = null;
+            try {
+                tokenAccount = yield solanaSplSDK.getAccount(connection, new web3_js_1.default.PublicKey(address));
+            }
+            catch (_b) {
+                /* empty */
+            }
+            __classPrivateFieldGet(this, _a, "f", _BSSolanaCachedMethodsHelper_splAccountCache).set(address, tokenAccount);
+            return tokenAccount;
+        });
+    }
+}
+exports.BSSolanaCachedMethodsHelper = BSSolanaCachedMethodsHelper;
+_a = BSSolanaCachedMethodsHelper;
+_BSSolanaCachedMethodsHelper_splAccountCache = { value: new Map() };
+_BSSolanaCachedMethodsHelper_splAddressCache = { value: new Map() };
+_BSSolanaCachedMethodsHelper_metaplexMetadataCache = { value: new Map() };

package/dist/helpers/BSSolanaHelper.d.ts

@@ -0,0 +1,7 @@
+import { Network } from '@cityofzion/blockchain-service';
+import { BSSolanaNetworkId } from '../constants/BSSolanaConstants';
+export declare class BSSolanaHelper {
+    static isMainnet(network: Network<BSSolanaNetworkId>): boolean;
+    static fixBip44Path(bip44Path: string): string;
+    static getBip44Path(path: string, index: number): string;
+}

package/dist/helpers/BSSolanaHelper.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BSSolanaHelper = void 0;
+const BSSolanaConstants_1 = require("../constants/BSSolanaConstants");
+class BSSolanaHelper {
+    static isMainnet(network) {
+        return BSSolanaConstants_1.BSSolanaConstants.MAINNET_NETWORK_IDS.includes(network.id);
+    }
+    static fixBip44Path(bip44Path) {
+        return bip44Path.replace('m/', '');
+    }
+    static getBip44Path(path, index) {
+        return this.fixBip44Path(path.replace('?', index.toString()));
+    }
+}
+exports.BSSolanaHelper = BSSolanaHelper;

package/dist/services/blockchain-data/TatumRpcBDSSolana.d.ts

@@ -0,0 +1,19 @@
+import { BalanceResponse, BlockchainDataService, ContractResponse, ExportTransactionsByAddressParams, FullTransactionsByAddressParams, FullTransactionsByAddressResponse, Network, RpcResponse, Token, TransactionResponse, TransactionsByAddressParams, TransactionsByAddressResponse } from '@cityofzion/blockchain-service';
+import { BSSolanaNetworkId } from '../../constants/BSSolanaConstants';
+import solanaSDK from '@solana/web3.js';
+export declare class TatumRpcBDSSolana implements BlockchainDataService {
+    #private;
+    static tatumUrlByNetworkId: Record<BSSolanaNetworkId, string>;
+    static getTatumConnection(network: Network<BSSolanaNetworkId>, apiKey: string): solanaSDK.Connection;
+    maxTimeToConfirmTransactionInMs: number;
+    constructor(network: Network<BSSolanaNetworkId>, feeToken: Token, mainnetApiKey: string, testnetApiKey: string);
+    getFullTransactionsByAddress(_params: FullTransactionsByAddressParams): Promise<FullTransactionsByAddressResponse>;
+    exportFullTransactionsByAddress(_params: ExportTransactionsByAddressParams): Promise<string>;
+    getTransaction(txid: string): Promise<TransactionResponse>;
+    getTransactionsByAddress(params: TransactionsByAddressParams): Promise<TransactionsByAddressResponse>;
+    getContract(_contractHash: string): Promise<ContractResponse>;
+    getTokenInfo(tokenHash: string): Promise<Token>;
+    getBalance(address: string): Promise<BalanceResponse[]>;
+    getBlockHeight(): Promise<number>;
+    getRpcList(): Promise<RpcResponse[]>;
+}