@cryptorubic/web3 0.6.5 → 0.7.0

package/package.json

@@ -1,22 +1,24 @@
 {
     "name": "@cryptorubic/web3",
-    "version": "0.6.5",
+    "version": "0.7.0",
     "dependencies": {
         "tslib": "^2.3.0",
         "bignumber.js": "9.1.2",
-        "@cryptorubic/core": "0.6.5",
+        "@cryptorubic/core": "0.7.0",
         "viem": "^2.19.1",
         "web3-utils": "^4.3.1",
         "@ton/ton": "^15.1.0",
         "@solana/web3.js": "1.95.3",
         "@solflare-wallet/utl-sdk": "^1.4.0",
         "@ethersproject/bignumber": "^5.7.0",
-        "@cryptorubic/tron-types": "0.6.5",
+        "@cryptorubic/tron-types": "0.7.0",
         "bitcoin-address-validation": "^2.2.3",
         "axios": "0.27.2",
         "crc-32": "^1.2.2",
         "tronweb": "^6.0.0-beta.4",
-        "@solana/spl-token": "0.2.0"
+        "@solana/spl-token": "0.2.0",
+        "@mysten/sui": "^1.24.0",
+        "@suiet/wallet-sdk": "^0.3.3"
     },
     "type": "commonjs",
     "main": "./src/index.js",

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

@@ -0,0 +1,17 @@
+import { Abi, MulticallResponse, MulticallParameters } from 'viem';
+import { AbstractAdapter } from './abstract-adapter';
+import { ICustomLogger, PriceTokenAmount, SuiBlockchainName, Token, TokenAmount } from '@cryptorubic/core';
+import { EvmTransactionConfig } from '../../utils/models/evm-transaction-config';
+import { SuiClient } from '@mysten/sui/client';
+import BigNumber from 'bignumber.js';
+export declare class SuiAdapter extends AbstractAdapter<SuiClient, SuiClient, SuiBlockchainName> {
+    constructor(rpcList: string[], logger?: ICustomLogger);
+    read<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
+    write<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[]): Promise<T>;
+    multicallByContract<T>(_contracts: MulticallParameters, _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
+    multicallByAddress<T>(_address: string, _abi: Abi, _method: string, _methodArgs?: unknown[][], _allowErrors?: boolean): Promise<MulticallResponse<T>[]>;
+    simulateTransaction(_config: EvmTransactionConfig, _from: string): Promise<void>;
+    callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<SuiBlockchainName>[]>;
+    checkEnoughBalance(token: TokenAmount | PriceTokenAmount, walletAddress: string): Promise<boolean>;
+    getBalance(userAddress: string, tokenAddress: string): Promise<BigNumber>;
+}

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuiAdapter = void 0;
+const abstract_adapter_1 = require("./abstract-adapter");
+const core_1 = require("@cryptorubic/core");
+const web3_pure_1 = require("../../utils/web3-pure");
+const client_1 = require("@mysten/sui/client");
+const bignumber_js_1 = require("bignumber.js");
+class SuiAdapter extends abstract_adapter_1.AbstractAdapter {
+    constructor(rpcList, logger) {
+        super(core_1.BLOCKCHAIN_NAME.SUI, logger);
+        this.public = new client_1.SuiClient({ url: rpcList[0] });
+    }
+    async read(_address, _abi, _method, _methodArgs = []) {
+        throw new Error('Method read is not supported');
+    }
+    async write(_address, _abi, _method, _methodArgs = []) {
+        throw new Error('Method write 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 callForTokensInfo(tokenAddresses) {
+        const nativeToken = core_1.nativeTokensList[core_1.BLOCKCHAIN_NAME.SUI];
+        const nativeTokenIndex = tokenAddresses.findIndex((address) => web3_pure_1.Web3Pure.isNativeAddress(core_1.BLOCKCHAIN_NAME.SUI, address));
+        const filteredTokenAddresses = tokenAddresses.filter((_, index) => index !== nativeTokenIndex);
+        // only native token in array
+        if (!filteredTokenAddresses.length && nativeTokenIndex !== -1) {
+            return [nativeToken];
+        }
+        const allTokensMeta = await Promise.all(filteredTokenAddresses.map((coinType) => this.public.getCoinMetadata({ coinType })));
+        const tokens = allTokensMeta.map((metadata, metaIndex) => {
+            if (metadata) {
+                if (!metadata) {
+                    return null;
+                }
+                const token = new core_1.Token({
+                    decimals: metadata.decimals,
+                    symbol: metadata.symbol,
+                    name: metadata.name,
+                    blockchain: core_1.BLOCKCHAIN_NAME.SUI,
+                    address: filteredTokenAddresses[metaIndex]
+                });
+                return token;
+            }
+            return null;
+        });
+        if (nativeTokenIndex === -1) {
+            return tokens;
+        }
+        tokens.splice(nativeTokenIndex, 0, nativeToken);
+        return tokens;
+    }
+    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.BLOCKCHAIN_NAME.SUI, tokenAddress);
+        if (isToken) {
+            const balance = await this.public.getBalance({
+                owner: userAddress,
+                coinType: tokenAddress
+            });
+            return new bignumber_js_1.default(balance.totalBalance);
+        }
+        const balance = await this.public.getBalance({ owner: userAddress });
+        return new bignumber_js_1.default(balance.totalBalance);
+    }
+}
+exports.SuiAdapter = SuiAdapter;

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

@@ -2,11 +2,12 @@ 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, TonBlockchainName, BitcoinBlockchainName } from '@cryptorubic/core';
+import { BlockchainName, EvmBlockchainName, SolanaBlockchainName, TronBlockchainName, ICustomLogger, HttpClient, TonBlockchainName, BitcoinBlockchainName, SuiBlockchainName } from '@cryptorubic/core';
 import { TonAdapter } from './adapters/ton-adapter';
 import { TonAdapterConfig } from './adapters/models/ton-adapter-config';
 import { EvmAdapter } from './adapters/evm-adapter';
 import { BitcoinAdapter } from './adapters/bitcoin-adapter';
+import { SuiAdapter } from './adapters/sui-adapter';
 export declare class BlockchainAdapterFactoryService {
     private readonly rpcList;
     private readonly createLogger?;
@@ -21,6 +22,7 @@ export declare class BlockchainAdapterFactoryService {
     getAdapter(blockchain: TronBlockchainName): TronAdapter;
     getAdapter(blockchain: TonBlockchainName): TonAdapter;
     getAdapter(blockchain: BitcoinBlockchainName): BitcoinAdapter;
+    getAdapter(blockchain: SuiBlockchainName): SuiAdapter;
     private createStorage;
     private createAdapter;
     connectWallet(walletProvider: WalletProvider): void;

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

@@ -9,6 +9,7 @@ const core_1 = require("@cryptorubic/core");
 const ton_adapter_1 = require("./adapters/ton-adapter");
 const evm_adapter_1 = require("./adapters/evm-adapter");
 const bitcoin_adapter_1 = require("./adapters/bitcoin-adapter");
+const sui_adapter_1 = require("./adapters/sui-adapter");
 class BlockchainAdapterFactoryService {
     constructor(rpcList, createLogger, httpClient, tonParams) {
         this.rpcList = rpcList;
@@ -75,6 +76,9 @@ class BlockchainAdapterFactoryService {
             if (blockchainType === core_1.CHAIN_TYPE.TRON) {
                 return new tron_adapter_1.TronAdapter(rpcs, this.createLogger?.(`TRON_ADAPTER`));
             }
+            if (blockchainType === core_1.CHAIN_TYPE.SUI) {
+                return new sui_adapter_1.SuiAdapter(rpcs, this.createLogger?.(`SUI_ADAPTER`));
+            }
             if (blockchainType === core_1.CHAIN_TYPE.SOLANA) {
                 return new solana_adapter_1.SolanaAdapter(rpcs, this.createLogger?.(`SOLANA_ADAPTER`));
             }
@@ -109,6 +113,11 @@ class BlockchainAdapterFactoryService {
             store.wallet = walletProvider[core_1.CHAIN_TYPE.TRON].core;
             store.walletAddress = walletProvider[core_1.CHAIN_TYPE.TRON].address;
         }
+        if (walletProvider?.[core_1.CHAIN_TYPE.SUI]?.core && this.adapterStore?.[core_1.BLOCKCHAIN_NAME.SUI]) {
+            const store = this.adapterStore[core_1.BLOCKCHAIN_NAME.SUI];
+            store.wallet = walletProvider[core_1.CHAIN_TYPE.SUI].core;
+            store.walletAddress = walletProvider[core_1.CHAIN_TYPE.SUI].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;

package/src/lib/adapter/constants/models/wallet-provider.d.ts

@@ -2,6 +2,7 @@ import { CHAIN_TYPE } from '@cryptorubic/core';
 import { SolanaWeb3 } from './solana-web3';
 import { TronWeb } from 'tronweb';
 import { BtcWallet } from '../../adapters/models/btc-wallet-provider';
+import { WalletAdapter } from '@suiet/wallet-sdk';
 export interface WalletProviderCore<T = any> {
     /**
      * Core provider.
@@ -19,6 +20,7 @@ export type TronWalletProviderCore = WalletProviderCore<typeof TronWeb>;
 export type SolanaWalletProviderCore = WalletProviderCore<SolanaWeb3>;
 export type TonWaleltProviderCore = WalletProviderCore<unknown>;
 export type BitcoinWalletProviderCore = WalletProviderCore<BtcWallet>;
+export type SuiWalletProviderCore = WalletProviderCore<WalletAdapter>;
 /**
  * Stores wallet core and information about current user, used to make `send` transactions.
  */
@@ -28,6 +30,7 @@ interface IWalletProvider {
     readonly [CHAIN_TYPE.SOLANA]?: SolanaWalletProviderCore;
     readonly [CHAIN_TYPE.TON]?: TonWaleltProviderCore;
     readonly [CHAIN_TYPE.BITCOIN]?: BitcoinWalletProviderCore;
+    readonly [CHAIN_TYPE.SUI]?: SuiWalletProviderCore;
 }
 export type WalletProvider = Partial<IWalletProvider>;
 export {};

package/src/lib/utils/constants/changenow-api-blockchain.d.ts

@@ -23,6 +23,7 @@ export declare const changeNowEvmSupportedBlockchain: {
 export type ChangenowEvmCrossChainSupportedBlockchain = keyof typeof changeNowEvmSupportedBlockchain;
 export declare const changenowApiBlockchain: {
     THETA: string;
+    SUI: string;
     FLARE: string;
     FILECOIN: string;
     EOS: string;

package/src/lib/utils/constants/changenow-api-blockchain.js

@@ -29,6 +29,7 @@ exports.changenowApiBlockchain = {
     ...exports.changeNowEvmSupportedBlockchain,
     // Non evm
     [core_1.BLOCKCHAIN_NAME.THETA]: 'theta',
+    [core_1.BLOCKCHAIN_NAME.SUI]: 'sui',
     [core_1.BLOCKCHAIN_NAME.FLARE]: 'flr',
     [core_1.BLOCKCHAIN_NAME.FILECOIN]: 'fil',
     [core_1.BLOCKCHAIN_NAME.EOS]: 'eos',

package/src/lib/utils/constants/web3-pure-store.js

@@ -10,8 +10,10 @@ const icp_web3_pure_1 = require("../web3-types/icp-web3-pure");
 const solana_web3_pure_1 = require("../web3-types/solana-web3-pure");
 const common_web3_pure_1 = require("../web3-types/common-web3-pure");
 const ton_web3_pure_1 = require("../web3-types/ton-web3-pure");
+const sui_web3_pure_1 = require("../web3-types/sui-web3-pure");
 exports.web3PureStore = {
     [core_1.CHAIN_TYPE.EVM]: new evm_web3_pure_1.EvmWeb3Pure(),
+    [core_1.CHAIN_TYPE.SUI]: new sui_web3_pure_1.SuiWeb3Pure(),
     [core_1.CHAIN_TYPE.TRON]: new tron_web3_pure_1.TronWeb3Pure(),
     [core_1.CHAIN_TYPE.BITCOIN]: new bitcoin_web3_pure_1.BitcoinWeb3Pure(),
     [core_1.CHAIN_TYPE.ICP]: new icp_web3_pure_1.IcpWeb3Pure(),

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

@@ -7,7 +7,7 @@ class SolanaWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
     constructor() {
         super({
             cnApiKey: changenow_api_blockchain_1.changenowApiBlockchain.SOLANA,
-            regex: /^[1-9A-HJ-NP-Za-km-z]{32,44}$/
+            regex: /^0[xX][a-fA-F0-9]{64}$/
         });
         this.nativeTokenAddress = 'So11111111111111111111111111111111111111111';
     }

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

@@ -0,0 +1,8 @@
+import { CommonWeb3Pure } from './common-web3-pure';
+export declare class SuiWeb3Pure extends CommonWeb3Pure {
+    readonly nativeTokenAddress = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
+    readonly emptyAddress = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
+    static compareAddress(addressA: string, addressB: string): boolean;
+    isAddressCorrect(address: string): Promise<boolean>;
+    constructor();
+}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuiWeb3Pure = void 0;
+const common_web3_pure_1 = require("./common-web3-pure");
+const core_1 = require("@cryptorubic/core");
+const bignumber_js_1 = require("bignumber.js");
+class SuiWeb3Pure extends common_web3_pure_1.CommonWeb3Pure {
+    static compareAddress(addressA, addressB) {
+        const pureAddressA = addressA.split(':')[0];
+        const pureAddressB = addressB.split(':')[0];
+        return (0, core_1.compareAddresses)(new bignumber_js_1.default(pureAddressA).toFixed(), new bignumber_js_1.default(pureAddressB).toFixed());
+    }
+    async isAddressCorrect(address) {
+        if (this.regEx) {
+            return this.regEx.test(address);
+        }
+        throw new Error(`Validation function is not implemented for ${this.constructor.name}`);
+    }
+    constructor() {
+        super({
+            regex: /(^0[xX][a-fA-F0-9]{64}::[a-z0-9]*::[A-Z0-9]*$)|(^0[xX][a-fA-F0-9]{64}$)/
+        });
+        this.nativeTokenAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
+        this.emptyAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
+    }
+}
+exports.SuiWeb3Pure = SuiWeb3Pure;