@swapkit/helpers 2.5.0 → 3.0.0-beta.0

package/src/modules/swapKitConfig.ts

@@ -0,0 +1,131 @@
+import { createStore } from "zustand/vanilla";
+import { type Chain, EXPLORER_URLS, NODE_URLS, RPC_URLS } from "../types";
+
+export type SKConfigIntegrations = {
+  chainflip?: { useSDKBroker?: boolean; brokerUrl: string };
+  coinbase?: {
+    appName: string;
+    appLogoUrl?: string | null;
+    darkMode?: boolean;
+    linkAPIUrl?: string;
+    overrideIsMetaMask?: boolean;
+    overrideIsCoinbaseWallet?: boolean;
+    overrideIsCoinbaseBrowser?: boolean;
+    headlessMode?: boolean;
+    reloadOnDisconnect?: boolean;
+  };
+  trezor?: { email: string; appUrl: string };
+  keepKey?: { name: string; imageUrl: string; basePath: string; url: string };
+  radix: {
+    dAppDefinitionAddress: string;
+    applicationName: string;
+    applicationVersion: string;
+    network: { networkId: number; networkName: string; dashboardBase: string };
+  };
+};
+
+const initialState = {
+  // TODO: figure out how to type apis without using toolbox directly
+  // Maybe move rpc/toolbox apis to helpers?
+  apis: {} as { [key in Chain]: any },
+  explorerUrls: EXPLORER_URLS,
+  nodeUrls: NODE_URLS,
+  rpcUrls: RPC_URLS,
+
+  apiKeys: {
+    blockchair: "",
+    covalent: "",
+    ethplorer: "freekey",
+    kado: "",
+    keepKey: "",
+    swapKit: "",
+    walletConnectProjectId: "",
+  },
+
+  envs: {
+    apiUrl: "https://api.swapkit.dev",
+    devApiUrl: "https://dev-api.swapkit.dev",
+    isDev: false,
+    isStagenet: false,
+    referer: "https://swapkit.dev",
+  },
+
+  integrations: {
+    radix: {
+      applicationName: "Swapkit Playground",
+      applicationVersion: "0.0.1",
+      dAppDefinitionAddress: "account_rdx128r289p58222hcvev7frs6kue76pl7pdcnw8725aw658v0zggkh9ws",
+      network: {
+        dashboardBase: "https://dashboard.radixdlt.com",
+        networkId: 1,
+        networkName: "mainnet",
+      },
+    },
+  } as SKConfigIntegrations,
+};
+type SKState = typeof initialState;
+
+export type SKConfigState = {
+  apiKeys?: Partial<SKState["apiKeys"]>;
+  envs?: Partial<SKState["envs"]>;
+  explorerUrls?: Partial<SKState["explorerUrls"]>;
+  integrations?: Partial<SKConfigIntegrations>;
+  nodeUrls?: Partial<SKState["nodeUrls"]>;
+  rpcUrls?: Partial<SKState["rpcUrls"]>;
+};
+
+type SwapKitConfigStore = SKState & {
+  setApiKey: (key: keyof SKState["apiKeys"], apiKey: string) => void;
+  setConfig: (config: SKConfigState) => void;
+  setEnv: <T extends keyof SKState["envs"]>(key: T, value: SKState["envs"][T]) => void;
+  setExplorerUrl: (chain: keyof SKState["explorerUrls"], url: string) => void;
+  setNodeUrl: (chain: keyof SKState["nodeUrls"], url: string) => void;
+  setRpcUrl: (chain: keyof SKState["rpcUrls"], url: string) => void;
+  setIntegrationConfig: (
+    integration: keyof SKState["integrations"],
+    config: SKConfigIntegrations[keyof SKConfigIntegrations],
+  ) => void;
+};
+
+const swapKitState = createStore<SwapKitConfigStore>((set) => ({
+  ...initialState,
+
+  setApiKey: (key, apiKey) => set((s) => ({ apiKeys: { ...s.apiKeys, [key]: apiKey } })),
+  setEnv: (key, value) => set((s) => ({ envs: { ...s.envs, [key]: value } })),
+  setExplorerUrl: (chain, url) =>
+    set((s) => ({ explorerUrls: { ...s.explorerUrls, [chain]: url } })),
+  setNodeUrl: (chain, url) => set((s) => ({ nodeUrls: { ...s.nodeUrls, [chain]: url } })),
+  setRpcUrl: (chain, url) => set((s) => ({ rpcUrls: { ...s.rpcUrls, [chain]: url } })),
+  setIntegrationConfig: (integration, config) =>
+    set((s) => ({ integrations: { ...s.integrations, [integration]: config } })),
+  setConfig: (config) =>
+    set((s) => ({
+      apiKeys: { ...s.apiKeys, ...config.apiKeys },
+      envs: { ...s.envs, ...config.envs },
+      explorerUrls: { ...s.explorerUrls, ...config.explorerUrls },
+      nodeUrls: { ...s.nodeUrls, ...config.nodeUrls },
+      rpcUrls: { ...s.rpcUrls, ...config.rpcUrls },
+      integrations: { ...s.integrations, ...config.integrations },
+    })),
+}));
+
+export const SKConfig = {
+  getState: swapKitState.getState,
+  get: <T extends keyof SKState>(key: T) => swapKitState.getState()[key],
+  set: <T extends SKConfigState>(config: T) => swapKitState.getState().setConfig(config),
+
+  setApiKey: <T extends keyof SKState["apiKeys"]>(key: T, apiKey: string) =>
+    swapKitState.getState().setApiKey(key, apiKey),
+  setEnv: <T extends keyof SKState["envs"]>(key: T, value: SKState["envs"][T]) =>
+    swapKitState.getState().setEnv(key, value),
+  setExplorerUrl: <T extends keyof SKState["explorerUrls"]>(chain: T, url: string) =>
+    swapKitState.getState().setExplorerUrl(chain, url),
+  setNodeUrl: <T extends keyof SKState["nodeUrls"]>(chain: T, url: string) =>
+    swapKitState.getState().setNodeUrl(chain, url),
+  setRpcUrl: <T extends keyof SKState["rpcUrls"]>(chain: T, url: string) =>
+    swapKitState.getState().setRpcUrl(chain, url),
+  setIntegrationConfig: <T extends keyof SKState["integrations"]>(
+    integration: T,
+    config: SKConfigIntegrations[T],
+  ) => swapKitState.getState().setIntegrationConfig(integration, config),
+};

package/src/modules/swapKitError.ts

@@ -94,6 +94,7 @@ const errorCodes = {
   wallet_keepkey_contract_address_not_provided: 20902,
   wallet_keepkey_send_transaction_no_address: 20903,
   wallet_bitkeep_not_found: 21001,
+  wallet_exodus_sign_transaction_error: 21100,
   /**
    * Chainflip
    */
@@ -128,6 +129,7 @@ const errorCodes = {
   toolbox_cosmos_signer_not_defined: 90101,
   toolbox_cosmos_no_accounts_found: 90102,
   toolbox_cosmos_verify_signature_no_pubkey: 90103,
+  toolbox_cosmos_validate_address_prefix_not_found: 90104,
   toolbox_evm_no_abi_fragment: 90201,
   toolbox_evm_no_signer: 90202,
   toolbox_evm_no_signer_address: 90203,
@@ -168,8 +170,8 @@ export class SwapKitError extends Error {
     sourceError?: any,
   ) {
     const isErrorString = typeof errorOrErrorKey === "string";
-
     const errorKey = isErrorString ? errorOrErrorKey : errorOrErrorKey.errorKey;
+    super(errorKey);
 
     if (sourceError) {
       console.error(sourceError, {
@@ -178,11 +180,9 @@ export class SwapKitError extends Error {
       });
     }
 
-    super(errorKey, {
-      cause: {
-        code: SwapKitError.ErrorCode[errorKey],
-        message: `${errorKey}${isErrorString ? "" : `: ${JSON.stringify(errorOrErrorKey.info)}`}`,
-      },
+    console.error(errorKey, {
+      code: SwapKitError.ErrorCode[errorKey],
+      message: `${errorKey}${isErrorString ? "" : `: ${JSON.stringify(errorOrErrorKey.info)}`}`,
     });
 
     Object.setPrototypeOf(this, SwapKitError.prototype);

package/src/tokens/index.ts

@@ -0,0 +1,15 @@
+import * as tokenLists from "./lists";
+
+export function getTokenIcon(identifier: string): string | undefined {
+  // Search through all lists for a matching token
+  for (const list of Object.values(tokenLists)) {
+    const token = list.tokens.find((token) => token.identifier === identifier);
+    if (token?.logoURI) {
+      return token.logoURI;
+    }
+  }
+
+  return undefined;
+}
+
+export { tokenLists };