@coin-voyage/crypto 0.0.1 → 0.0.2

package/src/hooks/use-universal-connect.ts

@@ -1,141 +0,0 @@
-import { useConfig as useBigmiConfig } from "@bigmi/react"
-import { ChainType } from "@coin-voyage/shared/common"
-import { useConnectWallet } from "@mysten/dapp-kit"
-import { useWallet } from "@solana/wallet-adapter-react"
-import type { Connector } from "wagmi"
-import {
-  useConfig as useWagmiConfig,
-  useConnect as useWagmiConnect,
-} from "wagmi"
-import type {
-  CreateConnectorFnExtended,
-  WalletAdapterExtended,
-} from "../lib/connectors/types"
-import { ChainTypeWalletConnector } from "../types/wallet"
-import type { SuiConnector, WalletConnector } from "../types/wallet-connector"
-
-interface UseUniversalConnectProps {
-  onError?: (err: any) => void
-  onSuccess?: (
-    data: any,
-    variables?: {
-      chainId?: number | undefined
-      connector: WalletConnector
-    }
-  ) => void
-  onSettled?: (data: any, error?: any) => void
-  onMutate?: (variables?: {
-    chainId?: number
-    connector: any
-  }) => void,
-}
-
-export const useUniversalConnect = (props?: UseUniversalConnectProps) => {
-  const utxoConfig = useBigmiConfig()
-  const evmConfig = useWagmiConfig()
-  const { select, disconnect, connected } = useWallet()
-  const { mutateAsync: suiConnectAsync } = useConnectWallet()
-
-
-  const { connectAsync } = useWagmiConnect({
-    config: evmConfig,
-    mutation: {
-      ...props,
-      onSuccess(data, variables) {
-        const connector =
-          (variables.connector as CreateConnectorFnExtended) ||
-          (variables.connector as Connector)
-        props?.onSuccess?.(data, {
-          chainId: variables?.chainId,
-          connector,
-        })
-      },
-      onError(err) {
-        if (err.message) {
-          if (err.message !== "User rejected request") {
-            console.log(err.message, err)
-          }
-        } else {
-          console.log("Could not connect.", err)
-        }
-        props?.onError?.(err)
-      },
-    },
-  })
-
-  const { connectAsync: utxoConnectAsync } = useWagmiConnect({
-    config: utxoConfig,
-    mutation: {
-      ...props,
-      onSuccess(data, variables) {
-        props?.onSuccess?.(data, {
-          chainId: variables?.chainId,
-          connector: variables.connector as CreateConnectorFnExtended,
-        })
-      },
-      onError(err) {
-        if (err.message) {
-          if (err.message !== "User rejected request") {
-            console.log(err.message, err)
-          }
-        } else {
-          console.log("Could not connect.", err)
-        }
-        props?.onError?.(err)
-      },
-    },
-  })
-
-  const connect = async ({
-    walletConnector
-  }: {
-    walletConnector: ChainTypeWalletConnector
-  }) => {
-    const { connector, chainType } = walletConnector
-    switch (chainType) {
-      case ChainType.EVM:
-        await connectAsync({
-          connector: connector as Connector,
-        })
-        break
-      case ChainType.UTXO:
-        await utxoConnectAsync({
-          connector: connector as Connector,
-        })
-        break
-      case ChainType.SOL:
-        try {
-          props?.onMutate?.({ connector })
-          if (connected) {
-            await disconnect()
-          }
-          const walletAdapter = connector as WalletAdapterExtended
-          select(walletAdapter.name)
-          props?.onSuccess?.(undefined, { connector: walletAdapter })
-        } catch (error: any) {
-          props?.onError?.(error)
-        }
-        break
-      case ChainType.SUI:
-        await suiConnectAsync(
-          {
-            wallet: connector as SuiConnector,
-          },
-          {
-            onError: props?.onError,
-            onSuccess: (data) => {
-              props?.onSuccess?.(data, { connector })
-            },
-            onSettled: (data, error) => {
-              props?.onSettled?.(data, error)
-            },
-          }
-        )
-        break
-      default:
-        break
-    }
-  }
-
-  return { connect }
-}

package/src/lib/connectors/coinbase.ts

@@ -1,9 +0,0 @@
-import { type CoinbaseWalletParameters, coinbaseWallet } from "wagmi/connectors"
-import { extendConnector } from "./utils"
-
-export const createCoinbaseConnector = (params: CoinbaseWalletParameters) =>
-  extendConnector(
-    coinbaseWallet(params),
-    "coinbaseWalletSDK",
-    "Coinbase Wallet"
-  )

package/src/lib/connectors/metaMask.ts

@@ -1,6 +0,0 @@
-import type { MetaMaskParameters } from "wagmi/connectors"
-import { metaMask } from "wagmi/connectors"
-import { extendConnector } from "./utils"
-
-export const createMetaMaskConnector = (params: MetaMaskParameters) =>
-  extendConnector(metaMask(params), "metaMaskSDK", "MetaMask")

package/src/lib/connectors/utils.ts

@@ -1,23 +0,0 @@
-import type { WalletAdapter } from "@solana/wallet-adapter-base"
-import type { CreateConnectorFn } from "wagmi"
-import type { CreateConnectorFnExtended, WalletAdapterExtended } from "./types"
-
-export const extendConnector = (
-  connector: CreateConnectorFn,
-  id: string,
-  name: string
-): CreateConnectorFnExtended => {
-  const extendedConnector = connector as CreateConnectorFnExtended
-  extendedConnector.id = id
-  extendedConnector.displayName = name
-  return extendedConnector
-}
-
-export const extendsWalletAdapter = (
-  adapter: WalletAdapter,
-  id: string
-): WalletAdapterExtended => {
-  const extended = adapter as WalletAdapterExtended
-  extended.id = id
-  return extended
-}

package/src/lib/connectors/walletConnect.ts

@@ -1,18 +0,0 @@
-import type { WalletConnectParameters } from "wagmi/connectors"
-import { walletConnect } from "wagmi/connectors"
-import { extendConnector } from "./utils"
-
-export const createWalletConnectConnector = (params: WalletConnectParameters) =>
-  extendConnector(
-    walletConnect({
-      showQrModal: false,
-      qrModalOptions: {
-        themeVariables: {
-          "--wcm-z-index": "3000",
-        },
-      },
-      ...params,
-    }),
-    "walletConnect",
-    "WalletConnect"
-  )

package/src/lib/utils/connector.ts

@@ -1,22 +0,0 @@
-import type { ChainType } from "@coin-voyage/shared/common"
-import type { ChainTypeWalletConnector } from "../../types/wallet"
-import type { WalletConnector } from "../../types/wallet-connector"
-
-export const getConnectorId = (connector: WalletConnector) => {
-  if ("id" in connector) {
-    return connector.id ?? connector.name
-  }
-  return connector.name
-}
-
-export const getConnector = (
-  walletConnector: ChainTypeWalletConnector[],
-  chainType?: ChainType
-) => {
-  let connector = walletConnector[0]
-  if (chainType) {
-    connector =
-      walletConnector.find((c) => c.chainType === chainType) ?? connector
-  }
-  return connector.connector
-}

package/src/lib/utils/get-connector-icon.ts

@@ -1,13 +0,0 @@
-import type { Connector } from "wagmi"
-import { getWalletIcon } from "../../assets/icons"
-import { WalletConnector } from "../../types/wallet-connector"
-
-export const getConnectorIcon = (
-  connector?: WalletConnector
-) => {
-  const connectorId = (connector as Connector)?.id
-
-  return connectorId
-    ? getWalletIcon(connectorId) || connector?.icon
-    : connector?.icon
-}

package/src/lib/utils/get-wallet-priority.ts

@@ -1,15 +0,0 @@
-const walletPriority: Record<string, number> = {
-  metaMaskSDK: 1,
-  "io.metamask": 1,
-  "io.metamask.mobile": 1,
-  "app.phantom": 1,
-  "Sui Wallet": 1,
-  coinbaseWalletSDK: 2,
-  "com.coinbase.wallet": 2,
-  walletConnect: 3,
-  safe: 4,
-}
-
-export const getWalletPriority = (id: string) => {
-  return walletPriority?.[id] || 1000
-}

package/src/lib/utils/is-wallet-installed.ts

@@ -1,40 +0,0 @@
-export const isWalletInstalled = (id: string): boolean => {
-  const anyWindow = typeof window !== "undefined" ? (window as any) : undefined
-  switch (id) {
-    case "metaMask":
-      return (
-        anyWindow?.ethereum?.isMetaMask ||
-        anyWindow?.ethereum?.providers?.some(
-          (provider: any) => provider.isMetaMask
-        )
-      )
-    case "coinbase":
-      return (
-        // Coinbase Browser doesn't inject itself automatically
-        // We should not consider Coinbase Browser as installed wallet so we can fallback to Coinbase SDK
-        (anyWindow?.ethereum?.isCoinbaseWallet &&
-          !anyWindow?.ethereum?.isCoinbaseBrowser) ||
-        anyWindow?.coinbaseWalletExtension?.isCoinbaseWallet ||
-        anyWindow?.ethereum?.providers?.some(
-          (provider: any) => provider.isCoinbaseWallet
-        )
-      )
-    case "app.phantom":
-      return anyWindow?.phantom?.isPhantom
-    case "app.phantom.bitcoin":
-      return anyWindow?.phantom?.bitcoin?.isPhantom
-    case "com.okex.wallet.bitcoin":
-      return anyWindow?.okxwallet?.bitcoin?.isOkxWallet
-    case "XverseProviders.BitcoinProvider":
-      return anyWindow?.XverseProviders?.BitcoinProvider
-    case "unisat":
-      return anyWindow?.unisat
-    case "io.xdefi.bitcoin":
-      return anyWindow?.xfi?.bitcoin
-    default:
-      /**
-       * Return true if the wallet is not in the list of explicitly supported or self-injected wallet
-       */
-      return true
-  }
-}

package/src/lib/utils/message.ts

@@ -1,29 +0,0 @@
-import { SignInMessage } from "../../types";
-
-export const toMessage = (message: SignInMessage, accountName: string): string => {
-  const header = `${message.domain} wants you to sign in with your ${accountName} account:\n`;
-  const uriField = `URI: ${message.uri}`;
-  let prefix = [header, message.address].join("\n");
-  const versionField = `Version: ${message.version}`;
-
-  const nonceField = `Nonce: ${message.nonce}`;
-
-  const suffixArray = [uriField, versionField, nonceField];
-
-  message.issuedAt = message.issuedAt || new Date().toISOString();
-
-  suffixArray.push(`Issued At: ${message.issuedAt}`);
-
-  if (message.expirationTime) {
-    const expiryField = `Expiration Time: ${message.expirationTime}`;
-
-    suffixArray.push(expiryField);
-  }
-
-  const suffix = suffixArray.join("\n");
-  prefix = [prefix, message.statement].join("\n\n");
-  if (message.statement) {
-    prefix += "\n";
-  }
-  return [prefix, suffix].join("\n");
-};

package/src/solana/base-provider.tsx

@@ -1,29 +0,0 @@
-import type { Adapter } from "@solana/wallet-adapter-base"
-import { WalletAdapterNetwork } from "@solana/wallet-adapter-base"
-import {
-  ConnectionProvider,
-  WalletProvider,
-} from "@solana/wallet-adapter-react"
-import { clusterApiUrl } from "@solana/web3.js"
-import type { PropsWithChildren } from "react"
-import { WalletConfiguration } from "../types"
-
-const endpoint = clusterApiUrl(WalletAdapterNetwork.Mainnet)
-
-const wallets: Adapter[] = []
-
-export function SolanaBaseProvider({ children, config }: PropsWithChildren<{
-  config?: WalletConfiguration["solana"]
-}>) {
-  return (
-    <ConnectionProvider endpoint={config?.rpcUrl ?? endpoint}>
-      <WalletProvider
-        {...config?.walletConfiguration}
-        autoConnect={config?.walletConfiguration?.autoConnect || true}
-        wallets={config?.walletConfiguration?.wallets || wallets}
-      >
-        {children}
-      </WalletProvider>
-    </ConnectionProvider>
-  )
-}

package/src/solana/external-context.ts

@@ -1,3 +0,0 @@
-import { createContext } from "react"
-
-export const SolanaExternalContext = createContext<boolean>(false)

package/src/solana/get-or-create-ata.ts

@@ -1,85 +0,0 @@
-import {
-  Account,
-  ASSOCIATED_TOKEN_PROGRAM_ID,
-  createAssociatedTokenAccountInstruction,
-  getAccount,
-  getAssociatedTokenAddressSync,
-  TOKEN_PROGRAM_ID,
-  TokenAccountNotFoundError,
-  TokenInvalidAccountOwnerError,
-  TokenInvalidMintError,
-  TokenInvalidOwnerError
-} from "@solana/spl-token";
-import type { Commitment, Connection, PublicKey } from "@solana/web3.js";
-import { TransactionInstruction } from "@solana/web3.js";
-
-/**
- * Retrieve the associated token account, or create it if it doesn't exist
- *
- * @param connection               Connection to use
- * @param payer                    Payer of the transaction and initialization fees
- * @param mint                     Mint associated with the account to set or verify
- * @param owner                    Owner of the account to set or verify
- * @param allowOwnerOffCurve       Allow the owner account to be a PDA (Program Derived Address)
- * @param commitment               Desired level of commitment for querying the state
- * @param confirmOptions           Options for confirming the transaction
- * @param programId                SPL Token program account
- * @param associatedTokenProgramId SPL Associated Token program account
- *
- * @return Address of the new associated token account
- */
-export async function getOrCreateAssociatedTokenAccount(
-  connection: Connection,
-  payerPubkey: PublicKey,
-  mint: PublicKey,
-  owner: PublicKey,
-  allowOwnerOffCurve = false,
-  commitment?: Commitment,
-  programId = TOKEN_PROGRAM_ID,
-  associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
-): Promise<Account | TransactionInstruction> {
-  const associatedToken = getAssociatedTokenAddressSync(
-    mint,
-    owner,
-    allowOwnerOffCurve,
-    programId,
-    associatedTokenProgramId
-  );
-
-  // This is the optimal logic, considering TX fee, client-side computation, RPC roundtrips and guaranteed idempotent.
-  // Sadly we can't do this atomically.
-  let account: Account;
-  try {
-    account = await getAccount(connection, associatedToken, commitment, programId);
-  } catch (error: unknown) {
-    // TokenAccountNotFoundError can be possible if the associated address has already received some lamports,
-    // becoming a system account. Assuming program derived addressing is safe, this is the only case for the
-    // TokenInvalidAccountOwnerError in this code path.
-    if (error instanceof TokenAccountNotFoundError || error instanceof TokenInvalidAccountOwnerError) {
-      // As this isn't atomic, it's possible others can create associated accounts meanwhile.
-      try {
-        return createAssociatedTokenAccountInstruction(
-          payerPubkey,
-          associatedToken,
-          owner,
-          mint,
-          programId,
-          associatedTokenProgramId
-        );
-      } catch (error: unknown) {
-        // Ignore all errors; for now there is no API-compatible way to selectively ignore the expected
-        // instruction error if the associated account exists already.
-      }
-
-      // Now this should always succeed
-      account = await getAccount(connection, associatedToken, commitment, programId);
-    } else {
-      throw error;
-    }
-  }
-
-  if (!account.mint.equals(mint)) throw new TokenInvalidMintError();
-  if (!account.owner.equals(owner)) throw new TokenInvalidOwnerError();
-
-  return account;
-}

package/src/solana/use-solana-transaction.ts

@@ -1,83 +0,0 @@
-import type { PaymentDetails } from "@coin-voyage/shared/api";
-import {
-  createTransferCheckedInstruction,
-  getAssociatedTokenAddress,
-  getAssociatedTokenAddressSync
-} from "@solana/spl-token";
-import { useConnection, useWallet } from "@solana/wallet-adapter-react";
-import {
-  ComputeBudgetProgram,
-  PublicKey,
-  SystemProgram,
-  Transaction,
-  TransactionInstruction
-} from "@solana/web3.js";
-import { getOrCreateAssociatedTokenAccount } from "./get-or-create-ata";
-
-export function useSolanaTransaction(): {
-  execute: (paymentDetails: PaymentDetails) => Promise<string | undefined>;
-} {
-  const { connection } = useConnection();
-  const wallet = useWallet();
-
-  const execute = async (paymentDetails: PaymentDetails) => {
-    let transaction = new Transaction();
-
-    const receiverPubKey = new PublicKey(paymentDetails.deposit_address);
-    const senderPubKey = new PublicKey(paymentDetails.refund_address);
-
-    const instructions: TransactionInstruction[] = [
-      // add priority fees
-      ComputeBudgetProgram.setComputeUnitPrice({
-        microLamports: 1_000_000
-      })
-    ];
-
-    const value = paymentDetails.source_amount.raw_amount;
-
-    // Native SOL transfer
-    if (!paymentDetails.source_currency.address) {
-      instructions.push(
-        SystemProgram.transfer({
-          fromPubkey: senderPubKey,
-          toPubkey: receiverPubKey,
-          lamports: value
-        })
-      );
-    } else {
-      const mint = new PublicKey(paymentDetails.source_currency.address);
-
-      const payerAta = await getAssociatedTokenAddress(mint, senderPubKey, false);
-      const receiverAta = getAssociatedTokenAddressSync(mint, receiverPubKey, false);
-
-      const accountOrTransactionInstruction = await getOrCreateAssociatedTokenAccount(
-        connection,
-        senderPubKey,
-        mint,
-        receiverPubKey
-      );
-      if (accountOrTransactionInstruction instanceof TransactionInstruction) {
-        instructions.push(accountOrTransactionInstruction);
-      }
-
-      instructions.push(
-        createTransferCheckedInstruction(
-          payerAta, // from
-          mint,
-          receiverAta, // to
-          senderPubKey, // from's owner
-          value,
-          paymentDetails.source_currency.decimals
-        )
-      );
-    }
-
-    transaction.instructions = instructions;
-    return await wallet.sendTransaction(transaction, connection, {
-      maxRetries: 3,
-      skipPreflight: true,
-    });
-  }
-
-  return { execute }
-}

package/src/sui/base-provider.tsx

@@ -1,22 +0,0 @@
-import { SuiClientProvider, WalletProvider } from "@mysten/dapp-kit"
-import type { PropsWithChildren } from "react"
-import { WalletConfiguration } from "../types"
-
-export function SuiBaseProvider({ children, config }: PropsWithChildren<{
-  config?: WalletConfiguration["sui"]
-}>) {
-  return (
-    <SuiClientProvider
-      networks={{
-        mainnet: { url: config?.rpcUrl ?? "https://fullnode.mainnet.sui.io:443" },
-        devnet: { url: "https://fullnode.devnet.sui.io:443" },
-      }}
-      defaultNetwork={"mainnet"}
-    >
-      <WalletProvider
-        {...config?.walletConfiguration}
-        autoConnect={config?.walletConfiguration?.autoConnect || true}
-      >{children}</WalletProvider>
-    </SuiClientProvider>
-  )
-}

package/src/sui/external-context.ts

@@ -1,3 +0,0 @@
-import { createContext } from "react"
-
-export const SuiExternalContext = createContext<boolean>(false)

package/src/sui/use-sign-in-with-sui.ts

@@ -1,55 +0,0 @@
-import { ChainType } from "@coin-voyage/shared/common";
-import { useConnectWallet, useSignPersonalMessage } from "@mysten/dapp-kit";
-import { toast } from "sonner";
-import { useCombinedWallets } from "../hooks/use-combined-wallets";
-import { toMessage } from "../lib/utils/message";
-import { SignInMessage } from "../types";
-import { SignInWith } from "../types/sign-in-with";
-import { SuiConnector } from "../types/wallet-connector";
-
-export function useSignInWithSui({ signIn, callbackUrl }: SignInWith) {
-  const { mutate: connect } = useConnectWallet();
-  const { mutate: signPersonalMessage } = useSignPersonalMessage();
-  const { installedWallets } = useCombinedWallets(ChainType.SUI)
-
-  const handleSignature = async (address: string) => {
-    const msg = {
-      domain: window.location.host,
-      address,
-      statement: "Sign in with Sui to CoinVoyage.io",
-      uri: window.location.origin,
-      nonce: Math.random().toString(),
-      version: "1"
-    } as SignInMessage;
-
-    const message = toMessage(msg, "Sui");
-
-    signPersonalMessage({ message: new TextEncoder().encode(message) }, {
-      onSuccess: (result) => {
-        signIn("sui", {
-          address,
-          message,
-          domain: window.location.host,
-          signature: result.signature,
-          callbackUrl: callbackUrl ?? "/"
-        });
-      },
-      onError: (error) => {
-        toast.error("Something went wrong!", {
-          description: error.message
-        });
-      }
-    });
-  };
-
-  const onSelect = (id: string) => {
-    const selectedWallet = installedWallets.find((w) => w.id === id);
-    const connector = selectedWallet?.connectors?.[0].connector as SuiConnector | undefined;
-    if (!connector) return;
-    connect({ wallet: connector }, {
-      onSuccess: (res) => handleSignature(res.accounts[0].address)
-    })
-  };
-
-  return { onSelect, installedWallets };
-}

package/src/sui/use-sui-transaction.ts

@@ -1,56 +0,0 @@
-import type { PaymentDetails } from "@coin-voyage/shared/api";
-import { useReportTransactionEffects, useSignTransaction, useSuiClient } from "@mysten/dapp-kit";
-import { Transaction, } from "@mysten/sui/transactions";
-import { SUI_PACKAGE_IDS } from "./constants";
-
-export function useSUITransaction(): {
-  execute: (paymentDetails: PaymentDetails) => Promise<string | undefined>;
-} {
-  const client = useSuiClient()
-  const { mutateAsync: signTransaction } = useSignTransaction();
-  const { mutate: reportTransactionEffects } = useReportTransactionEffects()
-
-  const execute = async (paymentDetails: PaymentDetails) => {
-    const isNative = !paymentDetails.source_currency.address || (paymentDetails.source_currency.address.toLowerCase() === SUI_PACKAGE_IDS["sui"].toLowerCase());
-    const tx = new Transaction();
-
-    if (isNative) {
-      const balance = await client.getBalance({
-        owner: paymentDetails.refund_address,
-        coinType: SUI_PACKAGE_IDS["sui"]
-      })
-      const value = paymentDetails.source_amount.raw_amount;
-      if (BigInt(balance.totalBalance) < value) {
-        throw new Error(`[CHECKOUT] Insufficient balance: ${balance}`);
-      }
-      const [coin] = tx.splitCoins(tx.gas, [value]);
-      tx.transferObjects([coin], paymentDetails.deposit_address);
-
-      const { bytes, signature } = await signTransaction({
-        transaction: tx,
-      });
-
-      const executeResult = await client.executeTransactionBlock({
-        transactionBlock: bytes,
-        signature,
-        options: {
-          showRawEffects: true,
-        },
-      });
-
-      // Always report transaction effects to the wallet after execution
-      if (executeResult.rawEffects) {
-        reportTransactionEffects({
-          effects: executeResult.rawEffects
-        });
-      }
-
-      return executeResult.digest;
-    }
-
-    // TODO: Implement SUI Token transfer
-    return
-  }
-
-  return { execute }
-}

package/src/types/utxo-connector-id.ts

@@ -1,10 +0,0 @@
-
-export enum UTXOConnectorId {
-    PHANTOM_BTC = 'app.phantom.bitcoin',
-    XVERSE = 'XverseProviders.BitcoinProvider',
-    UNISAT = 'unisat',
-    // CTRL = 'io.xdefi.bitcoin',
-    OKEX = 'com.okex.wallet.bitcoin',
-    LEATHER = 'LeatherProvider',
-    ONEKEY = 'so.onekey.app.wallet.bitcoin',
-}