@cryptorubic/web3 0.0.35 → 0.0.37-alpha-1212.0

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaAdapterSigner = void 0;
+const core_1 = require("@cryptorubic/core");
+const web3_js_1 = require("@solana/web3.js");
+const waitFor_1 = require("../../utils/waitFor");
+const js_base64_1 = require("js-base64");
+const user_reject_error_1 = require("../../../../errors/blockchain/user-reject.error");
+const errors_1 = require("../../utils/errors");
+const abstract_adapter_signer_1 = require("../../common/signer/abstract-adapter-signer");
+const tx_reverted_in_chain_error_1 = require("../../../../errors/common/tx-reverted-in-chain.error");
+class SolanaAdapterSigner extends abstract_adapter_signer_1.AbstractAdapterSigner {
+    get publicClient() {
+        if (!this.publicRef.public) {
+            const msg = `Trying to access undefined publicClient in SolanaAdapterSigner.`;
+            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.SOLANA);
+    }
+    async sendTransaction(params) {
+        try {
+            const decodedData = js_base64_1.Base64.toUint8Array(params.txOptions.data);
+            const tx = web3_js_1.VersionedTransaction.deserialize(decodedData);
+            const signedTx = await this.wallet.signTransaction(tx);
+            const txBase64 = js_base64_1.Base64.fromUint8Array(signedTx.serialize());
+            let signature;
+            if (params.txOptions?.sponsorParams) {
+                const response = await this.httpClient.post(`${this.apiUrl}/api/utility/solana/relay`, {
+                    data: txBase64,
+                    id: params.txOptions.sponsorParams.tradeId
+                });
+                signature = response.signature;
+            }
+            else {
+                try {
+                    const simulation = await this.publicClient.simulateTransaction(signedTx, {
+                        sigVerify: true,
+                        replaceRecentBlockhash: false
+                    });
+                    console.log(simulation);
+                }
+                catch (err) {
+                    console.log(err);
+                }
+                signature = await this.publicClient.sendRawTransaction(signedTx.serialize(), {
+                    maxRetries: 3,
+                    skipPreflight: false
+                });
+            }
+            params.txOptions.onTransactionHash?.(signature);
+            await this.waitForTxConfirmation(signature);
+            return signature;
+        }
+        catch (err) {
+            console.error(`[SolanaWeb3Private_sendTransaction] Error: ${err}`, { name: err.name, stack: err.stack });
+            if (err.message.includes('User rejected')) {
+                throw new user_reject_error_1.UserRejectError();
+            }
+            throw (0, errors_1.parseError)(err);
+        }
+    }
+    async waitForTxConfirmation(signature) {
+        const deadline = Date.now() + 3 * 60 * 1000;
+        let fetchedTx = null;
+        while (!fetchedTx && Date.now() < deadline) {
+            await (0, waitFor_1.waitFor)(5000);
+            fetchedTx = await this.publicClient.getTransaction(signature, {
+                commitment: 'confirmed',
+                maxSupportedTransactionVersion: 1
+            });
+        }
+        if (!fetchedTx || fetchedTx.meta?.err)
+            throw new tx_reverted_in_chain_error_1.TxRevertedInBlockchainError();
+    }
+}
+exports.SolanaAdapterSigner = SolanaAdapterSigner;

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

@@ -0,0 +1,49 @@
+import { AddressLookupTableAccount, Connection, Keypair, PublicKey, Transaction, TransactionInstruction, VersionedTransaction } from '@solana/web3.js';
+import { HttpClient, ICustomLogger, PriceTokenAmount, SolanaBlockchainName, Token, TokenAmount } from '@cryptorubic/core';
+import BigNumber from 'bignumber.js';
+import { AbstractAdapter } from '../common/abstract-adapter';
+import { SolanaRawInstruction } from '../models/solana-web3-types';
+import { ClientAdaptersFactoryParams } from '../../models/create-factory-params';
+import { SolanaWeb3 } from '../../constants/models/solana-web3';
+import { SolanaAdapterSigner } from './signer/solana-adapter-signer';
+import { Web3PrimitiveType } from '../../../utils/models/primitive-types';
+import { ContractMulticallResponse } from '../models/web3-public-models/contract-multicall-response';
+import { TxStatus } from '../models/web3-public-models/tx-status';
+export declare class SolanaAdapter extends AbstractAdapter<Connection, SolanaWeb3, SolanaBlockchainName> {
+    private readonly rpcList;
+    private readonly httpClient;
+    readonly signer: SolanaAdapterSigner;
+    constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    initWeb3Client(): void;
+    callContractMethod<T extends Web3PrimitiveType = string>(): Promise<T>;
+    read<T>(): Promise<T>;
+    getTransactionStatus(txHash: string): Promise<TxStatus>;
+    /**
+     * Gets balance of multiple tokens.
+     * @param address Wallet address.
+     * @param tokensAddresses Tokens addresses.
+     */
+    getTokensBalances(address: string, tokensAddresses: string[]): Promise<BigNumber[]>;
+    multicallContractsMethods<Output extends Web3PrimitiveType>(): Promise<ContractMulticallResponse<Output>[][]>;
+    getBlockNumber(): Promise<number | {
+        blockNumber: number;
+        workchain: number;
+    }>;
+    private createConection;
+    simulateTransaction(_config: object, _from: string): Promise<void>;
+    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
+    getBalance(userAddress: string, tokenAddress?: string): Promise<BigNumber>;
+    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<SolanaBlockchainName>[]>;
+    parseRawInstruction(rawInstruction: SolanaRawInstruction[], dataFormat: BufferEncoding): TransactionInstruction[];
+    parseLUTAddresses(lookupTableAddresses: string[]): Promise<AddressLookupTableAccount[]>;
+    createVersionedTransaction(instructions: TransactionInstruction[], walletAddress: string, addressLookupTableAccounts?: AddressLookupTableAccount[]): Promise<VersionedTransaction>;
+    getAtaAddress(walletAddress: string, tokenAddress: string): Promise<PublicKey>;
+    getKeypairFromSecret(pk?: string): Keypair | null;
+    getTxWithPayer(tx: VersionedTransaction, feePayer: string): Promise<VersionedTransaction>;
+    deserializeTransaction(data: string): VersionedTransaction;
+    serializeTransactionToBase58(tx: VersionedTransaction): string;
+    createTransferData(fromToken: PriceTokenAmount, walletAddress: string, receiver: string, convertToVersionedTx: boolean, allowOwnerOffCurve?: boolean): Promise<Transaction | VersionedTransaction>;
+    createNativeTransfer(fromAddress: PublicKey, toAddress: PublicKey, fromWeiAmount: string): Transaction;
+    createTokenTransfer(fromAddress: PublicKey, toAddress: PublicKey, fromTokenAddress: string, fromWeiAmount: string, allowOwnerOffCurve: boolean): Promise<Transaction>;
+    getLatestBlockhash(): Promise<string>;
+}

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

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolanaAdapter = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const core_1 = require("@cryptorubic/core");
+const bignumber_js_1 = require("bignumber.js");
+const bs58_1 = require("bs58");
+const js_base64_1 = require("js-base64");
+const abstract_adapter_1 = require("../common/abstract-adapter");
+const web3_pure_1 = require("../../../utils/web3-pure");
+const solana_tokens_service_1 = require("./services/solana-tokens-service");
+const solana_adapter_signer_1 = require("./signer/solana-adapter-signer");
+const tx_status_1 = require("../models/web3-public-models/tx-status");
+class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
+    constructor(rpcList, httpClient, logger, clientParams) {
+        super(core_1.BLOCKCHAIN_NAME.SOLANA, logger);
+        this.rpcList = rpcList;
+        this.httpClient = httpClient;
+        this.signer = new solana_adapter_signer_1.SolanaAdapterSigner(this.publicRef, httpClient, logger, clientParams);
+    }
+    initWeb3Client() {
+        this.public = this.createConection(this.rpcList);
+    }
+    async callContractMethod() {
+        throw new Error('Method call is not supported');
+    }
+    async read() {
+        throw new Error('Method read is not supported');
+    }
+    async getTransactionStatus(txHash) {
+        try {
+            const transaction = await this.public.getTransaction(txHash, {
+                maxSupportedTransactionVersion: 1
+            });
+            if (transaction?.meta?.err) {
+                return tx_status_1.TX_STATUS.FAIL;
+            }
+            if (transaction?.blockTime) {
+                return tx_status_1.TX_STATUS.SUCCESS;
+            }
+            return tx_status_1.TX_STATUS.PENDING;
+        }
+        catch {
+            return tx_status_1.TX_STATUS.PENDING;
+        }
+    }
+    /**
+     * Gets balance of multiple tokens.
+     * @param address Wallet address.
+     * @param tokensAddresses Tokens addresses.
+     */
+    async getTokensBalances(address, tokensAddresses) {
+        const resp = await this.public._rpcRequest('getTokenAccountsByOwner', [address, { programId: spl_token_1.TOKEN_PROGRAM_ID }, { encoding: 'jsonParsed' }]);
+        const tokenInfo = new Map(resp.result.value.map((el) => {
+            const { mint, tokenAmount } = el.account.data.parsed.info;
+            return [mint, tokenAmount.amount];
+        }));
+        const nativeSolBalance = await this.public.getBalanceAndContext(new web3_js_1.PublicKey(address), 'confirmed');
+        return tokensAddresses.map((tokenAddress) => {
+            if (tokenAddress === web3_pure_1.Web3Pure.getNativeTokenAddress(core_1.BLOCKCHAIN_NAME.SOLANA)) {
+                return new bignumber_js_1.default(nativeSolBalance.value.toString());
+            }
+            const tokenWithBalance = tokenInfo.get(tokenAddress);
+            return new bignumber_js_1.default(tokenWithBalance || NaN);
+        });
+    }
+    multicallContractsMethods() {
+        throw new Error('Method not implemented.');
+    }
+    getBlockNumber() {
+        return this.public.getBlockHeight('finalized');
+    }
+    createConection(rpcList) {
+        if (!rpcList?.[0]) {
+            this.logger?.customError('RPC list is empty');
+            return null;
+        }
+        else {
+            return new web3_js_1.Connection(rpcList[0], 'confirmed');
+        }
+    }
+    async simulateTransaction(_config, _from) { }
+    async checkEnoughBalance(token, walletAddress) {
+        const balance = await this.getBalance(walletAddress, token.address);
+        return balance.gte(token.tokenAmount);
+    }
+    async getBalance(userAddress, tokenAddress) {
+        const isToken = tokenAddress && !web3_pure_1.Web3Pure.isNativeAddress(core_1.CHAIN_TYPE.SOLANA, tokenAddress);
+        if (isToken) {
+            const balance = await this.getTokensBalances(userAddress, [tokenAddress]);
+            return balance?.[0] || new bignumber_js_1.default(0);
+        }
+        const balance = await this.public.getBalanceAndContext(new web3_js_1.PublicKey(userAddress), 'confirmed');
+        return new bignumber_js_1.default(balance.value.toString());
+    }
+    async callForTokensInfo(tokenAddresses) {
+        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 array
+        if (!filteredTokenAddresses.length && nativeTokenIndex !== -1) {
+            return [nativeToken];
+        }
+        const mints = filteredTokenAddresses.map((address) => new web3_js_1.PublicKey(address));
+        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(),
+                blockchain: core_1.BLOCKCHAIN_NAME.SOLANA,
+                decimals: token.decimals,
+                name: token.name,
+                symbol: token.symbol
+            });
+        });
+        if (nativeTokenIndex === -1) {
+            return tokens;
+        }
+        tokens.splice(nativeTokenIndex, 0, nativeToken);
+        return tokens;
+    }
+    parseRawInstruction(rawInstruction, dataFormat) {
+        return rawInstruction.map((instruction) => {
+            return new web3_js_1.TransactionInstruction({
+                keys: instruction.keys.map((key) => ({
+                    pubkey: new web3_js_1.PublicKey(key.pubkey),
+                    isWritable: key.isWritable,
+                    isSigner: key.isSigner
+                })),
+                data: Buffer.from(instruction.data, dataFormat),
+                programId: new web3_js_1.PublicKey(instruction.programId)
+            });
+        });
+    }
+    async parseLUTAddresses(lookupTableAddresses) {
+        const accounts = await Promise.all(lookupTableAddresses.map((address) => this.public.getAddressLookupTable(new web3_js_1.PublicKey(address)).then((v) => v.value)));
+        return accounts.filter((v) => !!v);
+    }
+    async createVersionedTransaction(instructions, walletAddress, addressLookupTableAccounts = []) {
+        const blockhash = await this.getLatestBlockhash();
+        const message = new web3_js_1.TransactionMessage({
+            instructions,
+            payerKey: new web3_js_1.PublicKey(walletAddress),
+            recentBlockhash: blockhash
+        }).compileToV0Message(addressLookupTableAccounts);
+        return new web3_js_1.VersionedTransaction(message);
+    }
+    getAtaAddress(walletAddress, tokenAddress) {
+        return (0, spl_token_1.getAssociatedTokenAddress)(new web3_js_1.PublicKey(tokenAddress), new web3_js_1.PublicKey(walletAddress));
+    }
+    getKeypairFromSecret(pk) {
+        if (!pk) {
+            return null;
+        }
+        const array = pk.split(',').map((s) => parseInt(s, 10));
+        const secretKey = Uint8Array.from(array);
+        return web3_js_1.Keypair.fromSecretKey(secretKey);
+    }
+    async getTxWithPayer(tx, feePayer) {
+        const altAccounts = [];
+        for (const lookup of tx.message.addressTableLookups) {
+            const { value } = await this.public.getAddressLookupTable(lookup.accountKey);
+            if (value) {
+                altAccounts.push(value);
+            }
+            else {
+                throw new Error(`ALT not found: ${lookup.accountKey.toBase58()}`);
+            }
+        }
+        const decompiled = web3_js_1.TransactionMessage.decompile(tx.message, {
+            addressLookupTableAccounts: altAccounts
+        });
+        const { blockhash } = await this.public.getLatestBlockhash();
+        const newMsg = new web3_js_1.TransactionMessage({
+            instructions: decompiled.instructions,
+            payerKey: new web3_js_1.PublicKey(feePayer),
+            recentBlockhash: blockhash
+        }).compileToV0Message(altAccounts);
+        return new web3_js_1.VersionedTransaction(newMsg);
+    }
+    deserializeTransaction(data) {
+        const decodedData = data.startsWith('0x') ? Buffer.from(data.slice(2), 'hex') : js_base64_1.Base64.toUint8Array(data);
+        return web3_js_1.VersionedTransaction.deserialize(decodedData);
+    }
+    serializeTransactionToBase58(tx) {
+        return bs58_1.default.encode(tx.serialize());
+    }
+    async createTransferData(fromToken, walletAddress, receiver, convertToVersionedTx, allowOwnerOffCurve = false) {
+        const fromAddress = new web3_js_1.PublicKey(walletAddress);
+        const toAddress = new web3_js_1.PublicKey(receiver);
+        const transaction = fromToken.isNative
+            ? this.createNativeTransfer(fromAddress, toAddress, fromToken.stringWeiAmount)
+            : await this.createTokenTransfer(fromAddress, toAddress, fromToken.address, fromToken.stringWeiAmount, allowOwnerOffCurve);
+        if (convertToVersionedTx) {
+            const blockhash = await this.getLatestBlockhash();
+            const message = new web3_js_1.TransactionMessage({
+                payerKey: fromAddress,
+                recentBlockhash: blockhash,
+                instructions: transaction.instructions
+            }).compileToV0Message();
+            return new web3_js_1.VersionedTransaction(message);
+        }
+        return transaction;
+    }
+    createNativeTransfer(fromAddress, toAddress, fromWeiAmount) {
+        return new web3_js_1.Transaction().add(web3_js_1.SystemProgram.transfer({
+            fromPubkey: fromAddress,
+            toPubkey: toAddress,
+            lamports: BigInt(fromWeiAmount)
+        }));
+    }
+    async createTokenTransfer(fromAddress, toAddress, fromTokenAddress, fromWeiAmount, allowOwnerOffCurve) {
+        const mintTokenAccount = new web3_js_1.PublicKey(fromTokenAddress);
+        const [fromATA, toATA] = await Promise.all([
+            (0, spl_token_1.getAssociatedTokenAddress)(mintTokenAccount, fromAddress),
+            (0, spl_token_1.getAssociatedTokenAddress)(mintTokenAccount, toAddress, allowOwnerOffCurve)
+        ]);
+        const transaction = new web3_js_1.Transaction();
+        const receiverAccountInfo = await this.public.getAccountInfo(toATA);
+        if (!receiverAccountInfo) {
+            transaction.add((0, spl_token_1.createAssociatedTokenAccountInstruction)(fromAddress, toATA, toAddress, mintTokenAccount));
+        }
+        transaction.add((0, spl_token_1.createTransferInstruction)(fromATA, toATA, fromAddress, BigInt(fromWeiAmount)));
+        return transaction;
+    }
+    async getLatestBlockhash() {
+        const { blockhash } = await this.public.getLatestBlockhash();
+        return blockhash;
+    }
+}
+exports.SolanaAdapter = SolanaAdapter;

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>[][]>;
+}