@cryptorubic/web3 1.3.1 → 1.4.1

package/README.md

@@ -1 +1 @@
-# web3
+# web3

package/package.json

@@ -1,12 +1,13 @@
 {
     "name": "@cryptorubic/web3",
-    "version": "1.3.1",
+    "version": "1.4.1",
     "dependencies": {
         "@ethersproject/bignumber": "^5.8.0",
         "@mysten/sui": "^1.24.0",
         "@solana/spl-token": "*",
         "@solana/web3.js": "1.95.3",
         "@solflare-wallet/utl-sdk": "^1.4.0",
+        "@stellar/stellar-sdk": "^14.4.3",
         "@suiet/wallet-sdk": "^0.3.3",
         "@ton/core": "^0.59.1",
         "@ton/ton": "^15.1.0",

package/src/lib/adapter/adapters/adapter-stellar/constants/fake-stellar-wallet.d.ts

@@ -0,0 +1 @@
+export declare const FAKE_STELLAR_WALLET = "GA43DZREOL4ISMF3RE4ETB4DVJVTITWEWTKPGJRZW4EOZCOCNLNOUVVB";

package/src/lib/adapter/adapters/adapter-stellar/constants/fake-stellar-wallet.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAKE_STELLAR_WALLET = void 0;
+exports.FAKE_STELLAR_WALLET = 'GA43DZREOL4ISMF3RE4ETB4DVJVTITWEWTKPGJRZW4EOZCOCNLNOUVVB';

package/src/lib/adapter/adapters/adapter-stellar/models/stellar-client.d.ts

@@ -0,0 +1,2 @@
+import { rpc } from '@stellar/stellar-sdk';
+export type StellarClient = rpc.Server;

package/src/lib/adapter/adapters/adapter-stellar/models/stellar-client.js

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

package/src/lib/adapter/adapters/adapter-stellar/models/stellar-rpc-provider.d.ts

@@ -0,0 +1,6 @@
+export interface StellarRpcProvider {
+    horizon: string;
+    soroban: string;
+    horizonHeaders?: Record<string, string>;
+    sorobanHeaders?: Record<string, string>;
+}

package/src/lib/adapter/adapters/adapter-stellar/models/stellar-rpc-provider.js

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

package/src/lib/adapter/adapters/adapter-stellar/models/stellar-send-tx-params.d.ts

@@ -0,0 +1,8 @@
+import { BasicSendTransactionOptions } from '../../models/basic-transaction-options';
+import { Transaction } from '@stellar/stellar-sdk';
+export interface StellarSendTxParams {
+    txOptions: StellarTransactionOptions;
+}
+export interface StellarTransactionOptions extends BasicSendTransactionOptions {
+    transaction: string | Transaction;
+}

package/src/lib/adapter/adapters/adapter-stellar/models/stellar-send-tx-params.js

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

package/src/lib/adapter/adapters/adapter-stellar/models/stellar-wallet.d.ts

@@ -0,0 +1,87 @@
+export interface StellarWallet {
+    /**
+     * Function used to request the public key from the active account or
+     * specific path on a wallet.
+     *
+     * @param params
+     * @param params.path - The path to tell the wallet which position to ask. This is commonly used in hardware wallets.
+     * @param params.skipRequestAccess - Freighter separates the access request from the logic of getting the address, if this is set to true we will avoid requesting the access
+     *
+     * @return Promise<{ address: string }>
+     */
+    getAddress(params?: {
+        path?: string;
+        skipRequestAccess?: boolean;
+    }): Promise<{
+        address: string;
+    }>;
+    /**
+     * A function to request a wallet to sign a built transaction in its XDR mode
+     *
+     * @param xdr - A Transaction or a FeeBumpTransaction
+     * @param opts - Options compatible with https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0043.md#signtransaction
+     * @param opts.networkPassphrase - The Stellar network to use when signing
+     * @param opts.address - The public key of the account that should be used to sign
+     * @param opts.path - This options is added for special cases like Hardware wallets
+     *
+     * @return Promise<{ signedTxXdr: string; signerAddress: string }>
+     */
+    signTransaction(xdr: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+        path?: string;
+        submit?: boolean;
+        submitUrl?: string;
+    }): Promise<{
+        signedTxXdr: string;
+        signerAddress?: string;
+    }>;
+    /**
+     * A function to request a wallet to sign an AuthEntry XDR.
+     *
+     * @param authEntry - An XDR string version of `HashIdPreimageSorobanAuthorization`
+     * @param opts - Options compatible with https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0043.md#signauthentry
+     * @param opts.networkPassphrase - The Stellar network to use when signing
+     * @param opts.address - The public key of the account that should be used to sign
+     * @param opts.path - This options is added for special cases like Hardware wallets
+     *
+     * @return - Promise<{ signedAuthEntry: string; signerAddress: string }>
+     */
+    signAuthEntry(authEntry: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+        path?: string;
+    }): Promise<{
+        signedAuthEntry: string;
+        signerAddress?: string;
+    }>;
+    /**
+     * A function to request a wallet to sign an AuthEntry XDR.
+     *
+     * @param message - An arbitrary string rather than a transaction or auth entry
+     * @param opts - Options compatible with https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0043.md#signmessage
+     * @param opts.networkPassphrase - The Stellar network to use when signing
+     * @param opts.address - The public key of the account that should be used to sign
+     * @param opts.path - This options is added for special cases like Hardware wallets
+     *
+     * @return - Promise<{ signedMessage: string; signerAddress: string }>
+     */
+    signMessage(message: string, opts?: {
+        networkPassphrase?: string;
+        address?: string;
+        path?: string;
+    }): Promise<{
+        signedMessage: string;
+        signerAddress?: string;
+    }>;
+    /**
+     * A function to request the current selected network in the wallet. This comes
+     * handy when you are dealing with a wallet that doesn't allow you to specify which network to use (For example Lobstr and Rabet)
+     *
+     * @return - Promise<{ network: string; networkPassphrase: string }>
+     */
+    getNetwork(): Promise<{
+        network: string;
+        networkPassphrase: string;
+    }>;
+}

package/src/lib/adapter/adapters/adapter-stellar/models/stellar-wallet.js

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

package/src/lib/adapter/adapters/adapter-stellar/signer/stellar-adapter-signer.d.ts

@@ -0,0 +1,18 @@
+import { BlockchainName, HttpClient, ICustomLogger } from '@cryptorubic/core';
+import { AbstractAdapterSigner } from '../../common/signer/abstract-adapter-signer';
+import { StellarClient } from '../models/stellar-client';
+import { StellarSendTxParams } from '../models/stellar-send-tx-params';
+import { StellarWallet } from '../models/stellar-wallet';
+import { ClientAdaptersFactoryParams } from '../../../models/create-factory-params';
+import { xdr } from '@stellar/stellar-sdk';
+export declare class StellarAdapterSigner extends AbstractAdapterSigner<StellarWallet, StellarSendTxParams, string> {
+    private readonly publicRef;
+    get publicClient(): StellarClient;
+    constructor(publicRef: {
+        public: StellarClient | null;
+    }, httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    write<T>(): Promise<T>;
+    getBlockchainName(): Promise<BlockchainName>;
+    sendTransaction(params: StellarSendTxParams): Promise<string>;
+    parseTxError(txResult: xdr.TransactionResult): void;
+}

package/src/lib/adapter/adapters/adapter-stellar/signer/stellar-adapter-signer.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StellarAdapterSigner = void 0;
+const core_1 = require("@cryptorubic/core");
+const abstract_adapter_signer_1 = require("../../common/signer/abstract-adapter-signer");
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+const bignumber_js_1 = require("bignumber.js");
+const insufficient_funds_gas_price_value_error_1 = require("../../../../errors/cross-chain/insufficient-funds-gas-price-value.error");
+class StellarAdapterSigner extends abstract_adapter_signer_1.AbstractAdapterSigner {
+    get publicClient() {
+        if (!this.publicRef.public) {
+            const msg = 'Trying to access undefined publicClient in StellarAdapterSigner';
+            this.logger?.customLog(msg);
+            throw new Error(msg);
+        }
+        return this.publicRef.public;
+    }
+    constructor(publicRef, httpClient, logger, clientParams) {
+        super(httpClient, logger, clientParams);
+        this.publicRef = publicRef;
+    }
+    async write() {
+        throw new Error('Method write is not supported');
+    }
+    getBlockchainName() {
+        return Promise.resolve(core_1.BLOCKCHAIN_NAME.STELLAR);
+    }
+    async sendTransaction(params) {
+        try {
+            const transaction = typeof params.txOptions.transaction === 'string'
+                ? stellar_sdk_1.TransactionBuilder.fromXDR(params.txOptions.transaction, stellar_sdk_1.Networks.PUBLIC)
+                : params.txOptions.transaction;
+            const [preparedTransaction, accountInfo] = await Promise.all([
+                this.publicClient.prepareTransaction(transaction),
+                this.publicClient.getAccountEntry(this.walletAddress)
+            ]);
+            // account has min required balance that cannot be spent
+            const minBalance = new bignumber_js_1.default(2 + accountInfo.numSubEntries()).multipliedBy(5000000);
+            const necessaryBalance = minBalance.plus(preparedTransaction.fee);
+            if (necessaryBalance.gt(accountInfo.balance().toString())) {
+                throw new insufficient_funds_gas_price_value_error_1.InsufficientFundsGasPriceValueError();
+            }
+            const { signedTxXdr } = await this.wallet.signTransaction(preparedTransaction.toXDR(), {
+                networkPassphrase: stellar_sdk_1.Networks.PUBLIC,
+                address: this.walletAddress
+            });
+            const resp = await this.publicClient.sendTransaction(stellar_sdk_1.TransactionBuilder.fromXDR(signedTxXdr, stellar_sdk_1.Networks.PUBLIC));
+            const txStatus = await this.publicClient.pollTransaction(resp.hash);
+            if (txStatus.status === 'FAILED') {
+                this.parseTxError(txStatus.resultXdr);
+            }
+            if (params.txOptions.onTransactionHash) {
+                params.txOptions.onTransactionHash?.(txStatus.txHash);
+            }
+            return txStatus.txHash;
+        }
+        catch (err) {
+            console.error('Send transaction error', err);
+            throw err;
+        }
+    }
+    parseTxError(txResult) {
+        const failedTxCode = txResult.result().switch().name;
+        if (failedTxCode === 'txInsufficientBalance') {
+            throw new insufficient_funds_gas_price_value_error_1.InsufficientFundsGasPriceValueError();
+        }
+        const failedOperation = txResult.result().results()[0];
+        const failedOperationCode = failedOperation.tr().value().switch().name;
+        if (failedOperationCode === 'changeTrustLowReserve') {
+            throw new insufficient_funds_gas_price_value_error_1.InsufficientFundsGasPriceValueError();
+        }
+        throw new Error(failedOperationCode);
+    }
+}
+exports.StellarAdapterSigner = StellarAdapterSigner;

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

@@ -0,0 +1,54 @@
+import { BlockchainName, HttpClient, ICustomLogger, PriceTokenAmount, StellarBlockchainName, Token, TokenAmount } from '@cryptorubic/core';
+import { AbstractAdapter } from '../common/abstract-adapter';
+import { StellarClient } from './models/stellar-client';
+import { StellarWallet } from './models/stellar-wallet';
+import { TxStatus } from '../models/web3-public-models/tx-status';
+import { Account, Horizon } from '@stellar/stellar-sdk';
+import { ClientAdaptersFactoryParams } from '../../models/create-factory-params';
+import { StellarAdapterSigner } from './signer/stellar-adapter-signer';
+import BigNumber from 'bignumber.js';
+import { Web3PrimitiveType } from '../../../utils/models/primitive-types';
+import { Abi } from 'viem';
+import { MethodData } from '../models/web3-public-models/method-data';
+import { ContractMulticallResponse } from '../models/web3-public-models/contract-multicall-response';
+import { StellarTransactionConfig } from '../../../utils/models/stellar-transaction-config';
+import { StellarRpcProvider } from './models/stellar-rpc-provider';
+export declare class StellarAdapter extends AbstractAdapter<StellarClient, StellarWallet, StellarBlockchainName> {
+    private readonly rpc;
+    readonly signer: StellarAdapterSigner;
+    readonly horizonClient: Horizon.Server;
+    private readonly CLASSIC_TOKEN_DECIMALS;
+    constructor(rpc: StellarRpcProvider[], httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    initWeb3Client(): void;
+    getBlockNumber(): Promise<number | {
+        blockNumber: number;
+        workchain: number;
+    }>;
+    getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
+    getBalance(userAddress: string, tokenAddress?: string): Promise<BigNumber>;
+    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
+    callForTokenInfo(tokenAddress: string): Promise<Token<BlockchainName>>;
+    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
+    needTrustline(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
+    addTrustline(tokenAddress: string): Promise<string>;
+    encodeTrustline(tokenAddress: string, walletAddress: string): Promise<string>;
+    getTokenContractId(tokenAddress: string): string;
+    private convertTokenAddressToAsset;
+    read<T>(address: string, method: string, methodArgs?: {
+        value: string;
+        type: string;
+    }[]): Promise<T>;
+    simulateTransaction(config: StellarTransactionConfig): Promise<string>;
+    getTransactionStatus(srcTxHash: string): Promise<TxStatus>;
+    getMinWeiBalance(userAddress: string): Promise<BigNumber>;
+    getFeeFromTransaction(xdr: string): BigNumber;
+    getAccountInfo(walletAddress: string): Promise<Account>;
+    callContractMethod<T extends Web3PrimitiveType = string>(_contractAddress: string, _contractAbi: Abi | undefined, _methodName: string, _methodArguments?: {
+        value: string;
+        type: string;
+    }[], _options?: object): Promise<T>;
+    multicallContractsMethods<Output extends Web3PrimitiveType>(_contractAbi: Abi, _contractsData: {
+        contractAddress: string;
+        methodsData: MethodData[];
+    }[]): Promise<ContractMulticallResponse<Output>[][]>;
+}

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

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StellarAdapter = void 0;
+const core_1 = require("@cryptorubic/core");
+const abstract_adapter_1 = require("../common/abstract-adapter");
+const tx_status_1 = require("../models/web3-public-models/tx-status");
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+const stellar_adapter_signer_1 = require("./signer/stellar-adapter-signer");
+const stellar_sdk_2 = require("@stellar/stellar-sdk");
+const bignumber_js_1 = require("bignumber.js");
+const web3_pure_1 = require("../../../utils/web3-pure");
+const fake_stellar_wallet_1 = require("./constants/fake-stellar-wallet");
+const inactive_account_error_1 = require("../../../errors/blockchain/inactive-account.error");
+class StellarAdapter extends abstract_adapter_1.AbstractAdapter {
+    constructor(rpc, httpClient, logger, clientParams) {
+        super(core_1.BLOCKCHAIN_NAME.STELLAR, logger);
+        this.rpc = rpc;
+        this.CLASSIC_TOKEN_DECIMALS = 7;
+        this.signer = new stellar_adapter_signer_1.StellarAdapterSigner(this.publicRef, httpClient, logger, clientParams);
+        this.horizonClient = new stellar_sdk_1.Horizon.Server(rpc[0].horizon, {
+            allowHttp: true,
+            appName: 'rubic.exchange',
+            headers: rpc[0].horizonHeaders
+        });
+    }
+    initWeb3Client() {
+        this.public = new stellar_sdk_2.rpc.Server(this.rpc[0].soroban, {
+            allowHttp: true,
+            timeout: 5000,
+            headers: this.rpc[0].sorobanHeaders
+        });
+    }
+    async getBlockNumber() {
+        const { sequence } = await this.public.getLatestLedger();
+        return sequence;
+    }
+    async getTokensBalances(userAddress, tokensAddresses) {
+        try {
+            const balances = (await this.horizonClient.loadAccount(userAddress)).balances;
+            return tokensAddresses.map((token) => {
+                const possibleBalance = balances.find((balance) => {
+                    if (balance.asset_type === 'native') {
+                        return web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.STELLAR, token);
+                    }
+                    const tokenBalance = balance;
+                    return (0, core_1.compareAddresses)(token, `${tokenBalance.asset_code}-${tokenBalance.asset_issuer}`);
+                });
+                return new bignumber_js_1.default(core_1.Token.toWei(possibleBalance?.balance || '0', this.CLASSIC_TOKEN_DECIMALS));
+            });
+        }
+        catch (err) {
+            console.error(err);
+            return tokensAddresses.map(() => new bignumber_js_1.default(0));
+        }
+    }
+    async getBalance(userAddress, tokenAddress) {
+        try {
+            if (!tokenAddress || web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.STELLAR, tokenAddress)) {
+                const resp = await this.public.getAccountEntry(userAddress);
+                return new bignumber_js_1.default(resp.balance().toString());
+            }
+            const resp = await this.public.getTrustline(userAddress, this.convertTokenAddressToAsset(tokenAddress));
+            return new bignumber_js_1.default(resp.balance().toString());
+        }
+        catch {
+            return new bignumber_js_1.default(0);
+        }
+    }
+    async callForTokensInfo(tokenAddresses) {
+        return Promise.all(tokenAddresses.map((token) => this.callForTokenInfo(token)));
+    }
+    async callForTokenInfo(tokenAddress) {
+        if (web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.STELLAR, tokenAddress)) {
+            return core_1.nativeTokensList[core_1.BLOCKCHAIN_NAME.STELLAR];
+        }
+        const [code, issuer] = tokenAddress.toUpperCase().split('-');
+        try {
+            const fetchedTokens = await this.horizonClient.assets().forIssuer(issuer).limit(200).call();
+            const fetchedToken = fetchedTokens.records.find((fetchedToken) => (0, core_1.compareAddresses)(fetchedToken.asset_code, code) &&
+                (0, core_1.compareAddresses)(fetchedToken.asset_issuer, issuer) &&
+                parseFloat(fetchedToken.balances.authorized) > 0);
+            if (fetchedToken && 'toml' in fetchedToken._links) {
+                const { href } = fetchedToken._links.toml;
+                if (href) {
+                    const { CURRENCIES } = await stellar_sdk_1.StellarToml.Resolver.resolve(new URL(href).hostname, { allowHttp: true }).catch(() => ({}));
+                    if (CURRENCIES) {
+                        const tomlToken = CURRENCIES.find((currency) => (0, core_1.compareAddresses)(fetchedToken.asset_code, currency.code) &&
+                            (0, core_1.compareAddresses)(fetchedToken.asset_issuer, currency.issuer));
+                        return new core_1.Token({
+                            name: tomlToken.name || tomlToken.code,
+                            symbol: tomlToken.code,
+                            decimals: tomlToken.display_decimals || this.CLASSIC_TOKEN_DECIMALS,
+                            blockchain: core_1.BLOCKCHAIN_NAME.STELLAR,
+                            address: `${tomlToken.code}-${tomlToken.issuer}`
+                        });
+                    }
+                }
+                return new core_1.Token({
+                    name: fetchedToken.asset_code,
+                    symbol: fetchedToken.asset_code,
+                    decimals: this.CLASSIC_TOKEN_DECIMALS,
+                    blockchain: core_1.BLOCKCHAIN_NAME.STELLAR,
+                    address: `${fetchedToken.asset_code}-${fetchedToken.asset_issuer}`
+                });
+            }
+            throw new Error('Token not found');
+        }
+        catch (err) {
+            console.error(err);
+            throw err;
+        }
+    }
+    async checkEnoughBalance(token, walletAddress) {
+        const userBalance = await this.getBalance(walletAddress, token.address);
+        return userBalance.gte(token.weiAmount);
+    }
+    async needTrustline(token, walletAddress) {
+        const isCorrectWalletAddress = await web3_pure_1.Web3Pure.isAddressCorrect(core_1.BLOCKCHAIN_NAME.STELLAR, walletAddress);
+        if (token.isNative || !isCorrectWalletAddress)
+            return false;
+        try {
+            const trustline = await this.public.getTrustline(walletAddress, this.convertTokenAddressToAsset(token.address));
+            return new bignumber_js_1.default(trustline.limit().toString()).lt(token.weiAmount);
+        }
+        catch (err) {
+            return true;
+        }
+    }
+    async addTrustline(tokenAddress) {
+        try {
+            const tx = await this.encodeTrustline(tokenAddress, this.signer.walletAddress);
+            const { signedTxXdr } = await this.signer.wallet.signTransaction(tx, {
+                networkPassphrase: stellar_sdk_1.Networks.PUBLIC,
+                address: this.signer.walletAddress
+            });
+            const resp = await this.public.sendTransaction(stellar_sdk_1.TransactionBuilder.fromXDR(signedTxXdr, stellar_sdk_1.Networks.PUBLIC));
+            if (resp.status === 'ERROR' && resp.errorResult) {
+                this.signer.parseTxError(resp.errorResult);
+            }
+            const resStatus = await this.public.pollTransaction(resp.hash);
+            if (resStatus.status === 'FAILED') {
+                this.signer.parseTxError(resStatus.resultXdr);
+            }
+            return resStatus.txHash;
+        }
+        catch (err) {
+            this.logger?.customError('FAILED TO ADD TRUSTLINE', err);
+            throw err;
+        }
+    }
+    async encodeTrustline(tokenAddress, walletAddress) {
+        const account = await this.getAccountInfo(walletAddress);
+        const tx = new stellar_sdk_1.TransactionBuilder(account, {
+            fee: stellar_sdk_1.BASE_FEE,
+            networkPassphrase: stellar_sdk_1.Networks.PUBLIC
+        })
+            .addOperation(stellar_sdk_1.Operation.changeTrust({
+            asset: this.convertTokenAddressToAsset(tokenAddress)
+        }))
+            .setTimeout(600)
+            .build();
+        return tx.toXDR();
+    }
+    getTokenContractId(tokenAddress) {
+        if (web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.STELLAR, tokenAddress)) {
+            return stellar_sdk_1.Asset.native().contractId(stellar_sdk_1.Networks.PUBLIC);
+        }
+        return this.convertTokenAddressToAsset(tokenAddress).contractId(stellar_sdk_1.Networks.PUBLIC);
+    }
+    convertTokenAddressToAsset(tokenAddress) {
+        const [code, issuer] = tokenAddress.split('-');
+        return new stellar_sdk_1.Asset(code, issuer);
+    }
+    async read(address, method, methodArgs = []) {
+        const contract = new stellar_sdk_1.Contract(address);
+        const args = methodArgs.map(({ value, type }) => (0, stellar_sdk_1.nativeToScVal)(value, { type }));
+        const operation = contract.call(method, ...args);
+        const tx = new stellar_sdk_1.TransactionBuilder(new stellar_sdk_1.Account(fake_stellar_wallet_1.FAKE_STELLAR_WALLET, '0'), {
+            fee: stellar_sdk_1.BASE_FEE,
+            networkPassphrase: stellar_sdk_1.Networks.PUBLIC
+        })
+            .addOperation(operation)
+            .setTimeout(600)
+            .build();
+        const resp = await this.public.simulateTransaction(tx);
+        if ('error' in resp) {
+            throw new Error(resp.error);
+        }
+        const rawValue = resp.result.retval;
+        return (0, stellar_sdk_1.scValToNative)(rawValue);
+    }
+    async simulateTransaction(config) {
+        try {
+            const resp = await this.public.simulateTransaction(stellar_sdk_1.TransactionBuilder.fromXDR(config.transaction, stellar_sdk_1.Networks.PUBLIC));
+            if ('error' in resp) {
+                throw new Error(resp.error);
+            }
+            return resp.minResourceFee;
+        }
+        catch (err) {
+            this.logger?.customError('Error while simulating transaction', err);
+            throw err;
+        }
+    }
+    async getTransactionStatus(srcTxHash) {
+        try {
+            const resp = await this.public.pollTransaction(srcTxHash);
+            if (resp.status === 'SUCCESS') {
+                return tx_status_1.TX_STATUS.SUCCESS;
+            }
+            if (resp.status === 'FAILED') {
+                return tx_status_1.TX_STATUS.FAIL;
+            }
+            return tx_status_1.TX_STATUS.PENDING;
+        }
+        catch {
+            return tx_status_1.TX_STATUS.PENDING;
+        }
+    }
+    async getMinWeiBalance(userAddress) {
+        try {
+            const resp = await this.public.getAccountEntry(userAddress);
+            const baseReserve = 5000000;
+            return new bignumber_js_1.default(2 + resp.numSubEntries()).multipliedBy(baseReserve);
+        }
+        catch {
+            return new bignumber_js_1.default(0);
+        }
+    }
+    getFeeFromTransaction(xdr) {
+        const parsedTranssaction = stellar_sdk_1.TransactionBuilder.fromXDR(xdr, stellar_sdk_1.Networks.PUBLIC);
+        return new bignumber_js_1.default(parsedTranssaction.fee);
+    }
+    async getAccountInfo(walletAddress) {
+        try {
+            const account = await this.public.getAccount(walletAddress);
+            return account;
+        }
+        catch (err) {
+            if (err.message?.includes('Account not found')) {
+                throw new inactive_account_error_1.InactiveAccountError();
+            }
+            throw err;
+        }
+    }
+    async callContractMethod(_contractAddress, _contractAbi = [], _methodName, _methodArguments = [], _options) {
+        throw new Error('Method call is not supported');
+    }
+    multicallContractsMethods(_contractAbi, _contractsData) {
+        throw new Error('Method multicall is not supported');
+    }
+}
+exports.StellarAdapter = StellarAdapter;

package/src/lib/adapter/adapters/models/web3-public-models/tx-status.d.ts

@@ -4,7 +4,10 @@ export declare const TX_STATUS: {
     readonly FAIL: "FAIL";
     readonly FALLBACK: "FALLBACK";
     readonly REVERT: "REVERT";
+    readonly REVERTED: "REVERTED";
     readonly UNKNOWN: "UNKNOWN";
     readonly READY_TO_CLAIM: "READY_TO_CLAIM";
+    readonly WAITING_FOR_TRUSTLINE: "WAITING_FOR_TRUSTLINE";
+    readonly WAITING_FOR_REFUND_TRUSTLINE: "WAITING_FOR_REFUND_TRUSTLINE";
 };
 export type TxStatus = (typeof TX_STATUS)[keyof typeof TX_STATUS];

package/src/lib/adapter/adapters/models/web3-public-models/tx-status.js

@@ -7,6 +7,9 @@ exports.TX_STATUS = {
     FAIL: 'FAIL',
     FALLBACK: 'FALLBACK',
     REVERT: 'REVERT',
+    REVERTED: 'REVERTED',
     UNKNOWN: 'UNKNOWN',
-    READY_TO_CLAIM: 'READY_TO_CLAIM'
+    READY_TO_CLAIM: 'READY_TO_CLAIM',
+    WAITING_FOR_TRUSTLINE: 'WAITING_FOR_TRUSTLINE',
+    WAITING_FOR_REFUND_TRUSTLINE: 'WAITING_FOR_REFUND_TRUSTLINE'
 };

package/src/lib/adapter/blockchain-adapter-factory.service.d.ts

@@ -1,6 +1,6 @@
 import { AbstractAdapter } from './adapters/common/abstract-adapter';
 import { WalletProviderCore } from './constants/models/wallet-provider';
-import { BlockchainName, EvmBlockchainName, SolanaBlockchainName, TronBlockchainName, ICustomLogger, TonBlockchainName, BitcoinBlockchainName, SuiBlockchainName } from '@cryptorubic/core';
+import { BlockchainName, EvmBlockchainName, SolanaBlockchainName, TronBlockchainName, ICustomLogger, TonBlockchainName, BitcoinBlockchainName, SuiBlockchainName, StellarBlockchainName } from '@cryptorubic/core';
 import { TonAdapter } from './adapters/adapter-ton/ton-adapter';
 import { EvmAdapter } from './adapters/adapter-evm/evm-adapter';
 import { BitcoinAdapter } from './adapters/adapter-bitcoin/bitcoin-adapter';
@@ -8,6 +8,7 @@ import { SolanaAdapter } from './adapters/adapter-solana/solana-adapter';
 import { TronAdapter } from './adapters/adapter-tron/tron-adapter';
 import { SuiAdapter } from './adapters/adapter-sui/sui-adapter';
 import { AdapterFactoryParams } from './models/create-factory-params';
+import { StellarAdapter } from './adapters/adapter-stellar/stellar-adapter';
 export declare class BlockchainAdapterFactoryService {
     private readonly rpcList;
     private readonly httpClient;
@@ -25,6 +26,7 @@ export declare class BlockchainAdapterFactoryService {
     getAdapter(blockchain: TonBlockchainName): TonAdapter;
     getAdapter(blockchain: BitcoinBlockchainName): BitcoinAdapter;
     getAdapter(blockchain: SuiBlockchainName): SuiAdapter;
+    getAdapter(blockchain: StellarBlockchainName): StellarAdapter;
     private createStorage;
     private createAdapter;
     connectWallet(blockchain: BlockchainName, wallet: WalletProviderCore): void;

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

@@ -9,6 +9,7 @@ const bitcoin_adapter_1 = require("./adapters/adapter-bitcoin/bitcoin-adapter");
 const solana_adapter_1 = require("./adapters/adapter-solana/solana-adapter");
 const tron_adapter_1 = require("./adapters/adapter-tron/tron-adapter");
 const sui_adapter_1 = require("./adapters/adapter-sui/sui-adapter");
+const stellar_adapter_1 = require("./adapters/adapter-stellar/stellar-adapter");
 class BlockchainAdapterFactoryService {
     constructor(rpcList, httpClient, createLogger, tonParams, clientParams) {
         this.rpcList = rpcList;
@@ -80,6 +81,9 @@ class BlockchainAdapterFactoryService {
             if (blockchainType === core_1.CHAIN_TYPE.SOLANA) {
                 return new solana_adapter_1.SolanaAdapter(rpcs, this.httpClient, this.createLogger?.(`SOLANA_ADAPTER`), this.clientParams);
             }
+            if (blockchain === core_1.BLOCKCHAIN_NAME.STELLAR) {
+                return new stellar_adapter_1.StellarAdapter(rpcs, this.httpClient, this.logger, this.clientParams);
+            }
         }
         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`), this.clientParams);

package/src/lib/adapter/constants/chain-configs/chain-configs.js

@@ -1491,5 +1491,32 @@ exports.viemConfig = {
                 address: '0xcA11bde05977b3631167028862bE2a173976CA11'
             }
         }
+    }),
+    MEGAETH: (0, viem_1.defineChain)({
+        id: 4326,
+        name: 'MegaETH',
+        network: 'MegaETH',
+        nativeCurrency: {
+            name: 'Ethereum',
+            symbol: 'ETH',
+            decimals: 18
+        },
+        rpcUrls: {
+            default: {
+                http: ['https://mainnet.megaeth.com/rpc']
+            }
+        },
+        blockExplorers: {
+            default: {
+                name: 'megaethblockscout',
+                url: 'https://mega.etherscan.io'
+            }
+        },
+        testnet: false,
+        contracts: {
+            multicall3: {
+                address: '0xcA11bde05977b3631167028862bE2a173976CA11'
+            }
+        }
     })
 };

package/src/lib/adapter/constants/viem-blockchain-mapping.js

@@ -78,5 +78,6 @@ exports.viemBlockchainMapping = {
     [core_1.BLOCKCHAIN_NAME.HEMI]: chain_configs_1.viemConfig[core_1.BLOCKCHAIN_NAME.HEMI],
     [core_1.BLOCKCHAIN_NAME.PLASMA]: chain_configs_1.viemConfig[core_1.BLOCKCHAIN_NAME.PLASMA],
     [core_1.BLOCKCHAIN_NAME.HYPER_EVM]: chain_configs_1.viemConfig[core_1.BLOCKCHAIN_NAME.HYPER_EVM],
-    [core_1.BLOCKCHAIN_NAME.MONAD]: chain_configs_1.viemConfig[core_1.BLOCKCHAIN_NAME.MONAD]
+    [core_1.BLOCKCHAIN_NAME.MONAD]: chain_configs_1.viemConfig[core_1.BLOCKCHAIN_NAME.MONAD],
+    [core_1.BLOCKCHAIN_NAME.MEGAETH]: chain_configs_1.viemConfig[core_1.BLOCKCHAIN_NAME.MEGAETH]
 };

package/src/lib/adapter/models/create-factory-params.d.ts

@@ -1,9 +1,10 @@
-import { EvmBlockchainName, HttpClient, ICustomLogger, SolanaBlockchainName, SuiBlockchainName, TronBlockchainName } from '@cryptorubic/core';
+import { EvmBlockchainName, HttpClient, ICustomLogger, SolanaBlockchainName, StellarBlockchainName, SuiBlockchainName, TronBlockchainName } from '@cryptorubic/core';
 import { EnvType } from '../constants/models/env-type';
 import { TronWebProvider } from '../adapters/adapter-tron/models/tron-web-provider';
 import { TonAdapterConfig } from '../adapters/models/ton-adapter-config';
 import { FallbackTransportConfig, HttpTransportConfig } from 'viem';
-export type RpcListType = Record<EvmBlockchainName, string[]> & Record<TronBlockchainName, TronWebProvider[]> & Record<SolanaBlockchainName, string[]> & Record<SuiBlockchainName, string[]>;
+import { StellarRpcProvider } from '../adapters/adapter-stellar/models/stellar-rpc-provider';
+export type RpcListType = Record<EvmBlockchainName, string[]> & Record<TronBlockchainName, TronWebProvider[]> & Record<SolanaBlockchainName, string[]> & Record<SuiBlockchainName, string[]> & Record<StellarBlockchainName, StellarRpcProvider[]>;
 export interface AdapterFactoryParams {
     rpcList: RpcListType;
     httpClient?: HttpClient;

package/src/lib/errors/blockchain/inactive-account.error.d.ts

@@ -0,0 +1,4 @@
+import { RubicSdkError } from '../rubic-sdk.error';
+export declare class InactiveAccountError extends RubicSdkError {
+    constructor();
+}

package/src/lib/errors/blockchain/inactive-account.error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InactiveAccountError = void 0;
+const rubic_sdk_error_1 = require("../rubic-sdk.error");
+class InactiveAccountError extends rubic_sdk_error_1.RubicSdkError {
+    constructor() {
+        super('Account is not activated');
+        Object.setPrototypeOf(this, InactiveAccountError.prototype);
+    }
+}
+exports.InactiveAccountError = InactiveAccountError;

package/src/lib/utils/constants/web3-pure-store.js

@@ -13,6 +13,7 @@ const ton_web3_pure_1 = require("../web3-types/ton-web3-pure");
 const tron_web3_pure_1 = require("../web3-types/tron-web3-pure");
 const changenow_api_blockchain_1 = require("./changenow-api-blockchain");
 const zcash_web3_pure_1 = require("../web3-types/zcash-web3-pure");
+const stellar_web3_pure_1 = require("../web3-types/stellar-web3-pure");
 exports.web3PureStore = {
     [core_1.CHAIN_TYPE.EVM]: new evm_web3_pure_1.EvmWeb3Pure(),
     [core_1.CHAIN_TYPE.SUI]: new sui_web3_pure_1.SuiWeb3Pure(),
@@ -25,6 +26,7 @@ exports.web3PureStore = {
     [core_1.CHAIN_TYPE.BSV]: new bitcoin_web3_pure_1.BitcoinWeb3Pure(),
     [core_1.CHAIN_TYPE.NEAR]: new near_web3_pure_1.NearWeb3Pure(),
     [core_1.CHAIN_TYPE.ZCASH]: new zcash_web3_pure_1.ZcashWeb3Pure(),
+    [core_1.CHAIN_TYPE.STELLAR]: new stellar_web3_pure_1.StellarWeb3Pure(),
     // Common Web3
     [core_1.CHAIN_TYPE.RIPPLE]: new common_web3_pure_1.CommonWeb3Pure({
         cnApiKey: changenow_api_blockchain_1.changenowApiBlockchain.RIPPLE,
@@ -133,10 +135,6 @@ exports.web3PureStore = {
         cnApiKey: changenow_api_blockchain_1.changenowApiBlockchain.WAX,
         regex: /^[a-z1-5.]{1,12}$/
     }),
-    [core_1.CHAIN_TYPE.STELLAR]: new common_web3_pure_1.CommonWeb3Pure({
-        cnApiKey: changenow_api_blockchain_1.changenowApiBlockchain.STEEM,
-        regex: /^G[A-D]{1}[A-Z2-7]{54}$/
-    }),
     [core_1.CHAIN_TYPE.XDC]: new common_web3_pure_1.CommonWeb3Pure({
         cnApiKey: changenow_api_blockchain_1.changenowApiBlockchain.XDC,
         regex: /^xdc[a-fA-F\d]{40}$/

package/src/lib/utils/models/stellar-transaction-config.d.ts

@@ -0,0 +1,3 @@
+export interface StellarTransactionConfig {
+    transaction: string;
+}

package/src/lib/utils/models/stellar-transaction-config.js

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

package/src/lib/utils/web3-types/stellar-web3-pure.d.ts

@@ -0,0 +1,5 @@
+import { CommonWeb3Pure } from './common-web3-pure';
+export declare class StellarWeb3Pure extends CommonWeb3Pure {
+    constructor();
+    isAddressCorrect(address: string): Promise<boolean>;
+}

package/src/lib/utils/web3-types/stellar-web3-pure.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StellarWeb3Pure = void 0;
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+const changenow_api_blockchain_1 = require("../constants/changenow-api-blockchain");
+const common_web3_pure_1 = require("./common-web3-pure");
+class StellarWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
+    constructor() {
+        super({
+            cnApiKey: changenow_api_blockchain_1.changenowApiBlockchain.STELLAR,
+            regex: /^G[A-Z2-7]{55}$/
+        });
+    }
+    async isAddressCorrect(address) {
+        try {
+            if (address.includes('-')) {
+                const [code, issuer] = address.split('-');
+                if (!code || !issuer)
+                    return false;
+                new stellar_sdk_1.Asset(code, issuer);
+                return true;
+            }
+            return this.regEx.test(address);
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.StellarWeb3Pure = StellarWeb3Pure;