@sodax/wallet-sdk-react 0.0.1-rc.2

package/src/xchains/stellar/utils.ts

@@ -0,0 +1,49 @@
+import {
+  Address,
+  Contract,
+  type Memo,
+  type MemoType,
+  type Operation,
+  TimeoutInfinite,
+  type Transaction,
+  type TransactionBuilder,
+  scValToBigInt,
+  xdr,
+} from '@stellar/stellar-sdk';
+import type CustomSorobanServer from './CustomSorobanServer';
+
+export const STELLAR_RLP_MSG_TYPE = { type: 'symbol' };
+
+// Can be used whenever you need an Address argument for a contract method
+export const accountToScVal = (account: string) => new Address(account).toScVal();
+
+export const simulateTx = async (
+  tx: Transaction<Memo<MemoType>, Operation[]>,
+  server: CustomSorobanServer,
+): Promise<any> => {
+  const response = await server.simulateTransaction(tx);
+
+  if (response !== undefined) {
+    return response;
+  }
+
+  throw new Error('cannot simulate transaction');
+};
+
+export const getTokenBalance = async (
+  address: string,
+  tokenId: string,
+  txBuilder: TransactionBuilder,
+  server: CustomSorobanServer,
+) => {
+  const params = [accountToScVal(address)];
+  const contract = new Contract(tokenId);
+  const tx = txBuilder
+    .addOperation(contract.call('balance', ...params))
+    .setTimeout(TimeoutInfinite)
+    .build();
+
+  const result = await simulateTx(tx, server);
+
+  return result.results ? scValToBigInt(xdr.ScVal.fromXDR(result.results[0].xdr, 'base64')) : 0n;
+};

package/src/xchains/sui/SuiXConnector.ts

@@ -0,0 +1,28 @@
+import type { XAccount } from '@/types';
+
+import { XConnector } from '@/core';
+import { SuiXService } from './SuiXService';
+
+export class SuiXConnector extends XConnector {
+  wallet: any;
+
+  constructor(wallet: any) {
+    // super('SUI', wallet.name, wallet.id);
+    super('SUI', wallet?.name, wallet?.name);
+    this.wallet = wallet;
+  }
+
+  getXService(): SuiXService {
+    return SuiXService.getInstance();
+  }
+
+  async connect(): Promise<XAccount | undefined> {
+    return;
+  }
+
+  async disconnect(): Promise<void> {}
+
+  public get icon() {
+    return this.wallet?.icon;
+  }
+}

package/src/xchains/sui/SuiXService.ts

@@ -0,0 +1,56 @@
+import { XService } from '@/core/XService';
+import type { XToken } from '@sodax/types';
+import { isNativeToken } from '@/utils';
+
+export class SuiXService extends XService {
+  private static instance: SuiXService;
+
+  public suiClient: any; // TODO: define suiClient type
+  public suiWallet: any; // TODO: define suiWallet type
+  public suiAccount: any; // TODO: define suiAccount type
+
+  private constructor() {
+    super('SUI');
+  }
+
+  public static getInstance(): SuiXService {
+    if (!SuiXService.instance) {
+      SuiXService.instance = new SuiXService();
+    }
+    return SuiXService.instance;
+  }
+
+  // getBalance is not used because getBalances uses getAllBalances which returns all balances
+
+  async getBalances(address: string | undefined, xTokens: XToken[]) {
+    if (!address) return {};
+
+    try {
+      const allBalances = await this.suiClient.getAllBalances({
+        owner: address,
+      });
+      const tokenMap = xTokens.reduce((map, xToken) => {
+        let coinType = isNativeToken(xToken) ? '0x2::sui::SUI' : xToken.address;
+
+        //  TODO: hard coded for getting legacy bnUSD balance
+        if (
+          coinType ===
+          '0x03917a812fe4a6d6bc779c5ab53f8a80ba741f8af04121193fc44e0f662e2ceb::balanced_dollar::BALANCED_DOLLAR'
+        ) {
+          coinType =
+            '0x3917a812fe4a6d6bc779c5ab53f8a80ba741f8af04121193fc44e0f662e2ceb::balanced_dollar::BALANCED_DOLLAR';
+        }
+
+        const balance = allBalances.find(b => b.coinType === coinType);
+
+        if (balance) map[xToken.address] = balance.totalBalance;
+        return map;
+      }, {});
+
+      return tokenMap;
+    } catch (e) {
+      console.log('error', e);
+      return {};
+    }
+  }
+}

package/src/xchains/sui/index.ts

@@ -0,0 +1,2 @@
+export { SuiXService } from './SuiXService';
+export { SuiXConnector } from './SuiXConnector';