@cryptorubic/web3 0.8.3 → 0.8.4

package/package.json

@@ -1,17 +1,17 @@
 {
     "name": "@cryptorubic/web3",
-    "version": "0.8.3",
+    "version": "0.8.4",
     "dependencies": {
         "tslib": "^2.3.0",
         "bignumber.js": "9.1.2",
-        "@cryptorubic/core": "0.8.3",
+        "@cryptorubic/core": "0.8.4",
         "viem": "^2.19.1",
         "web3-utils": "^4.3.1",
         "@ton/ton": "^15.1.0",
         "@solana/web3.js": "1.95.3",
         "@solflare-wallet/utl-sdk": "^1.4.0",
         "@ethersproject/bignumber": "^5.7.0",
-        "@cryptorubic/tron-types": "0.8.3",
+        "@cryptorubic/tron-types": "0.8.4",
         "bitcoin-address-validation": "^2.2.3",
         "axios": "0.27.2",
         "crc-32": "^1.2.2",

package/src/lib/adapter/adapters/models/solana-web3-types.d.ts

@@ -1,4 +1,35 @@
+import { BlockchainName } from '@cryptorubic/core';
 import { AccountInfo, PublicKey, RpcResponseAndContext } from '@solana/web3.js';
+export interface SolanaToken {
+    name: string;
+    symbol: string;
+    logoURI: string | null;
+    verified?: boolean;
+    address: string;
+    decimals: number | null;
+    holders?: number | null;
+}
+export interface SolanaTokensFetchingResp {
+    tokensList: SolanaToken[];
+    notFetchedMints: PublicKey[];
+    hasNotFetchedTokens: boolean;
+}
+export interface SolanaApiV2TokensResp {
+    count: number;
+    next: null | number;
+    previous: null | number;
+    results: Array<{
+        address: string;
+        name: string;
+        symbol: string;
+        network: BlockchainName;
+        decimals: number;
+        image: string;
+        rank: number;
+        source_rank: number;
+        usdPrice: number;
+    }>;
+}
 /**
  * RPC response value.
  */

package/src/lib/adapter/adapters/models/token-models.d.ts

@@ -0,0 +1 @@
+export type SupportedTokenField = 'decimals' | 'symbol' | 'name' | 'image';

package/src/lib/adapter/adapters/models/token-models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/lib/adapter/adapters/solana-adapter.d.ts

@@ -1,12 +1,13 @@
 import { Abi, MulticallResponse, MulticallParameters } from 'viem';
 import { AbstractAdapter } from './abstract-adapter';
 import { Connection } from '@solana/web3.js';
-import { ICustomLogger, PriceTokenAmount, SolanaBlockchainName, Token, TokenAmount } from '@cryptorubic/core';
+import { HttpClient, ICustomLogger, PriceTokenAmount, SolanaBlockchainName, Token, TokenAmount } from '@cryptorubic/core';
 import { EvmTransactionConfig } from '../../utils/models/evm-transaction-config';
 import BigNumber from 'bignumber.js';
 export declare const NATIVE_SOLANA_MINT_ADDRESS = "So11111111111111111111111111111111111111111";
 export declare class SolanaAdapter extends AbstractAdapter<Connection, Connection, SolanaBlockchainName> {
-    constructor(rpcList: string[], logger?: ICustomLogger);
+    private readonly httpClient;
+    constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger);
     private createPublicClient;
     read<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
     write<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;

package/src/lib/adapter/adapters/solana-adapter.js

@@ -4,14 +4,15 @@ exports.SolanaAdapter = exports.NATIVE_SOLANA_MINT_ADDRESS = void 0;
 const spl_token_1 = require("@solana/spl-token");
 const abstract_adapter_1 = require("./abstract-adapter");
 const web3_js_1 = require("@solana/web3.js");
-const utl_sdk_1 = require("@solflare-wallet/utl-sdk");
 const core_1 = require("@cryptorubic/core");
 const web3_pure_1 = require("../../utils/web3-pure");
 const bignumber_js_1 = require("bignumber.js");
+const solana_tokens_service_1 = require("./utils/solana-tokens-service");
 exports.NATIVE_SOLANA_MINT_ADDRESS = 'So11111111111111111111111111111111111111111';
 class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
-    constructor(rpcList, logger) {
+    constructor(rpcList, httpClient, logger) {
         super(core_1.BLOCKCHAIN_NAME.SOLANA, logger);
+        this.httpClient = httpClient;
         this.public = this.createPublicClient(rpcList);
     }
     createPublicClient(rpcList) {
@@ -73,13 +74,12 @@ class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
         const nativeToken = core_1.nativeTokensList[core_1.BLOCKCHAIN_NAME.SOLANA];
         const nativeTokenIndex = tokenAddresses.findIndex((address) => web3_pure_1.Web3Pure.isNativeAddress(core_1.CHAIN_TYPE.SOLANA, address));
         const filteredTokenAddresses = tokenAddresses.filter((_, index) => index !== nativeTokenIndex);
-        // only native token in tokenAddresses
-        if (!filteredTokenAddresses.length) {
+        // only native token in array
+        if (!filteredTokenAddresses.length && nativeTokenIndex !== -1) {
             return [nativeToken];
         }
         const mints = filteredTokenAddresses.map((address) => new web3_js_1.PublicKey(address));
-        const tokenSdk = new utl_sdk_1.Client();
-        const tokensMint = await tokenSdk.fetchMints(mints);
+        const tokensMint = await new solana_tokens_service_1.SolanaTokensService(this.public, this.httpClient).fetchTokensData(mints);
         const tokens = tokensMint.map((token) => {
             return new core_1.Token({
                 address: token.address.toString(),

package/src/lib/adapter/adapters/utils/solana-tokens-service.d.ts

@@ -0,0 +1,22 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { HttpClient } from '@cryptorubic/core';
+import { SolanaToken } from '../models/solana-web3-types';
+export declare class SolanaTokensService {
+    private readonly httpClient;
+    private connection;
+    private tokensOrder;
+    private initialMints;
+    private readonly apiEndpoint;
+    private readonly newTokensEndpoint;
+    private readonly xApiKey;
+    constructor(connection: Connection, httpClient: HttpClient);
+    fetchTokensData(mints: PublicKey[]): Promise<SolanaToken[]>;
+    private fetchTokensFromBackend;
+    private fetchTokensFromOldBackend;
+    private fetchTokensFromMetaplex;
+    private fetchTokensFromSplApi;
+    private sortTokensByIdx;
+    private getNotFetchedTokensList;
+    private getTokensList;
+    private getTokensListOld;
+}

package/src/lib/adapter/adapters/utils/solana-tokens-service.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaTokensService = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const utl_sdk_1 = require("@solflare-wallet/utl-sdk");
+const timeout_1 = require("./timeout");
+class SolanaTokensService {
+    constructor(connection, httpClient) {
+        this.httpClient = httpClient;
+        // key - address of token, value - idx of token in initial tokensAddress
+        this.tokensOrder = {};
+        this.initialMints = [];
+        this.apiEndpoint = 'https://x-api.rubic.exchange/sol_token_list';
+        this.newTokensEndpoint = 'https://api.rubic.exchange/api/v2';
+        this.xApiKey = 'sndfje3u4b3fnNSDNFUSDNVSunw345842hrnfd3b4nt4';
+        this.connection = connection;
+    }
+    async fetchTokensData(mints) {
+        const tokensAddresses = mints.map((mint) => mint.toString());
+        this.initialMints = mints;
+        this.tokensOrder = tokensAddresses.reduce((acc, address, idx) => ({ ...acc, [address.toLowerCase()]: idx }), {});
+        const fromBackend = await this.fetchTokensFromBackend(mints);
+        if (!fromBackend.hasNotFetchedTokens)
+            return this.sortTokensByIdx(fromBackend.tokensList);
+        const fromOldBackend = await this.fetchTokensFromOldBackend(fromBackend.notFetchedMints, fromBackend.tokensList);
+        if (!fromOldBackend.hasNotFetchedTokens) {
+            return this.sortTokensByIdx([...fromBackend.tokensList, ...fromOldBackend.tokensList]);
+        }
+        const fromMetaplex = await this.fetchTokensFromMetaplex(fromOldBackend.notFetchedMints, [
+            ...fromBackend.tokensList,
+            ...fromOldBackend.tokensList
+        ]);
+        if (!fromMetaplex.hasNotFetchedTokens) {
+            return this.sortTokensByIdx([...fromBackend.tokensList, ...fromOldBackend.tokensList, ...fromMetaplex.tokensList]);
+        }
+        const fromSplApi = await this.fetchTokensFromSplApi(fromMetaplex.notFetchedMints, [
+            ...fromBackend.tokensList,
+            ...fromOldBackend.tokensList,
+            ...fromMetaplex.tokensList
+        ]);
+        return this.sortTokensByIdx([
+            ...fromBackend.tokensList,
+            ...fromOldBackend.tokensList,
+            ...fromMetaplex.tokensList,
+            ...fromSplApi.tokensList
+        ]);
+    }
+    async fetchTokensFromBackend(mints) {
+        const tokensAddresses = mints.map((mint) => mint.toString());
+        const tokensList = await this.getTokensList(tokensAddresses);
+        const notFetchedMints = this.getNotFetchedTokensList(tokensList);
+        return {
+            tokensList,
+            notFetchedMints,
+            hasNotFetchedTokens: notFetchedMints.length > 0
+        };
+    }
+    async fetchTokensFromOldBackend(mints, prevFetchedTokens) {
+        const tokensAddresses = mints.map((mint) => mint.toString());
+        const { content: tokensFromOlbBackend } = await (0, timeout_1.withTimeout)(this.getTokensListOld(tokensAddresses), 3000, 'Api Timeout!').catch(() => ({ content: [] }));
+        const notSortedTokensList = [...prevFetchedTokens, ...tokensFromOlbBackend];
+        const notFetchedMints = this.getNotFetchedTokensList(notSortedTokensList);
+        return {
+            tokensList: notSortedTokensList,
+            notFetchedMints,
+            hasNotFetchedTokens: notFetchedMints.length > 0
+        };
+    }
+    async fetchTokensFromMetaplex(mints, prevFetchedTokens) {
+        const tokenSDK = new utl_sdk_1.Client();
+        const metaplexTokens = await tokenSDK.getFromMetaplex(mints).catch(() => []);
+        const notSortedTokensList = [...prevFetchedTokens, ...metaplexTokens];
+        const notFetchedMints = this.getNotFetchedTokensList(notSortedTokensList);
+        return {
+            tokensList: metaplexTokens,
+            notFetchedMints,
+            hasNotFetchedTokens: notFetchedMints.length > 0
+        };
+    }
+    async fetchTokensFromSplApi(mints, prevFetchedTokens) {
+        const splApiResp = await Promise.all(mints.map((mint) => (0, spl_token_1.getMint)(this.connection, mint, 'confirmed'))).catch(() => []);
+        const splApiTokens = splApiResp.filter(Boolean).map((token) => ({
+            name: `Token ${token.address.toString().slice(0, 10)}`,
+            symbol: `Token ${token.address.toString().slice(0, 10)}`,
+            logoURI: null,
+            decimals: token.decimals,
+            address: token.address.toString(),
+            verified: token.isInitialized
+        }));
+        const notSortedTokensList = [...prevFetchedTokens, ...splApiTokens];
+        const notFetchedMints = this.getNotFetchedTokensList(notSortedTokensList);
+        return {
+            tokensList: notSortedTokensList,
+            notFetchedMints,
+            hasNotFetchedTokens: notFetchedMints.length > 0
+        };
+    }
+    sortTokensByIdx(notSortedList) {
+        const sortedList = [];
+        for (const token of notSortedList) {
+            const originalIdx = this.tokensOrder[token.address.toLowerCase()];
+            sortedList[originalIdx] = token;
+        }
+        return sortedList;
+    }
+    getNotFetchedTokensList(tokensList) {
+        const fetchedTokensMap = new Map();
+        tokensList.forEach((t) => fetchedTokensMap.set(t.address, t));
+        const notFetchedTokensList = this.initialMints.filter((mint) => !fetchedTokensMap.get(mint.toString()));
+        return notFetchedTokensList;
+    }
+    async getTokensList(tokenAddresses) {
+        try {
+            const queryParams = tokenAddresses.length > 1 ? { addresses: tokenAddresses.join(',') } : { query: tokenAddresses[0] };
+            const resp = await this.httpClient.get(`${this.newTokensEndpoint}/tokens`, {
+                params: queryParams
+            });
+            return resp.results.map((t) => ({
+                address: t.address,
+                decimals: t.decimals,
+                logoURI: t.image,
+                name: t.name,
+                symbol: t.symbol
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    getTokensListOld(tokenAddresses) {
+        return this.httpClient.post(`${this.apiEndpoint}/mints?chainId=101`, { addresses: tokenAddresses }, {
+            headers: {
+                apiKey: this.xApiKey
+            }
+        });
+    }
+}
+exports.SolanaTokensService = SolanaTokensService;

package/src/lib/adapter/adapters/utils/timeout.d.ts

@@ -0,0 +1 @@
+export declare function withTimeout<T>(promise: Promise<T>, ms: number, timeoutText?: string): Promise<T>;

package/src/lib/adapter/adapters/utils/timeout.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withTimeout = withTimeout;
+function withTimeout(promise, ms, timeoutText) {
+    let timeoutId = null;
+    const rejectOnDeadline = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+            reject(timeoutText);
+        }, ms);
+    });
+    return Promise.race([rejectOnDeadline, promise]).finally(() => {
+        if (timeoutId)
+            clearTimeout(timeoutId);
+    });
+}

package/src/lib/adapter/blockchain-adapter-factory.service.js

@@ -40,12 +40,6 @@ class BlockchainAdapterFactoryService {
         const adapters = Object.entries(this.rpcList).map(([blockchain, rpcs]) => {
             const adapter = this.createAdapter(blockchain, rpcs || []);
             return [blockchain, adapter || null];
-            if (adapter) {
-                this.logger?.customLog(`Creating adapter for ${blockchain} blockchain`);
-                return [blockchain, adapter];
-            }
-            this.logger?.customWarn(`Failed to create adapter for ${blockchain} blockchain`);
-            return [blockchain, null];
         });
         const tonAdapter = this.createAdapter(core_1.BLOCKCHAIN_NAME.TON, []);
         const btcAdapter = this.createAdapter(core_1.BLOCKCHAIN_NAME.BITCOIN, []);
@@ -80,10 +74,10 @@ class BlockchainAdapterFactoryService {
                 return new sui_adapter_1.SuiAdapter(rpcs, this.createLogger?.(`SUI_ADAPTER`));
             }
             if (blockchainType === core_1.CHAIN_TYPE.SOLANA) {
-                return new solana_adapter_1.SolanaAdapter(rpcs, this.createLogger?.(`SOLANA_ADAPTER`));
+                return new solana_adapter_1.SolanaAdapter(rpcs, this.httpClient, this.createLogger?.(`SOLANA_ADAPTER`));
             }
         }
-        if (blockchain === core_1.BLOCKCHAIN_NAME.TON && this.httpClient && this.tonParams?.tonApiConfig && this.tonParams?.tonClientConfig) {
+        if (blockchain === core_1.BLOCKCHAIN_NAME.TON && this.tonParams?.tonApiConfig && this.tonParams?.tonClientConfig) {
             return new ton_adapter_1.TonAdapter(this.httpClient, this.tonParams, this.createLogger?.(`TON_ADAPTER`));
         }
         if (blockchain === core_1.BLOCKCHAIN_NAME.BITCOIN && this.httpClient) {