@cryptorubic/web3 0.0.16 → 0.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cryptorubic/web3",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "dependencies": {
     "tslib": "^2.3.0"
   },

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

@@ -9,6 +9,9 @@ export declare abstract class AbstractAdapter<P, W, B extends BlockchainName> {
     private _wallet;
     set wallet(value: W | null);
     get wallet(): W;
+    private _walletAddress;
+    set walletAddress(value: string | null);
+    get walletAddress(): string;
     protected constructor(blockchain: B, logger?: ICustomLogger);
     abstract callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
     needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string | BigNumber): Promise<boolean>;

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

@@ -25,9 +25,21 @@ class AbstractAdapter {
         }
         return this._wallet;
     }
+    set walletAddress(value) {
+        this._walletAddress = value;
+    }
+    get walletAddress() {
+        if (!this._walletAddress) {
+            const msg = 'Trying to access undefined walletAddress';
+            this.logger?.customLog(msg);
+            throw new Error(msg);
+        }
+        return this._walletAddress;
+    }
     constructor(blockchain, logger) {
         this._public = null;
         this._wallet = null;
+        this._walletAddress = null;
         this.blockchain = blockchain;
         if (logger) {
             this.logger = logger;

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

@@ -6,7 +6,7 @@ import { EvmAdapterOptions } from "./models/evm-adapter-options";
 import { EvmTransactionConfig } from "../../utils/models/evm-transaction-config";
 import { ApproveAdapter } from "./models/approve-adapter";
 import { AllowanceInfo } from "./models/common-types";
-export declare class EvmAdapter extends AbstractAdapter<PublicActions & PublicClient, WalletClient & WalletActions, EvmBlockchainName> implements ApproveAdapter {
+export declare class EvmAdapter extends AbstractAdapter<PublicActions & PublicClient, WalletClient & WalletActions, EvmBlockchainName> implements ApproveAdapter<EvmTransactionConfig> {
     needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
     handlePreswap(contractAddress: string, walletAddress: string, tokenAmount: TokenAmount): Promise<void>;
     constructor(adapterOptions: EvmAdapterOptions, logger?: ICustomLogger);

package/src/lib/adapter/adapters/models/approve-adapter.d.ts

@@ -1,7 +1,6 @@
 import { TokenAmount } from "@cryptorubic/core";
 import { AllowanceInfo } from "./common-types";
-import { EvmTransactionConfig } from "../../../utils/models/evm-transaction-config";
-export interface ApproveAdapter {
+export interface ApproveAdapter<T> {
     /**
      * @param fromTokenAddress erc20 address of checked token
      * @param walletAddress owner wallet address
@@ -15,7 +14,7 @@ export interface ApproveAdapter {
      * @param spenderAddress spender address
      * @param amount amount in non wei
      */
-    encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): EvmTransactionConfig;
+    encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): T;
     /**
      * Check if approve needed.
      * @param token

package/src/lib/adapter/adapters/models/basic-transaction-options.d.ts

@@ -0,0 +1,7 @@
+export interface BasicTransactionOptions {
+    /**
+     * Callback to be called, when user confirm swap transaction.
+     * @param hash Transaction hash.
+     */
+    onTransactionHash?: (hash: string) => void;
+}

package/src/lib/adapter/adapters/models/basic-transaction-options.js

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

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

@@ -9,8 +9,7 @@ import { TronParameters } from "../../utils/models/tron-parameters";
 import { Abi } from "viem";
 import { ApproveAdapter } from "./models/approve-adapter";
 import { AllowanceInfo } from "./models/common-types";
-import { EvmTransactionConfig } from "../../utils/models/evm-transaction-config";
-export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronBlockchainName> implements ApproveAdapter {
+export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronBlockchainName> implements ApproveAdapter<TronTransactionConfig> {
     private readonly multicallAddress;
     needPreswapAction(token: TokenAmount, contractAddress: string, walletAddress: string, amount: string): Promise<boolean>;
     constructor(rpcList: string[], logger?: ICustomLogger);
@@ -19,18 +18,17 @@ export declare class TronAdapter extends AbstractAdapter<TronWeb, TronWeb, TronB
         methodsData: MethodData[];
     }[]): Promise<ContractMulticallResponse<Output>[][]>;
     private multicall;
-    callContractMethod<T extends TronWeb3PrimitiveType = string>(contractAddress: string, contractAbi: readonly AbiFragment[], methodName: string, methodArguments?: unknown[]): Promise<T>;
+    read<T>(contractAddress: string, contractAbi: readonly AbiFragment[], methodName: string, methodArguments?: unknown[]): Promise<T>;
     private multicallContractsMethodsByOne;
     getTokensBalances(userAddress: string, tokensAddresses: string[]): Promise<BigNumber[]>;
     callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token[]>;
     getBalance(userAddress: string, tokenAddress?: string): Promise<BigNumber>;
     getTokenBalance(userAddress: string, tokenAddress: string): Promise<BigNumber>;
     convertTronAddressToHex(address: string): Promise<string>;
-    read<T>(): Promise<T>;
-    write(): Promise<string>;
+    write(contractAddress: string, methodSignature: string, parameters: TronParameters): Promise<string>;
     static encodeMethodCall(contractAddress: string, contractAbi: Abi, methodName: string, methodArguments: TronParameters, callValue?: string, feeLimit?: number): TronTransactionConfig;
     private static flattenTypesToString;
     needApprove(from: TokenAmount | PriceTokenAmount, walletAddress: string, spender: string): Promise<boolean>;
-    encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): EvmTransactionConfig;
+    encodeApprove(tokenAddress: string, spenderAddress: string, amount?: string): TronTransactionConfig;
     getAllowance(fromTokenAddress: string, walletAddress: string, spender: string): Promise<AllowanceInfo>;
 }

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

@@ -51,7 +51,7 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
         // @ts-ignore
         return contract.aggregateViewCalls(calls).call();
     }
-    async callContractMethod(contractAddress, contractAbi, methodName, methodArguments = []) {
+    async read(contractAddress, contractAbi, methodName, methodArguments = []) {
         this.public.setAddress(contractAddress);
         const contract = await this.public.contract(contractAbi, contractAddress);
         const response = await contract[methodName](...methodArguments).call();
@@ -61,7 +61,7 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
         return Promise.all(contractsData.map((contractData) => {
             return Promise.all(contractData.methodsData.map(async (methodData) => {
                 try {
-                    const output = (await this.callContractMethod(contractData.contractAddress, contractAbi, methodData.methodName, methodData.methodArguments));
+                    const output = (await this.read(contractData.contractAddress, contractAbi, methodData.methodName, methodData.methodArguments));
                     return {
                         output,
                         success: true
@@ -161,12 +161,11 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
     async convertTronAddressToHex(address) {
         return this.public.address.toHex(address);
     }
-    read() {
-        throw new Error('Method is not implemented');
-    }
-    ;
-    write() {
-        throw new Error('Method is not implemented');
+    async write(contractAddress, methodSignature, parameters) {
+        const transaction = await this.wallet.transactionBuilder.triggerSmartContract(contractAddress, methodSignature, {}, parameters, this.walletAddress);
+        const signedTransaction = await this.wallet.trx.sign(transaction.transaction);
+        const receipt = await this.wallet.trx.sendRawTransaction(signedTransaction);
+        return receipt.transaction.txID;
     }
     ;
     static encodeMethodCall(contractAddress, contractAbi, methodName, methodArguments, callValue, feeLimit) {
@@ -201,20 +200,18 @@ class TronAdapter extends abstract_adapter_1.AbstractAdapter {
     }
     encodeApprove(tokenAddress, spenderAddress, amount) {
         const amountWei = amount ?? new bignumber_js_1.default(2).pow(256).minus(1).toFixed();
-        const callData = tron_web3_pure_1.TronWeb3Pure.encodeFunctionCall(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'approve', [spenderAddress, amountWei]);
-        return {
-            data: callData,
-            to: tokenAddress,
-            value: '0'
-        };
+        return tron_web3_pure_1.TronWeb3Pure.encodeMethodCall(tokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'approve', [
+            { type: 'address', value: spenderAddress },
+            { type: 'uint256', value: amountWei }
+        ]);
     }
     async getAllowance(fromTokenAddress, walletAddress, spender) {
-        const [contract, decimals] = await Promise.all([
+        const [contract, decimals, allowance] = await Promise.all([
             this.public.contract(trc_20_contract_abi_1.TRC20_CONTRACT_ABI, fromTokenAddress),
-            this.callContractMethod(fromTokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'decimals')
+            this.read(fromTokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'decimals'),
+            this.read(fromTokenAddress, trc_20_contract_abi_1.TRC20_CONTRACT_ABI, 'allowance', [spender])
         ]);
-        const allowance = await this.getAllowance(fromTokenAddress, walletAddress, spender);
-        const allowanceWeiBN = new bignumber_js_1.default(allowance?.toString());
+        const allowanceWeiBN = new bignumber_js_1.default(allowance);
         const allowanceNonWei = core_1.Token.fromWei(allowanceWeiBN, Number(decimals));
         return { allowanceNonWei, allowanceWei: allowanceWeiBN };
     }

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

@@ -2,7 +2,8 @@ import { SolanaAdapter } from './adapters/solana-adapter';
 import { TronAdapter } from './adapters/tron-adapter';
 import { AbstractAdapter } from './adapters/abstract-adapter';
 import { WalletProvider } from "./constants/models/wallet-provider";
-import { BlockchainName, EvmBlockchainName, SolanaBlockchainName, TronBlockchainName, ICustomLogger, HttpClient } from "@cryptorubic/core";
+import { BlockchainName, EvmBlockchainName, SolanaBlockchainName, TronBlockchainName, ICustomLogger, HttpClient, TonBlockchainName } from "@cryptorubic/core";
+import { TonAdapter } from "./adapters/ton-adapter";
 import { TonAdapterConfig } from "./adapters/models/ton-adapter-config";
 import { EvmAdapter } from "./adapters/evm-adapter";
 export declare class BlockchainAdapterFactoryService {
@@ -17,6 +18,7 @@ export declare class BlockchainAdapterFactoryService {
     getAdapter(blockchain: SolanaBlockchainName): SolanaAdapter;
     getAdapter(blockchain: EvmBlockchainName): EvmAdapter;
     getAdapter(blockchain: TronBlockchainName): TronAdapter;
+    getAdapter(blockchain: TonBlockchainName): TonAdapter;
     private createStorage;
     private createAdapter;
     connectWallet(walletProvider: WalletProvider): void;

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

@@ -92,19 +92,23 @@ class BlockchainAdapterFactoryService {
                     chain: chain,
                     transport: (0, viem_1.custom)(provider)
                 });
+                adapter.walletAddress = walletProvider[core_1.CHAIN_TYPE.EVM].address;
             });
         }
         if (walletProvider?.[core_1.CHAIN_TYPE.SOLANA]?.core && this.adapterStore?.[core_1.BLOCKCHAIN_NAME.SOLANA]) {
             const store = this.adapterStore[core_1.BLOCKCHAIN_NAME.SOLANA];
             store.wallet = walletProvider[core_1.CHAIN_TYPE.SOLANA].core;
+            store.walletAddress = walletProvider[core_1.CHAIN_TYPE.SOLANA].address;
         }
         if (walletProvider?.[core_1.CHAIN_TYPE.TRON]?.core && this.adapterStore?.[core_1.BLOCKCHAIN_NAME.TRON]) {
             const store = this.adapterStore[core_1.BLOCKCHAIN_NAME.TRON];
             store.wallet = walletProvider[core_1.CHAIN_TYPE.TRON].core;
+            store.walletAddress = walletProvider[core_1.CHAIN_TYPE.TRON].address;
         }
         if (walletProvider?.[core_1.CHAIN_TYPE.TON]?.core && this.adapterStore?.[core_1.BLOCKCHAIN_NAME.TON]) {
             const store = this.adapterStore[core_1.BLOCKCHAIN_NAME.TON];
             store.wallet = walletProvider[core_1.CHAIN_TYPE.TON].core;
+            store.walletAddress = walletProvider[core_1.CHAIN_TYPE.TON].address;
         }
     }
 }

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

@@ -1,7 +1,9 @@
 import { CommonWeb3Pure } from "./common-web3-pure";
+import { TronTransactionConfig } from "../models/tron-transaction-config";
 import { TronParameters } from "../models/tron-parameters";
 import { TronWeb3PrimitiveType, Web3PrimitiveType } from "../models/primitive-types";
 import { FunctionFragment } from "tronweb/src/types/ABI";
+import { AbiItem } from "../models/abi-types";
 export declare class TronWeb3Pure extends CommonWeb3Pure {
     constructor();
     isAddressCorrect(address: string): Promise<boolean>;
@@ -15,6 +17,7 @@ export declare class TronWeb3Pure extends CommonWeb3Pure {
      * @returns An ABI encoded function call. Means function signature + parameters.
      */
     static encodeFunctionCall(contractAbi: FunctionFragment[], methodName: string, methodArguments: unknown[]): string;
+    static encodeMethodCall(contractAddress: string, contractAbi: AbiItem[], methodName: string, methodArguments: TronParameters, callValue?: string, feeLimit?: number): TronTransactionConfig;
     static encodeMethodSignature(methodSignature: string, parameters: TronParameters): string;
     /**
      * Decodes method result using its JSON interface object and given parameters.

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

@@ -33,6 +33,20 @@ class TronWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
         const encodedParameters = tronweb_1.utils.abi.encodeParamsV2ByABI(methodSignature, methodArguments);
         return encodedMethodSignature + encodedParameters.slice(2);
     }
+    static encodeMethodCall(contractAddress, contractAbi, methodName, methodArguments, callValue, feeLimit) {
+        const methodAbi = contractAbi.find(abiItem => abiItem.name === methodName);
+        if (!methodAbi) {
+            throw new Error('Encode fail. No method in ABI');
+        }
+        const signature = `${methodAbi.name}(${this.flattenTypesToString(methodAbi.inputs).join(',')})`;
+        return {
+            to: contractAddress,
+            arguments: methodArguments,
+            signature,
+            ...(callValue && { callValue }),
+            ...(feeLimit && { feeLimit })
+        };
+    }
     static encodeMethodSignature(methodSignature, parameters) {
         const encodedMethodSignature = tronweb_1.TronWeb.sha3(methodSignature).slice(0, 10);
         const flattenedParameters = this.flattenParameters(parameters);