@cryptorubic/web3 1.1.0-alpha-stellar.8 → 1.1.0-alpha-stellar.10

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cryptorubic/web3",
-    "version": "1.1.0-alpha-stellar.8",
+    "version": "1.1.0-alpha-stellar.10",
     "dependencies": {
         "@ethersproject/bignumber": "^5.8.0",
         "@mysten/sui": "^1.24.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/stellar-adapter.d.ts

@@ -16,21 +16,29 @@ export declare class StellarAdapter extends AbstractAdapter<StellarClient, Stell
     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;
     }>;
+    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, walletAddress: string): Promise<boolean>;
-    callContractMethod<T extends Web3PrimitiveType = string>(contractAddress: string, contractAbi: Abi, methodName: string, methodArguments?: unknown[], options?: object): Promise<T>;
+    getTokenContractId(tokenAddress: string): string;
+    private convertTokenAddressToAsset;
+    read<T>(address: string, method: string, methodArgs?: {
+        value: string;
+        type: string;
+    }[]): Promise<T>;
+    simulateTransaction(config: StellarTransactionConfig, from: string, timeout?: number): Promise<string>;
+    getTransactionStatus(srcTxHash: string): Promise<TxStatus>;
+    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>[][]>;
-    private convertTokenAddressToSAC;
-    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

@@ -8,6 +8,8 @@ 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");
 class StellarAdapter extends abstract_adapter_1.AbstractAdapter {
     constructor(rpcList, httpClient, logger, clientParams) {
         super(core_1.BLOCKCHAIN_NAME.STELLAR, logger);
@@ -20,71 +22,88 @@ class StellarAdapter extends abstract_adapter_1.AbstractAdapter {
             timeout: 5000
         });
     }
+    async getBlockNumber() {
+        const { sequence } = await this.public.getLatestLedger();
+        return sequence;
+    }
     async getTokensBalances(userAddress, tokensAddresses) {
-        const sacTokenAddresses = tokensAddresses.map(this.convertTokenAddressToSAC);
-        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'), {
-                fee: stellar_sdk_1.BASE_FEE,
-                networkPassphrase: stellar_sdk_1.Networks.PUBLIC
-            })
-                .addOperation(operation)
-                .setTimeout(30)
-                .build();
-            try {
-                const resp = await this.public.simulateTransaction(tx);
-                //@ts-ignore
-                const rawRetval = resp.results.retval;
-                const balance = (0, stellar_sdk_1.scValToBigInt)(rawRetval);
-                return new bignumber_js_1.default(balance.toString());
-            }
-            catch (err) {
-                console.log(err);
-                return new bignumber_js_1.default('0');
-            }
-        });
+        return Promise.all(tokensAddresses.map((address) => this.getBalance(userAddress, address)));
+    }
+    async getBalance(userAddress, tokenAddress) {
         try {
-            const resp = await Promise.all(balancePromises);
-            return resp;
+            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 (err) {
-            console.error(err);
-            throw err;
+        catch {
+            return new bignumber_js_1.default(0);
         }
     }
-    callForTokensInfo(tokenAddresses) {
-        throw new Error('Not Implemented ');
+    async callForTokensInfo(tokenAddresses) {
+        return Promise.all(tokenAddresses.map((token) => this.callForTokenInfo(token)));
     }
-    getBlockNumber() {
-        throw new Error('Not Implemented ');
-    }
-    getBalance(userAddress, tokenAddress) {
-        throw new Error('Not Implemented ');
+    async callForTokenInfo(tokenAddress) {
+        const metadata = ['name', 'symbol', 'decimals'];
+        const contract = new stellar_sdk_1.Contract(this.getTokenContractId(tokenAddress));
+        const builder = 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
+        })
+            .setTimeout(30)
+            .build();
+        const [name, symbol, decimals] = await Promise.all(metadata.map(async (value) => {
+            builder.operations.pop();
+            //@ts-ignore
+            builder.operations.push(contract.call(value));
+            const resp = await this.public.simulateTransaction(builder);
+            if ('error' in resp) {
+                throw new Error(resp.error);
+            }
+            const rawValue = resp.result.retval;
+            return (0, stellar_sdk_1.scValToNative)(rawValue);
+        }));
+        return new core_1.Token({
+            address: tokenAddress,
+            blockchain: core_1.BLOCKCHAIN_NAME.STELLAR,
+            decimals,
+            name,
+            symbol
+        });
     }
-    checkEnoughBalance(token, walletAddress) {
-        throw new Error('Not Implemented ');
+    async checkEnoughBalance(token, walletAddress) {
+        const userBalance = await this.getBalance(walletAddress, token.address);
+        return userBalance.gte(token.weiAmount);
     }
-    callContractMethod(contractAddress, contractAbi, methodName, methodArguments, options) {
-        throw new Error('Not Implemented ');
+    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);
     }
-    multicallContractsMethods(contractAbi, contractsData) {
-        throw new Error('Not Implemented ');
+    convertTokenAddressToAsset(tokenAddress) {
+        const [code, issuer] = tokenAddress.split('-');
+        return new stellar_sdk_1.Asset(code, issuer);
     }
-    convertTokenAddressToSAC(tokenAddress) {
-        const [code, address] = tokenAddress === '0x0000000000000000000000000000000000000000' ? [stellar_sdk_1.Asset.native().code, undefined] : tokenAddress.split('-');
-        if (tokenAddress === '0x0000000000000000000000000000000000000000' || address?.startsWith('G')) {
-            const classicAsset = new stellar_sdk_1.Asset(code, address);
-            return classicAsset.contractId(stellar_sdk_1.Networks.PUBLIC);
+    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(30)
+            .build();
+        const resp = await this.public.simulateTransaction(tx);
+        if ('error' in resp) {
+            throw new Error(resp.error);
         }
-        return address;
-    }
-    async read(address, abi, method, methodArgs = []) {
-        // const operation = Operation.invokeHostFunction({
-        // })
-        // const result = await
-        // return result as Promise<T>;
-        throw Error('Not implemented');
+        const rawValue = resp.result.retval;
+        return (0, stellar_sdk_1.scValToNative)(rawValue);
     }
     async simulateTransaction(config, from, timeout = 15000) {
         try {
@@ -111,5 +130,11 @@ class StellarAdapter extends abstract_adapter_1.AbstractAdapter {
             return tx_status_1.TX_STATUS.PENDING;
         }
     }
+    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;