@cryptorubic/web3 0.15.0-alpha-stellar.0 → 0.16.3-alpha-2695.0

package/src/lib/adapter/adapters/{solana-adapter.js → adapter-solana/solana-adapter.js}

@@ -1,56 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaAdapter = exports.NATIVE_SOLANA_MINT_ADDRESS = void 0;
+exports.SolanaAdapter = 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 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");
 const bs58_1 = require("bs58");
 const js_base64_1 = require("js-base64");
-exports.NATIVE_SOLANA_MINT_ADDRESS = 'So11111111111111111111111111111111111111111';
+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) {
+    constructor(rpcList, httpClient, logger, clientParams) {
         super(core_1.BLOCKCHAIN_NAME.SOLANA, logger);
+        this.rpcList = rpcList;
         this.httpClient = httpClient;
-        this.public = this.createPublicClient(rpcList);
+        this.signer = new solana_adapter_signer_1.SolanaAdapterSigner(this.publicRef, httpClient, logger, clientParams);
     }
-    createPublicClient(rpcList) {
-        if (!rpcList?.[0]) {
-            this.logger?.customError('RPC list is empty');
-            return null;
-        }
-        else {
-            return new web3_js_1.Connection(rpcList[0], 'confirmed');
-        }
+    initWeb3Client() {
+        this.public = this.createConection(this.rpcList);
     }
-    async read(_address, _abi, _method, _methodArgs = []) {
-        throw new Error('Method multicall is not supported');
+    async callContractMethod() {
+        throw new Error('Method call is not supported');
     }
-    async write(_address, _abi, _method, _methodArgs = []) {
-        throw new Error('Method multicall is not supported');
+    async read() {
+        throw new Error('Method read is not supported');
     }
-    async multicallByContract(_contracts, _allowErrors = true) {
-        throw new Error('Method multicall is not supported');
-    }
-    async multicallByAddress(_address, _abi, _method, _methodArgs = [], _allowErrors = true) {
-        throw new Error('Method multicall is not supported');
-    }
-    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);
+    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;
         }
-        const balance = await this.public.getBalanceAndContext(new web3_js_1.PublicKey(userAddress), 'confirmed');
-        return new bignumber_js_1.default(balance.value.toString());
     }
     /**
      * Gets balance of multiple tokens.
@@ -65,13 +58,42 @@ class SolanaAdapter extends abstract_adapter_1.AbstractAdapter {
         }));
         const nativeSolBalance = await this.public.getBalanceAndContext(new web3_js_1.PublicKey(address), 'confirmed');
         return tokensAddresses.map((tokenAddress) => {
-            if (tokenAddress === exports.NATIVE_SOLANA_MINT_ADDRESS) {
+            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));

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