@cryptorubic/web3 0.5.2-alpha-teleswap.4 → 0.5.2-id-1249.0

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@cryptorubic/web3",
-  "version": "0.5.2-alpha-teleswap.4",
+  "version": "0.5.2-id-1249.0",
   "dependencies": {
     "tslib": "^2.3.0",
     "bignumber.js": "9.1.2",
-    "@cryptorubic/core": "0.5.2-alpha-teleswap.4",
+    "@cryptorubic/core": "0.5.2-id-1249.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.5.2-alpha-teleswap.4",
+    "@cryptorubic/tron-types": "0.5.2-id-1249.0",
     "bitcoin-address-validation": "^2.2.3",
     "axios": "0.27.2",
     "crc-32": "^1.2.2",

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

@@ -7,11 +7,8 @@ export declare class BitcoinAdapter extends AbstractAdapter<BtcWallet, BtcWallet
     private readonly httpClient;
     constructor(httpClient: HttpClient, logger?: ICustomLogger);
     getBalance(userAddress: string): Promise<BigNumber>;
-    getPublicKey(userAddress: string): Promise<string | null>;
     callForTokensInfo(tokenAddresses: string[] | ReadonlyArray<string>): Promise<Token<BlockchainName>[]>;
     read<T>(args: unknown): Promise<T>;
     write(args: unknown): Promise<string>;
-    getPublicKeyFromWallet(): Promise<string>;
     transfer(recipient: string, amount: string, fromAddress: string, memo?: string, options?: BasicTransactionOptions): Promise<string>;
-    sendPsbtTransaction(psbt: string, userAddress: string, inputIndexes: number[], options?: BasicTransactionOptions): Promise<string>;
 }

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

@@ -14,32 +14,6 @@ class BitcoinAdapter extends abstract_adapter_1.AbstractAdapter {
         const response = await this.httpClient.get(url);
         return new bignumber_js_1.default(response.final_balance);
     }
-    async getPublicKey(userAddress) {
-        try {
-            const url = `https://api.blockcypher.com/v1/btc/main/addrs/${userAddress}/full`;
-            const response = await this.httpClient.get(url);
-            const txs = response.txs;
-            let publicKey = null;
-            for (const txData of txs) {
-                const userInputData = txData.inputs.find((inputData) => {
-                    const isInputFromUserAddress = inputData.addresses.includes(userAddress);
-                    const publicKey = inputData.witness?.[1];
-                    return isInputFromUserAddress && publicKey;
-                });
-                if (userInputData) {
-                    publicKey = userInputData.witness[1];
-                    break;
-                }
-            }
-            if (!publicKey) {
-                throw new Error();
-            }
-            return publicKey;
-        }
-        catch {
-            return null;
-        }
-    }
     async callForTokensInfo(tokenAddresses) {
         return [core_1.nativeTokensList[core_1.BLOCKCHAIN_NAME.BITCOIN]];
     }
@@ -49,19 +23,6 @@ class BitcoinAdapter extends abstract_adapter_1.AbstractAdapter {
     write(args) {
         throw new Error('Not implemented');
     }
-    async getPublicKeyFromWallet() {
-        const res = await this.wallet.request({
-            method: 'request_accounts_and_keys',
-            params: {
-                purposes: ['payment']
-            }
-        }, () => { });
-        if (res.error) {
-            console.error(res.error);
-            throw res.error;
-        }
-        return res.result[0].publicKey;
-    }
     async transfer(recipient, amount, fromAddress, memo, options) {
         const hashPromise = new Promise((resolve, reject) => {
             this.wallet.request({
@@ -83,9 +44,8 @@ class BitcoinAdapter extends abstract_adapter_1.AbstractAdapter {
                     reject(error);
                 }
                 else {
-                    const hash = txHash;
-                    options?.onTransactionHash?.(hash);
-                    resolve(hash);
+                    options?.onTransactionHash?.(txHash);
+                    resolve(txHash);
                 }
             });
         });
@@ -101,39 +61,5 @@ class BitcoinAdapter extends abstract_adapter_1.AbstractAdapter {
             throw new Error('Failed to transfer funds');
         }
     }
-    async sendPsbtTransaction(psbt, userAddress, inputIndexes, options) {
-        const hashPromise = new Promise((resolve, reject) => {
-            this.wallet.request({
-                method: 'sign_psbt',
-                params: {
-                    psbt,
-                    signInputs: {
-                        [userAddress]: inputIndexes
-                    },
-                    allowedSignHash: 1,
-                    broadcast: true
-                }
-            }, (error, txHash) => {
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    const txData = txHash;
-                    options?.onTransactionHash?.(txData.result.txId);
-                    resolve(txData.result.txId);
-                }
-            });
-        });
-        try {
-            const hash = await hashPromise;
-            if (typeof hash === 'string') {
-                return hash;
-            }
-            throw new Error();
-        }
-        catch {
-            throw new Error('Failed to sign psbt transaction');
-        }
-    }
 }
 exports.BitcoinAdapter = BitcoinAdapter;

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

@@ -2,8 +2,8 @@ export interface BtcWallet {
     on: (event: string, callback: (...args: unknown[]) => void) => unknown;
     request<T>(args: {
         method: string;
-        params: unknown[] | {};
-    }, fn: (error: Error, txHash: string | {}) => unknown): Promise<{
+        params: unknown[];
+    }, fn: (error: Error, txHash: string) => unknown): Promise<{
         error: null | Error;
         result: T;
     }>;

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

@@ -0,0 +1,15 @@
+import { Abi, MulticallResponse, MulticallParameters } from 'viem';
+import { AbstractAdapter } from './abstract-adapter';
+import { Connection } from '@solana/web3.js';
+import { ICustomLogger, SuiBlockchainName, Token } from '@cryptorubic/core';
+import { EvmTransactionConfig } from '../../utils/models/evm-transaction-config';
+import { SuiClient } from '@mysten/sui/client';
+export declare class SuiAdapter extends AbstractAdapter<SuiClient, Connection, 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>[]>;
+}

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

@@ -0,0 +1,58 @@
+"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");
+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;
+    }
+}
+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;
@@ -77,6 +78,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`));
             }
@@ -116,6 +120,12 @@ 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];

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,7 @@
+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;
+    constructor();
+}

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

@@ -0,0 +1,21 @@
+"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());
+    }
+    constructor() {
+        super({
+            regex: /^0[xX][a-fA-F0-9]{64}::[a-z0-9]*::[A-Z0-9]*$/
+        });
+        this.nativeTokenAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
+        this.emptyAddress = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI';
+    }
+}
+exports.SuiWeb3Pure = SuiWeb3Pure;

package/src/lib/adapter/adapters/models/bitcoin-user-address-info.d.ts

@@ -1,53 +0,0 @@
-export interface BitcoinTxInput {
-    prev_hash: string;
-    output_index: number;
-    output_value: number;
-    sequence: number;
-    addresses: string[];
-    script_type: string;
-    age?: number;
-    witness: string[];
-}
-export interface BitcoinTxOutput {
-    value: number;
-    script: string;
-    addresses: string[];
-    script_type: string;
-    spent_by?: string;
-}
-export interface BitcoinTxInfo {
-    block_hash?: string;
-    block_height: number;
-    block_index: number;
-    hash: string;
-    addresses: string[];
-    total: number;
-    fees: number;
-    size: number;
-    vsize: number;
-    preference: string;
-    relayed_by: string;
-    confirmed?: string;
-    received: string;
-    ver: number;
-    double_spend: boolean;
-    vin_sz: number;
-    vout_sz: number;
-    confirmations?: number;
-    confidence?: number;
-    inputs: BitcoinTxInput[];
-    outputs: BitcoinTxOutput[];
-    opt_in_rbf?: boolean;
-}
-export interface BitcoinUserAddressInfo {
-    address: string;
-    total_received: number;
-    total_sent: number;
-    balance: number;
-    unconfirmed_balance: number;
-    final_balance: number;
-    n_tx: number;
-    unconfirmed_n_tx: number;
-    final_n_tx: number;
-    txs: BitcoinTxInfo[];
-}

package/src/lib/adapter/adapters/models/bitcoin-user-address-info.js

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