@cryptorubic/web3 1.0.2-alpha.deposits.1 → 1.1.0-alpha-stellar.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cryptorubic/web3",
-    "version": "1.0.2-alpha.deposits.1",
+    "version": "1.1.0-alpha-stellar.1",
     "dependencies": {
         "@ethersproject/bignumber": "^5.8.0",
         "@mysten/sui": "^1.24.0",

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-send-tx-params.d.ts

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

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,16 @@
+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';
+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>;
+}

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

@@ -0,0 +1,46 @@
+"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");
+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 preparedTransaction = await this.publicClient.prepareTransaction(stellar_sdk_1.TransactionBuilder.fromXDR(params.txOptions.transaction, stellar_sdk_1.Networks.PUBLIC));
+            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));
+            if (resp.status === 'ERROR') {
+                throw new Error('Failed to execute transaction', { cause: resp.errorResult });
+            }
+            params.txOptions?.onTransactionHash?.(resp.hash);
+            return resp.hash;
+        }
+        catch (err) {
+            console.error('Send transaction error', err);
+            throw err;
+        }
+    }
+}
+exports.StellarAdapterSigner = StellarAdapterSigner;

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

@@ -0,0 +1,36 @@
+import { BlockchainName, HttpClient, ICustomLogger, 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 { StellarTransactionConfig } from '../../../utils/models/stellar-transaction-config';
+import { ClientAdaptersFactoryParams } from '../../models/create-factory-params';
+import { StellarAdapterSigner } from './signer/stellar-adapter-signer';
+import BigNumber from 'bignumber.js';
+import { Abi } from 'viem';
+import { Web3PrimitiveType } from '../../../utils/models/primitive-types';
+import { ContractMulticallResponse } from '../models/web3-public-models/contract-multicall-response';
+import { MethodData } from '../models/web3-public-models/method-data';
+export declare class StellarAdapter extends AbstractAdapter<StellarClient, StellarWallet, StellarBlockchainName> {
+    private readonly rpcList;
+    readonly signer: StellarAdapterSigner;
+    constructor(rpcList: string[], httpClient: HttpClient, logger?: ICustomLogger, clientParams?: ClientAdaptersFactoryParams);
+    initWeb3Client(): void;
+    getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
+    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
+    getBlockNumber(): Promise<number | {
+        blockNumber: number;
+        workchain: number;
+    }>;
+    getBalance(userAddress: string, tokenAddress?: string): Promise<BigNumber>;
+    checkEnoughBalance(token: TokenAmount, walletAddress: string): Promise<boolean>;
+    callContractMethod<T extends Web3PrimitiveType = string>(contractAddress: string, contractAbi: Abi, methodName: string, methodArguments?: unknown[], options?: object): Promise<T>;
+    multicallContractsMethods<Output extends Web3PrimitiveType>(contractAbi: Abi, contractsData: {
+        contractAddress: string;
+        methodsData: MethodData[];
+    }[]): Promise<ContractMulticallResponse<Output>[][]>;
+    private convertClassicTokenAddressToSAC;
+    read<T>(address: string, abi: any, method: string, methodArgs?: unknown[]): Promise<T>;
+    simulateTransaction(config: StellarTransactionConfig, from: string, timeout?: number): Promise<string>;
+    getTransactionStatus(srcTxHash: string): Promise<TxStatus>;
+}

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

@@ -0,0 +1,92 @@
+"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");
+class StellarAdapter extends abstract_adapter_1.AbstractAdapter {
+    constructor(rpcList, httpClient, logger, clientParams) {
+        super(core_1.BLOCKCHAIN_NAME.STELLAR, logger);
+        this.rpcList = rpcList;
+        this.signer = new stellar_adapter_signer_1.StellarAdapterSigner(this.publicRef, httpClient, logger, clientParams);
+    }
+    initWeb3Client() {
+        this.public = new stellar_sdk_2.rpc.Server(this.rpcList[0], {
+            allowHttp: true,
+            timeout: 5000
+        });
+    }
+    async getTokensBalances(userAddress, tokensAddresses) {
+        const sacTokenAddresses = tokensAddresses.map((address) => address.startsWith('C') ? address : this.convertClassicTokenAddressToSAC(address));
+        const balancePromises = sacTokenAddresses.map(async (contractId) => {
+            const contract = new stellar_sdk_1.Contract(contractId);
+            const operation = contract.call('balance', (0, stellar_sdk_1.nativeToScVal)(userAddress, { type: 'address' }));
+            const tx = new stellar_sdk_1.TransactionBuilder(new stellar_sdk_1.Account(userAddress, '0')).addOperation(operation).setTimeout(30).build();
+            const resp = await this.public.simulateTransaction(tx);
+            //@ts-ignore
+            const balanceScVal = resp.results[0].retval;
+            return new bignumber_js_1.default(balanceScVal.toString());
+        });
+        return Promise.all(balancePromises);
+    }
+    callForTokensInfo(tokenAddresses) {
+        throw new Error('Not Implemented ');
+    }
+    getBlockNumber() {
+        throw new Error('Not Implemented ');
+    }
+    getBalance(userAddress, tokenAddress) {
+        throw new Error('Not Implemented ');
+    }
+    checkEnoughBalance(token, walletAddress) {
+        throw new Error('Not Implemented ');
+    }
+    callContractMethod(contractAddress, contractAbi, methodName, methodArguments, options) {
+        throw new Error('Not Implemented ');
+    }
+    multicallContractsMethods(contractAbi, contractsData) {
+        throw new Error('Not Implemented ');
+    }
+    convertClassicTokenAddressToSAC(tokenAddress) {
+        const [code, address] = tokenAddress === '0x0000000000000000000000000000000000000000' ? [stellar_sdk_1.Asset.native().code, undefined] : tokenAddress.split('-');
+        const classicAsset = new stellar_sdk_1.Asset(code, address);
+        return classicAsset.contractId(stellar_sdk_1.Networks.PUBLIC);
+    }
+    async read(address, abi, method, methodArgs = []) {
+        // const operation = Operation.invokeHostFunction({
+        // })
+        // const result = await
+        // return result as Promise<T>;
+        throw Error('Not implemented');
+    }
+    async simulateTransaction(config, from, timeout = 15000) {
+        try {
+            await this.public.simulateTransaction(stellar_sdk_1.TransactionBuilder.fromXDR(config.transaction, stellar_sdk_1.Networks.PUBLIC));
+            return '0';
+        }
+        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;
+        }
+    }
+}
+exports.StellarAdapter = StellarAdapter;

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/models/create-factory-params.d.ts

@@ -1,9 +1,9 @@
-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[]>;
+export type RpcListType = Record<EvmBlockchainName, string[]> & Record<TronBlockchainName, TronWebProvider[]> & Record<SolanaBlockchainName, string[]> & Record<SuiBlockchainName, string[]> & Record<StellarBlockchainName, string[]>;
 export interface AdapterFactoryParams {
     rpcList: RpcListType;
     httpClient?: HttpClient;

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 });