@sign-global/tokentable 0.4.2-beta.2 → 0.4.2-beta.4

package/src/airdrop/SignatureAirdropClient.ts

@@ -1,378 +0,0 @@
-import { CONST } from './constants';
-import { EvmSignatureAirdropService, SolanaSignatureAirdropService } from './contracts';
-import { WalletFactory } from '../wallets';
-import { ChainType } from '../wallets/types';
-import {
-  bindWallet,
-  checkEligibility,
-  checkGetSignatures,
-  connectGoogleApi,
-  connectTwitter,
-  disconnectRecipient,
-  getAirdropProject
-} from './services';
-import {
-  AirdropSigIdentityTypeEnum,
-  ChainId,
-  ErrorCode,
-  IAirdropOptions,
-  IAirdropSignatureClaim,
-  IAirdropSignatureIdentity,
-  IClaimSignature,
-  IProject,
-  IWalletClient,
-  SolanaWalletState,
-  ViemWalletClient
-} from './types';
-import { cleanUrlParams, isMobile } from '../utils';
-
-export class SignatureAirdropClient {
-  private projectId?: string;
-  private endpoint?: string;
-  private project: IProject | undefined;
-  protected claims?: IAirdropSignatureClaim[];
-  protected identities?: IAirdropSignatureIdentity[];
-  private projectPromise: Promise<void> | undefined;
-  private authPromise: Promise<void> | undefined;
-  private strategyCache: Map<string, EvmSignatureAirdropService | SolanaSignatureAirdropService> = new Map();
-  constructor(params: IAirdropOptions) {
-    this.projectId = params.projectId;
-    this.endpoint = params.endpoint;
-    if (this.project) {
-      this.project = params.project;
-    } else {
-      this.projectPromise = this.initializeProjects();
-    }
-    if (isMobile()) {
-      this.authPromise = this.checkAndHandleTwitterCode();
-    }
-  }
-
-  private readonly LOCAL_STORAGE_SID_PREFIX = 'sid_';
-
-  private async checkAndHandleTwitterCode() {
-    try {
-      const urlParams = new URLSearchParams(window.location.search);
-      const code = urlParams.get('code');
-      const type = urlParams.get('type');
-
-      if (code && this.projectId) {
-        let res;
-        if (type === 'twitter') {
-          res = await connectTwitter({ code, projectId: this.projectId }, this.endpoint);
-        } else if (type === 'google') {
-          res = await connectGoogleApi({ code, projectId: this.projectId }, this.endpoint);
-        }
-        if (res?.sid) {
-          this.setSid(this.projectId!, res.sid);
-        } else {
-          throw new Error('Failed to connect');
-        }
-        cleanUrlParams(['code', 'type']);
-      }
-    } catch (error) {
-      console.error(error);
-    }
-  }
-
-  private setSid(projectId: string, sid: string): void {
-    window.localStorage.setItem(`${this.LOCAL_STORAGE_SID_PREFIX}${projectId}`, sid);
-  }
-
-  private async fetchProjectDetails(projectId: string): Promise<void> {
-    this.project = await getAirdropProject(projectId, this.endpoint);
-  }
-
-  protected async initializeProjects() {
-    try {
-      let projectId = this.projectId;
-      if (!projectId) {
-        return;
-      }
-      await this.fetchProjectDetails(projectId);
-    } catch (error: any) {
-      throw new Error(`Failed to initialize project: ${error.message}`);
-    }
-  }
-
-  async getProjectInfo() {
-    if (this.projectPromise) {
-      await this.projectPromise;
-    }
-    if (!this.project) throw new Error('Project not found');
-    return this.project;
-  }
-
-  async connectOAuth({
-    onSuccess,
-    onError,
-    type
-  }: {
-    onSuccess: () => void;
-    onError: (error: Error) => void;
-    type: AirdropSigIdentityTypeEnum;
-  }) {
-    const project = await this.getProjectInfo();
-    const authorizeUrl = project.identities.find((item: any) => item.identityType === type)?.authorizeUrl;
-    if (!authorizeUrl) {
-      onError(new Error('Authorize URL not found'));
-      return;
-    }
-    if (isMobile()) {
-      const state = encodeURIComponent(window.location.href);
-      window.location.href = `${authorizeUrl}&state=${state}`;
-      return;
-    }
-    const onWindowMessage = async (message: any) => {
-      const name = message.data?.name;
-      if (name && [CONST.TWITTER_AUTH_SUCCESS, CONST.GOOGLE_AUTH_SUCCESS].includes(name)) {
-        const { code } = message.data.data || {};
-        try {
-          let res;
-          if (name === CONST.GOOGLE_AUTH_SUCCESS) {
-            res = await connectGoogleApi({ code, projectId: project.id }, this.endpoint);
-          } else if (name === CONST.TWITTER_AUTH_SUCCESS) {
-            res = await connectTwitter({ code, projectId: project.id }, this.endpoint);
-          }
-          if (res?.sid) {
-            this.setSid(project.id, res?.sid);
-            onSuccess();
-          } else {
-            onError(new Error('Failed to connect'));
-          }
-        } catch (error) {
-          onError(error as Error);
-        } finally {
-          window.removeEventListener('message', onWindowMessage);
-        }
-      }
-    };
-
-    window.addEventListener('message', onWindowMessage);
-    window.open(`${authorizeUrl}&state=state`, `twitter_auth_${project.id}`, 'width=600,height=800');
-  }
-
-  async connectX({ onSuccess, onError }: { onSuccess: () => void; onError: (error: Error) => void }) {
-    await this.connectOAuth({
-      onSuccess,
-      onError,
-      type: AirdropSigIdentityTypeEnum.Twitter
-    });
-  }
-
-  async connectGoogle({ onSuccess, onError }: { onSuccess: () => void; onError: (error: Error) => void }) {
-    await this.connectOAuth({
-      onSuccess,
-      onError,
-      type: AirdropSigIdentityTypeEnum.Google
-    });
-  }
-
-  async connectWallet({
-    chainType,
-    onSuccess,
-    onError
-  }: {
-    chainType: ChainType;
-    onSuccess?: (address: string) => void;
-    onError?: (error: any) => void;
-  }) {
-    try {
-      const project = await this.getProjectInfo();
-      const wallet = WalletFactory.getWallet(chainType);
-      const timestamp = Date.now();
-      const recipientTypeMap = {
-        [ChainType.Evm]: AirdropSigIdentityTypeEnum.EVMWallet,
-        [ChainType.Solana]: AirdropSigIdentityTypeEnum.SolanaWallet,
-        [ChainType.Ton]: AirdropSigIdentityTypeEnum.TONWallet
-      };
-      const msg = [project.id, recipientTypeMap[chainType], timestamp].join(',');
-      const signResult = await wallet.signin(msg, false);
-      await wallet.disconnect();
-      const { message, signature } = signResult || {};
-
-      if (this.identities?.find((it) => it.value?.toLowerCase() === wallet.address?.toLowerCase())) {
-        onError?.(ErrorCode.WALLET_ALREADY_CONNECTED);
-        return;
-      }
-
-      const payload = {
-        signature: signature as string,
-        message: message as string,
-        key: wallet.publicKey || wallet.address!,
-        address: wallet.address!,
-        projectId: project.id,
-        timestamp: timestamp,
-        recipientType: recipientTypeMap[chainType]
-      };
-
-      const res = await bindWallet(payload, this.endpoint);
-      if (res?.sid) {
-        this.setSid(project.id, res?.sid);
-      }
-      onSuccess?.(wallet.address!);
-    } catch (error) {
-      onError?.(error);
-    }
-  }
-
-  async getClaims() {
-    const project = await this.getProjectInfo();
-    if (this.authPromise) {
-      await this.authPromise;
-    }
-    const res = await checkEligibility(
-      {
-        projectId: project.id
-      },
-      this.endpoint
-    );
-    this.claims = res.claims;
-    this.identities = res.identities;
-    return res;
-  }
-
-  public async disconnectIdentity({
-    recipientType,
-    recipient
-  }: {
-    recipientType: AirdropSigIdentityTypeEnum;
-    recipient?: string;
-  }) {
-    const project = await this.getProjectInfo();
-    return await disconnectRecipient(
-      {
-        projectId: project.id,
-        recipientType,
-        recipient
-      },
-      this.endpoint
-    );
-  }
-
-  public async getStrategy(
-    walletClient?: IWalletClient
-  ): Promise<EvmSignatureAirdropService | SolanaSignatureAirdropService> {
-    const project = await this.getProjectInfo();
-
-    const cacheKey = walletClient
-      ? project.chainType === ChainType.Evm
-        ? (walletClient as ViemWalletClient).account?.address!
-        : project.chainType === ChainType.Solana
-        ? (walletClient as SolanaWalletState).publicKey!.toString()
-        : 'walletClient'
-      : 'default';
-    if (this.strategyCache.has(cacheKey)) {
-      return this.strategyCache.get(cacheKey)!;
-    }
-
-    const strategy =
-      project.chainType === ChainType.Solana
-        ? new SolanaSignatureAirdropService({
-            chainId: project.chainId,
-            projectId: project.id,
-            token: project.tokenAddress,
-            walletClient: walletClient as any
-          })
-        : new EvmSignatureAirdropService({
-            chainId: Number(project.chainId) as ChainId,
-            contractAddress: project.contractAddress,
-            walletClient: walletClient as any
-          });
-    this.strategyCache.set(cacheKey, strategy);
-    return strategy;
-  }
-
-  async getVersion(): Promise<string> {
-    const strategy = await this.getStrategy();
-    return strategy.getVersion();
-  }
-
-  // solana prams need to wallet
-  async getClaimFee(amount?: bigint, walletClient?: IWalletClient): Promise<undefined | bigint> {
-    const strategy = await this.getStrategy(walletClient);
-    if (!strategy.getClaimFee) {
-      throw new Error('getClaimFee is not supported for this chain');
-    }
-    return await strategy.getClaimFee(this.project?.contractAddress || '', amount || BigInt(1));
-  }
-
-  async claimAirdrop({
-    claimIds,
-    walletClient,
-    recipient
-  }: {
-    claimIds: string[];
-    walletClient: IWalletClient;
-    recipient: string;
-  }) {
-    if (!claimIds.length) {
-      throw new Error('Claim IDs cannot be empty');
-    }
-    if (!walletClient) {
-      throw new Error('Wallet client is required');
-    }
-    if (!this.claims?.length) {
-      throw new Error('No claims available');
-    }
-    const service = await this.getStrategy(walletClient);
-    const project = await this.getProjectInfo();
-    const res = await checkGetSignatures(
-      {
-        claimIds,
-        projectId: this.projectId!,
-        recipient
-      },
-      this.endpoint
-    );
-    if (!res?.signatures?.length) {
-      throw new Error('Failed to get signatures');
-    }
-    const signatureMap = res?.signatures?.reduce((map, item) => {
-      map[item.claimId] = item;
-      return map;
-    }, {} as Record<string, IClaimSignature>);
-    const filteredClaims = this.claims.filter((it) => claimIds.includes(it.claimId));
-    if (!filteredClaims.length) {
-      throw new Error('No matching claims found');
-    }
-
-    // only evm use
-    const defaultRecipient =
-      project.chainType === ChainType.Evm ? (walletClient as ViemWalletClient).account?.address! : '';
-
-    const claimData = filteredClaims.map((it) => {
-      const signature = signatureMap[it.claimId];
-      if (!signature) {
-        throw new Error(`Signature not found for claim ID: ${it.claimId}`);
-      }
-
-      return {
-        ...it,
-        recipient: recipient ? recipient : defaultRecipient,
-        ...signature
-      };
-    });
-
-    const hash = (await service!.claim(claimData, recipient)) as `0x${string}`;
-    return hash;
-  }
-
-  async batchCheckClaimed(): Promise<boolean[]> {
-    if (!this.claims?.length) return [];
-    const strategy = await this.getStrategy();
-    if (!strategy.batchFetchClaimed) {
-      throw new Error('batchCheckClaimed is not supported for this chain');
-    }
-    const claimIds = this.claims?.map((it) => it.claimId);
-    return strategy.batchFetchClaimed(claimIds);
-  }
-
-  async getPaused(): Promise<boolean> {
-    const strategy = await this.getStrategy();
-    if (!strategy.getPaused) {
-      throw new Error('getPaused is not supported for this chain');
-    }
-    return strategy.getPaused();
-  }
-}

package/src/airdrop/common/index.ts

@@ -1,54 +0,0 @@
-import { ChainConfig, SupportedChains } from '../constants';
-import { ChainId } from '../types';
-import { projectDataForTon } from './projectDataForTon';
-
-export function getChainById(chainId: ChainId) {
-  const chain = SupportedChains.find((chain) => chain.id === chainId);
-
-  if (!chain) {
-    throw new Error(`ChainId ${chainId} not supported.`);
-  }
-
-  return chain;
-}
-
-export function getChainConfig(chainId: ChainId) {
-  return ChainConfig[chainId];
-}
-
-export function getChainRpc(chainId: ChainId): string {
-  const config = getChainConfig(chainId as any);
-
-  if (!config) {
-    throw new Error(`ChainId ${chainId} not supported.`);
-  }
-
-  return config?.rpcUrl;
-}
-
-export const getTonProjectIdByAddress = ({
-  address,
-  slug,
-  data
-}: {
-  address?: string;
-  slug: string;
-  data: Record<string, string>;
-}): string | undefined => {
-  let project: Record<string, string> = projectDataForTon[slug as keyof typeof projectDataForTon];
-  if (!project) {
-    project = data;
-  }
-
-  if (!address) {
-    const firstProject = Object.values(project)[0];
-    return firstProject;
-  }
-  const lastText = address[address.length - 1];
-
-  const group = Object.keys(project || {}).find((key) => key.includes(lastText));
-
-  const projectId = group ? project[group as keyof typeof project] : undefined;
-
-  return projectId;
-};

package/src/airdrop/common/projectDataForTon.ts

@@ -1,79 +0,0 @@
-export const projectDataForTon = {
-  ava: {
-    '12345': 'AD_18uwEPKbTXZo',
-    '67890': 'AD_XOPhRRGggtjK',
-    abcABC: 'AD_qKwG21hnimAB',
-    defDEF: 'AD_CfAV1GNekDAQ',
-    ghiGHI: 'AD_uwipChWywF4V',
-    jklJKL: 'AD_d3tai5RtikM2',
-    mnoMNO: 'AD_dMEF8ToRIqzY',
-    pqrPQR: 'AD_vdx6P5QHc1ES',
-    stuSTU: 'AD_2k77RlCRD1ds',
-    vwxVWX: 'AD_hiXx1hLsIkBM',
-    'yz-_YZ': 'AD_cj99f5rdUU8C'
-  },
-  dogs: {
-    '12': 'AD_P2ipWbDVrtSE',
-    '34': 'AD_cXW3IFfYHfa5',
-    '56': 'AD_NG5bNpQOHuqI',
-    '78': 'AD_KvnQeG76AgYs',
-    '90': 'AD_xlv2JO3PQdtR',
-    aA: 'AD_kc0CJE8RPvJy',
-    bB: 'AD_yRFzJyPoAOY4',
-    cC: 'AD_yN14YHi4F29p',
-    dD: 'AD_jWsTmtfnbzVn',
-    eE: 'AD_ZfFnjr06dhp7',
-    fF: 'AD_s58jwEK3EggA',
-    gG: 'AD_qKszLFxv5PDy',
-    hH: 'AD_RzefaG1fi44A',
-    iI: 'AD_LItldBE09QRn',
-    jJ: 'AD_SzKbQmVOz0S1',
-    kK: 'AD_rNrYIzCzye0W',
-    lL: 'AD_IbtlhoM0M6SZ',
-    mM: 'AD_m2NUNiwCgFES',
-    nN: 'AD_3mb6NTcYPw5y',
-    oO: 'AD_kVrO6qmmZDUK',
-    pP: 'AD_cV9g8YMQZ0iB',
-    qQ: 'AD_esdFer2shKO3',
-    rR: 'AD_BqZmJzFKapu0',
-    sS: 'AD_iOU6Rnltj3sx',
-    tT: 'AD_M8J1QU64Yuzi',
-    uU: 'AD_es9ceiuC8TXq',
-    vV: 'AD_7DXSpRcGivjO',
-    wW: 'AD_0uI9R6Sc6jY4',
-    xX: 'AD_FyrRNdtrgqKj',
-    yY: 'AD_JR0ktPVqVriT',
-    zZ: 'AD_bb9I2XdIqM6W',
-    '_-': 'AD_qaLi6r8K9BAv'
-  },
-  ava2: {
-    '1234567890_': 'AD_EZFWfhs641YQ',
-    'aAbBcCdDeE-': 'AD_jCVjsDT9g6h3',
-    fFgGhHiIjJ: 'AD_7nF9gncQeVW3',
-    kKlLmMnNoO: 'AD_RmoPsyKeIah0',
-    pPqQrRsStTZ: 'AD_zrK1RVGQ2Ogl',
-    uUvVwWxXyYz: 'AD_fKN6IcxEIdIA'
-  },
-  wat: {
-    '1234': 'AD_sMtwhyrqUFiZ',
-    '5678': 'AD_CMZVOHQjeVBp',
-    aAbB: 'AD_sdmcLLcDS59f',
-    cCdD: 'AD_M9Zyy7VaLuR1',
-    eEfF: 'AD_K4WWeUvk7aMj',
-    gGhH: 'AD_AmCnivdzxToB',
-    iIjJ: 'AD_2NgsKs5nyJhe',
-    kKlL: 'AD_IOPluo9KRSM9',
-    mMnN: 'AD_FMOlFAIOycQw',
-    oOpP: 'AD_NCW9yZdOTPQ9',
-    qQrR: 'AD_JjOkeBs0Jfsb',
-    sStT: 'AD_hUkWbwWMWUvp',
-    uUvV: 'AD_w9UAKxCxU84P',
-    wWxX: 'AD_Vwa41VRRXjpP',
-    yYzZ: 'AD_XQbS0ksJGDrB',
-    '90_-': 'AD_LhssByVDm8Q1'
-  },
-  roolz: {
-    abcdefghijklmnopqrstuvwxyz12345_: 'AD_3ZoF8wq7leAI',
-    'ABCDEFGHIJKLMNOPQRSTUVWXYZ67890-': 'AD_HMFs2ubSrC1K'
-  }
-};

package/src/airdrop/constants/chain-config.ts

@@ -1,107 +0,0 @@
-import { CHAIN } from '@tonconnect/ui-react';
-import {
-  base,
-  baseSepolia,
-  cyber,
-  mainnet,
-  polygonMumbai,
-  polygonAmoy,
-  sepolia,
-  zetachain,
-  zetachainAthensTestnet,
-  zkSync,
-  bsc,
-  berachainTestnet,
-  arbitrum
-} from 'viem/chains';
-import { mevmDevNet, tonMainNet, tonTestNet } from './network';
-
-export const ChainConfig = {
-  [mainnet.id]: {
-    contractAddress: '0x0993Dd5384BcD116A3543889BC6ffA6C98948631',
-    rpcUrl: 'https://eth-mainnet.g.alchemy.com/v2/udrqNPSB6i5n5L6QSM31Ng72h_hFOrVT'
-  },
-  [bsc.id]: {
-    contractAddress: '0x6c241FF6d5c3f074b49aC10872770529d9e27BA4',
-    rpcUrl: 'https://bnb-mainnet.g.alchemy.com/v2/udrqNPSB6i5n5L6QSM31Ng72h_hFOrVT'
-  },
-  [base.id]: {
-    contractAddress: '0x3d1abcD56d53f7C8b04A753C6AF397903DC0f0F2',
-    rpcUrl: base.rpcUrls.default.http[0]
-  },
-  [cyber.id]: {
-    contractAddress: '0x7915dA247674E430b2a4Dcf01e4471f709428Bc0',
-    rpcUrl: cyber.rpcUrls.default.http[0]
-  },
-  [sepolia.id]: {
-    contractAddress: '0xf3f5243B35376c6dea04169983A8c853c8BE6d69',
-    rpcUrl: 'https://eth-sepolia.public.blastapi.io'
-  },
-  [baseSepolia.id]: {
-    contractAddress: '0x66c9fe5c76672B06Bf497eFfdaAfDf897D1e68d8',
-    rpcUrl: baseSepolia.rpcUrls.default.http[0]
-  },
-  [zetachainAthensTestnet.id]: {
-    contractAddress: '0x63aE2f2260DEfc11932d22410B976Ec29F54498B',
-    rpcUrl: zetachainAthensTestnet.rpcUrls.default.http[0]
-  },
-  [zetachain.id]: {
-    contractAddress: '0x00aFD4466E4Afa4F43cCd414b1BC65e574ACA2f5',
-    rpcUrl: 'https://zetachain-mainnet.g.alchemy.com/v2/1tmk0FrhwTJHXh0XIyae7_SXw1lDCjgs'
-  },
-  [arbitrum.id]: {
-    contractAddress: '0x759ac3CA33FeeAfB8C41aEbC8687A7Bd849Fc87a',
-    rpcUrl: arbitrum.rpcUrls.default.http[0]
-  },
-  [berachainTestnet.id]: {
-    contractAddress: '',
-    rpcUrl: '',
-    availableSolutions: []
-  },
-  [polygonMumbai.id]: {
-    contractAddress: '',
-    rpcUrl: '',
-    availableSolutions: []
-  },
-  [polygonAmoy.id]: {
-    contractAddress: '',
-    rpcUrl: '',
-    availableSolutions: []
-  },
-  [mevmDevNet.id]: {
-    contractAddress: '0x8D92827CdB67A503e9FB21B28a58F9dAb36B4973',
-    rpcUrl: mevmDevNet.rpcUrls.default.http[0]
-  },
-  [CHAIN.TESTNET]: {
-    name: 'TestNet',
-    contractAddress: '',
-    rpcUrl: 'https://testnet.toncenter.com/api/v2/jsonRPC', //https://toncenter.com/api/v2/jsonRPC
-    tonApiPrefix: 'https://testnet.tonapi.io',
-    blockExplorer: 'https://testnet.tonviewer.com'
-  },
-  [CHAIN.MAINNET]: {
-    name: 'MainNet',
-    contractAddress: '',
-    rpcUrl: 'https://toncenter.com/api/v2/jsonRPC',
-    tonApiPrefix: 'https://tonapi.io',
-    blockExplorer: 'https://tonviewer.com'
-  }
-};
-
-export const SupportedChains = [
-  mainnet,
-  bsc,
-  base,
-  cyber,
-  sepolia,
-  baseSepolia,
-  zetachain,
-  zetachainAthensTestnet,
-  berachainTestnet,
-  polygonMumbai,
-  polygonAmoy,
-  mevmDevNet,
-  arbitrum,
-  tonTestNet,
-  tonMainNet
-];

package/src/airdrop/constants/index.ts

@@ -1,9 +0,0 @@
-export * from './chain-config';
-
-export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
-
-export const CONST = {
-  TWITTER_AUTH_SUCCESS: 'twitter:auth:success',
-  GOOGLE_AUTH_SUCCESS: 'google:auth:success',
-  WELCOME_SIGNATURE_STATEMENT: 'Welcome to TokenTable!'
-} as const;

package/src/airdrop/constants/network.ts

@@ -1,78 +0,0 @@
-import { CHAIN } from '@tonconnect/ui-react';
-import { defineChain } from 'viem';
-
-export const mevmDevNet = defineChain({
-  id: 30732,
-  name: 'Movement M1 Devnet',
-  network: 'mevm',
-  nativeCurrency: { name: 'Move', symbol: 'MOVE', decimals: 18 },
-  rpcUrls: {
-    default: {
-      http: ['https://mevm.devnet.imola.movementlabs.xyz']
-    },
-    public: {
-      http: ['https://mevm.devnet.imola.movementlabs.xyz']
-    }
-  },
-  blockExplorers: {
-    etherscan: { name: 'Arbiscan', url: 'https://explorer.devnet.imola.movementlabs.xyz/' },
-    default: { name: 'Arbiscan', url: 'https://explorer.devnet.imola.movementlabs.xyz/' }
-  },
-  contracts: {
-    multicall3: {
-      address: '0xD67Eca381AAbd0c049554f5714E7d8C21864c560',
-      blockCreated: 500
-    }
-  }
-});
-
-export const tonTestNet = {
-  id: CHAIN.TESTNET,
-  name: 'TON Testnet',
-  network: 'TON_TESTNET',
-  nativeCurrency: {
-    decimals: 9,
-    name: 'TON',
-    symbol: 'TON'
-  },
-  rpcUrls: {
-    public: {
-      http: []
-    },
-    default: {
-      http: []
-    }
-  },
-  blockExplorers: {
-    default: {
-      name: 'tonviewer',
-      url: 'https://testnet.tonviewer.com'
-    }
-  },
-  testnet: true
-};
-
-export const tonMainNet = {
-  id: CHAIN.MAINNET,
-  name: 'TON Mainnet',
-  network: 'TON_MAINNET',
-  nativeCurrency: {
-    decimals: 9,
-    name: 'TON',
-    symbol: 'TON'
-  },
-  rpcUrls: {
-    public: {
-      http: []
-    },
-    default: {
-      http: []
-    }
-  },
-  blockExplorers: {
-    default: {
-      name: 'tonviwer',
-      url: 'https://tonviewer.com'
-    }
-  }
-};