@sign-global/tokentable 0.3.0 → 0.4.0-beta.2

package/src/airdrop/core/useWeb3ConnectWallet/providers/evm/EvmWallet.ts

@@ -0,0 +1,90 @@
+import { useConnectModal } from '@rainbow-me/rainbowkit';
+import { ResolvedRegister, useAccount, useWalletClient } from 'wagmi';
+import { WalletBase } from '../../WalletBase';
+import { disconnect, getAccount, signMessage } from 'wagmi/actions';
+import { EventEmitter } from 'events';
+import { ISignResult } from '../../types';
+import { get4361Message, prepareSignMessage } from '../../utils';
+
+export const eventBus = new EventEmitter();
+
+const EVM_EVENT_KEY = 'evm_signin';
+
+export interface EVMStoreType {
+  account: ReturnType<typeof useAccount> | null;
+  connectModal: ReturnType<typeof useConnectModal> | undefined;
+  walletClient: ReturnType<typeof useWalletClient> | undefined;
+  config: ResolvedRegister['config'] | undefined;
+  counter: number;
+}
+
+export const evmStore: EVMStoreType = {
+  account: null,
+  connectModal: undefined,
+  walletClient: undefined,
+  config: undefined,
+  counter: 0
+};
+
+export const getEventKey = () => {
+  return `${EVM_EVENT_KEY}_${evmStore.counter}`;
+};
+
+export class EvmWallet extends WalletBase<EVMStoreType> {
+  get isConnected() {
+    return !!(evmStore.account?.address && evmStore.account?.isConnected);
+  }
+
+  connect() {
+    evmStore?.connectModal?.openConnectModal?.();
+  }
+
+  async disconnect() {
+    await disconnect(evmStore.config!);
+  }
+
+  async sign(_message: string) {
+    const sign = await signMessage(evmStore.config!, {
+      message: _message
+    });
+    return {
+      message: _message,
+      signature: sign
+    };
+  }
+
+  override async signin(statement?: string): Promise<ISignResult> {
+    return new Promise((resolve) => {
+      const signCallback = (data: ReturnType<typeof useAccount>) => {
+        this.address = data.address;
+        this.chainId = data.chainId;
+        const msg = prepareSignMessage({ statement, chainId: data.chainId!, address: data.address! });
+        const fullMessage = get4361Message(msg);
+
+        const res = this.sign(fullMessage);
+
+        resolve(res);
+      };
+
+      const account = getAccount(evmStore.config!);
+      this.provider = evmStore.walletClient;
+
+      if (this.isConnected) {
+        signCallback(account);
+        return;
+      }
+
+      evmStore.counter++;
+      this.connect();
+      const eventKey = getEventKey();
+      eventBus.once(eventKey, (data) => {
+        console.log('listen event key success, event key = %s, data = %j', eventKey, data);
+        signCallback(data);
+      });
+    });
+  }
+
+  getStore(): EVMStoreType {
+    return evmStore;
+  }
+}

package/src/airdrop/core/useWeb3ConnectWallet/providers/evm/index.tsx

@@ -0,0 +1,43 @@
+import '@rainbow-me/rainbowkit/styles.css';
+import { RainbowKitProvider, lightTheme, useConnectModal } from '@rainbow-me/rainbowkit';
+import { ResolvedRegister, WagmiProvider, useAccount, useWalletClient } from 'wagmi';
+import { ReactNode, useEffect } from 'react';
+
+import { evmStore, getEventKey, eventBus } from './EvmWallet';
+
+export { EvmWallet } from './EvmWallet';
+
+export const EVMConnector = () => {
+  const connectModal = useConnectModal();
+  const walletClient = useWalletClient();
+  const account = useAccount();
+
+  evmStore.connectModal = connectModal;
+  evmStore.walletClient = walletClient;
+  evmStore.account = account;
+
+  useEffect(() => {
+    if (account.isConnected) {
+      const eventKey = getEventKey();
+      eventBus.emit(eventKey, account);
+    }
+  }, [account]);
+
+  return null;
+};
+
+export const EvmProvider = ({ children, config }: { children: ReactNode; config: ResolvedRegister['config'] }) => {
+  evmStore.config = config;
+  return (
+    <WagmiProvider config={config}>
+      <RainbowKitProvider
+        theme={lightTheme({
+          accentColor: '#DD8D58'
+        })}
+      >
+        {children}
+        <EVMConnector />
+      </RainbowKitProvider>
+    </WagmiProvider>
+  );
+};

package/src/airdrop/core/useWeb3ConnectWallet/providers/index.ts

@@ -0,0 +1,4 @@
+export { EvmWallet, EvmProvider } from './evm';
+export { SolWallet, SolanaProvider } from './solana';
+// export { StarknetWallet } from './starknet';
+export { TonWallet, TonProvider } from './ton';

package/src/airdrop/core/useWeb3ConnectWallet/providers/solana/index.tsx

@@ -0,0 +1,141 @@
+import { ReactNode, useCallback, useEffect, useMemo } from 'react';
+import { WalletBase } from '../../WalletBase';
+import { useWalletModal, WalletModalProvider } from '@solana/wallet-adapter-react-ui';
+import '@solana/wallet-adapter-react-ui/styles.css';
+import { ISignResult } from '../../types';
+import { ConnectionProvider, useWallet, WalletProvider } from '@solana/wallet-adapter-react';
+import { PhantomWalletAdapter } from '@solana/wallet-adapter-wallets';
+import { clusterApiUrl } from '@solana/web3.js';
+import bs58 from 'bs58';
+import { get4361Message, prepareSignMessage } from '../../utils';
+import EventEmitter from 'events';
+
+interface SolStoreType {
+  connectModal: ReturnType<typeof useWalletModal> | null;
+  account: ReturnType<typeof useWallet> | null;
+  counter: number;
+}
+
+const solStore: SolStoreType = {
+  connectModal: null,
+  account: null,
+  counter: 0
+};
+
+export const eventBus = new EventEmitter();
+
+const SOL_EVENT_KEY = 'sol_signin';
+
+export const getEventKey = () => {
+  return `${SOL_EVENT_KEY}_${solStore.counter}`;
+};
+
+export class SolWallet extends WalletBase<SolStoreType> {
+  getStore(): SolStoreType {
+    return solStore;
+  }
+  get isConnected() {
+    return !!solStore.account?.connected;
+  }
+  connect(): void {
+    solStore.connectModal?.setVisible(true);
+  }
+
+  disconnect() {
+    solStore.account?.disconnect();
+  }
+
+  async sign(message: string): Promise<ISignResult> {
+    try {
+      const provider = solStore.account!;
+      const encodedMessage = new TextEncoder().encode(message);
+      const signedMessage = await provider.signMessage?.(encodedMessage);
+
+      console.log(signedMessage, 'signedMessage');
+
+      return {
+        message,
+        signature: bs58.encode(signedMessage!)
+      };
+    } catch (error) {
+      console.error(error);
+      throw error;
+    }
+  }
+
+  signin(statement?: string): Promise<ISignResult> {
+    return new Promise((resolve) => {
+      const signCallback = (data: ReturnType<typeof useWallet>) => {
+        this.publicKey = data.publicKey?.toString();
+        this.address = this.publicKey;
+        this.chainId = 1;
+        const msg = prepareSignMessage({ statement, chainId: '1', address: this.address! });
+        const fullMessage = get4361Message(msg);
+
+        const res = this.sign(fullMessage);
+
+        resolve(res);
+      };
+
+      // const account = getAccount(evmStore.config!);
+      // this.provider = evmStore.walletClient;
+
+      if (this.isConnected) {
+        console.log(solStore);
+        signCallback(solStore.account!);
+        return;
+      }
+      solStore.counter++;
+      this.connect();
+      const eventKey = getEventKey();
+      console.log(eventKey);
+      eventBus.once(eventKey, (data) => {
+        console.log('listen event key success, event key = %s, data = %j', eventKey, data);
+        signCallback(data);
+      });
+    });
+  }
+}
+
+export const SolConnector = () => {
+  const walletModal = useWalletModal();
+  const wallet = useWallet();
+
+  useEffect(() => {
+    console.log(wallet, 'wallet');
+    if (wallet.wallet) {
+      if (wallet.connected) {
+        const eventKey = getEventKey();
+        eventBus.emit(eventKey, wallet);
+      } else {
+        wallet.connect().catch((error) => {
+          console.error(error);
+        });
+      }
+    }
+  }, [wallet]);
+
+  solStore.connectModal = walletModal;
+  solStore.account = wallet;
+  return null;
+};
+
+export const SolanaProvider = ({ children }: { children: ReactNode }) => {
+  const endpoint = clusterApiUrl('mainnet-beta');
+
+  const wallets = useMemo(() => [new PhantomWalletAdapter()], []);
+
+  const onError = useCallback((error: any) => {
+    console.error(error);
+  }, []);
+  return (
+    <ConnectionProvider endpoint={endpoint}>
+      <WalletProvider wallets={wallets} onError={onError}>
+        <WalletModalProvider>
+          <SolConnector />
+          {children}
+        </WalletModalProvider>
+      </WalletProvider>
+    </ConnectionProvider>
+  );
+};

package/src/airdrop/core/useWeb3ConnectWallet/providers/ton/TonWallet.ts

@@ -0,0 +1,149 @@
+import {
+  useTonConnectUI,
+  useTonWallet,
+  useTonConnectModal,
+  WalletInfoRemote,
+  TonConnectUIProviderProps
+} from '@tonconnect/ui-react';
+import { WalletBase } from '../../WalletBase';
+import { ISignResult } from '../../types';
+import { getCustomNaNoId } from '../../utils';
+import { hashSha256 } from '@ethsign/utils-web';
+import { CHAIN, TonConnectUI, TonProofItemReplySuccess, toUserFriendlyAddress, Wallet } from '@tonconnect/ui';
+import { EventEmitter } from 'events';
+import { Cell } from 'ton-core';
+
+export interface TonStoreType {
+  account: ReturnType<typeof useTonWallet> | null;
+  connectModal: ReturnType<typeof useTonConnectModal> | undefined;
+  walletClient: ReturnType<typeof useTonConnectUI>[0] | undefined;
+  config: TonConnectUIProviderProps | undefined;
+  counter: number;
+}
+
+export const tonStore: TonStoreType = {
+  account: null,
+  connectModal: undefined,
+  walletClient: undefined,
+  config: undefined,
+  counter: 0
+};
+
+export const eventBus = new EventEmitter();
+
+export const getEventKey = () => {
+  return `ton_sign_${tonStore.counter}`;
+};
+
+export class TonWallet extends WalletBase<TonStoreType> {
+  get isConnected() {
+    return !!tonStore.account?.account;
+  }
+
+  connect() {
+    tonStore?.connectModal?.open?.();
+  }
+
+  async disconnect() {
+    await tonStore.walletClient?.disconnect();
+  }
+
+  private getPublicKey(stateInit: string): string {
+    const state_init = Cell.fromBase64(stateInit);
+    const bits = state_init.refs[1].bits;
+    const pubKey = bits.toString().substring(16, 80).toLowerCase();
+    return pubKey;
+  }
+
+  async sign(originMsg: string): Promise<ISignResult> {
+    const message = await hashSha256(originMsg);
+    const tonConnectUI = tonStore.walletClient as TonConnectUI;
+    // const walletInfo = tonConnectUI?.wallet;
+    const authType = '';
+    // if (walletInfo?.jsBridgeKey && walletInfo?.openMethod !== 'qrcode') {
+    //     authType = walletInfo.jsBridgeKey; 
+    // }
+
+    console.log(this.isConnected, tonConnectUI, 'connected');
+    if (this.isConnected) {
+      await tonConnectUI.disconnect();
+    }
+    tonStore.counter++;
+    if (authType) {
+      const wallets = await tonConnectUI.getWallets();
+
+      const currentWallet = wallets.find((wallet) =>
+        [wallet.name, wallet.appName].includes(authType)
+      ) as WalletInfoRemote;
+
+      console.log(wallets, currentWallet, 'ww');
+
+      const link = tonConnectUI.connector.connect(
+        {
+          bridgeUrl: currentWallet.bridgeUrl,
+          universalLink: currentWallet.universalLink
+        },
+        {
+          tonProof: message
+        }
+      );
+
+      // tonspace在tg内部打开
+      window.open(link);
+    } else {
+      console.log('first time, call setConnectRequestParameters');
+      tonConnectUI.setConnectRequestParameters({
+        state: 'ready',
+        value: {
+          tonProof: message // 不能有空格，特殊字符
+        }
+      });
+      this.connect();
+    }
+
+    const connectedWallet: Wallet = await new Promise((resolve) => {
+      const eventKey = getEventKey();
+      console.log('start listen event key, key = %s', eventKey);
+      eventBus.once(eventKey, (data) => {
+        console.log('listen event key success, event key = %s, data = %j', eventKey, data);
+        resolve(data);
+      });
+    });
+
+    this.provider = tonStore.walletClient;
+    const proof = (connectedWallet.connectItems?.tonProof as TonProofItemReplySuccess)?.proof;
+    this.publicKey = connectedWallet.account.publicKey || this.getPublicKey(connectedWallet.account.walletStateInit); //使用walletStateInit，publicKey由后端计算
+    this.address = toUserFriendlyAddress(connectedWallet.account.address);
+    this.chainId = connectedWallet.account.chain;
+    this.network = this.chainId === CHAIN.MAINNET ? 'TON_MAINNET' : 'TON_TESTNET';
+    const fullMessage = JSON.stringify({
+      timestamp: proof.timestamp,
+      payload: proof.payload,
+      domain: proof.domain
+    });
+    const signature = proof.signature;
+
+    return {
+      message: JSON.stringify({
+        fullMessage,
+        message: originMsg
+      }),
+      signature,
+      tonProof: message
+    };
+  }
+
+  override async signin(statement?: string): Promise<ISignResult> {
+    const fullMessage = {
+      statement: statement || 'Welcome to EthSign',
+      issuedAt: new Date().toISOString(),
+      nonce: getCustomNaNoId()
+    };
+    const signRes = await this.sign(JSON.stringify(fullMessage, null, '  '));
+    return signRes;
+  }
+
+  getStore(): TonStoreType {
+    return tonStore;
+  }
+}

package/src/airdrop/core/useWeb3ConnectWallet/providers/ton/index.tsx

@@ -0,0 +1,41 @@
+import { ReactNode, useEffect } from 'react';
+import {
+  TonConnectUIProvider,
+  useTonConnectUI,
+  useTonWallet,
+  useTonConnectModal,
+  TonConnectUIProviderProps
+} from '@tonconnect/ui-react';
+
+import { tonStore, eventBus, getEventKey, TonWallet } from './TonWallet';
+
+export { TonWallet };
+
+export const TonConnector = () => {
+  const wallet = useTonWallet();
+  const [tonConnectUI] = useTonConnectUI();
+  const connectModal = useTonConnectModal();
+
+  tonStore.connectModal = connectModal;
+  tonStore.walletClient = tonConnectUI;
+  tonStore.account = wallet;
+
+  useEffect(() => {
+    if (wallet) {
+      eventBus.emit(getEventKey(), wallet);
+    }
+  }, [wallet]);
+
+  return null;
+};
+
+export const TonProvider = ({ children, config }: { children: ReactNode; config: TonConnectUIProviderProps }) => {
+  tonStore.config = config;
+
+  return (
+    <TonConnectUIProvider {...config}>
+      {children}
+      <TonConnector />
+    </TonConnectUIProvider>
+  );
+};

package/src/airdrop/core/useWeb3ConnectWallet/types.ts

@@ -0,0 +1,45 @@
+export enum WalletType {
+  EVM = 'evm',
+  BITCOIN = 'bitcoin',
+  SOLANA = 'solana',
+  TON = 'ton',
+  APTOS = 'aptos',
+  PARTICLE = 'particle-evm',
+  OKX = 'okx',
+  Cyber = 'cyber',
+  StarkNet = 'starknet',
+  WALLETCONNECT = 'walletconnect',
+  Cardano = 'cardano'
+}
+
+export enum ChainType {
+  Evm = 'evm',
+  Ton = 'ton',
+  // Starknet = 'starknet',
+  Solana = 'solana'
+}
+export enum ExtendedWalletType {
+  UNISAT = 'unisat',
+  OKXBTC = 'okx_btc'
+}
+
+export type ProviderType = WalletType | ExtendedWalletType;
+
+export type ISignResult =
+  | {
+      message: string;
+      signature: string;
+      [key: string]: any;
+    }
+  | undefined;
+
+export interface ISignInMessage {
+  domain?: string;
+  version?: string;
+  nonce: string;
+  issuedAt: string;
+  statement: string;
+  chainId?: number | string;
+  uri?: string;
+  address?: string;
+}

package/src/airdrop/core/useWeb3ConnectWallet/utils/index.ts

@@ -0,0 +1,61 @@
+import { ISignInMessage } from '../types';
+import { customAlphabet } from 'nanoid';
+
+export const getCustomNaNoId = (): string => {
+  const nanoid = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyz', 10);
+  return nanoid();
+};
+
+export function prepareSignMessage({
+  chainId,
+  address,
+  statement
+}: {
+  address: string;
+  chainId: number | string;
+  statement?: string;
+}): ISignInMessage {
+  return {
+    statement: statement || 'Welcome to EthSign',
+    chainId: chainId,
+    address: address,
+    issuedAt: new Date().toISOString(),
+    domain: window.location.host,
+    uri: window.location.origin,
+    version: '1',
+    nonce: getCustomNaNoId()
+  };
+}
+
+export const get4361Message = ({
+  domain,
+  version,
+  nonce,
+  issuedAt,
+  statement,
+  chainId,
+  uri,
+  address
+}: ISignInMessage): string => {
+  const header = `${domain} wants you to sign in with your Ethereum account:`;
+  const uriField = `URI: ${uri}`;
+  let prefix = [header, address].join('\n');
+  const versionField = `Version: ${version}`;
+
+  // const addressField = `Address: ` + address;
+
+  const chainField = `Chain ID: ` + chainId || '1';
+
+  const nonceField = `Nonce: ${nonce}`;
+
+  const suffixArray = [uriField, versionField, chainField, nonceField];
+
+  suffixArray.push(`Issued At: ${issuedAt}`);
+
+  const suffix = suffixArray.join('\n');
+  prefix = [prefix, statement].join('\n\n');
+  if (statement) {
+    prefix += '\n';
+  }
+  return [prefix, suffix].join('\n');
+};