WIP: Getting signer working

wormhole-connect/src/AppRouter.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useMemo } from 'react';
+import React, { useContext, useEffect, useMemo } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
 import { makeStyles } from 'tss-react/mui';
 
@@ -24,6 +24,7 @@ import { useExternalSearch } from 'hooks/useExternalSearch';
 import internalConfig from 'config';
 
 import BridgeV2 from 'views/v2/Bridge';
+import { RouteContext } from 'contexts/RouteContext';
 
 const useStyles = makeStyles()((theme: any) => ({
  appContent: {
@@ -49,6 +50,7 @@ interface Props {
 function AppRouter(props: Props) {
  const { classes } = useStyles();
  const dispatch = useDispatch();
+ const routeContext = useContext(RouteContext);
 
  // We update the global config once when WormholeConnect is first mounted, if a custom
  // config was provided.
@@ -80,6 +82,7 @@ function AppRouter(props: Props) {
  if (prevRoute === redeemRoute && route !== redeemRoute) {
  dispatch(clearRedeem());
  dispatch(clearWallets());
+ routeContext.clear();
  internalConfig.wh.registerProviders(); // reset providers that may have been set during transfer
  }
  // reset transfer state on leave

wormhole-connect/src/WormholeConnect.tsx

@@ -9,6 +9,7 @@ import { getDesignTokens, dark } from './theme';
 import ErrorBoundary from './components/ErrorBoundary';
 import { WormholeConnectConfig } from './config/types';
 import { WormholeConnectPartialTheme } from 'theme';
+import { RouteProvider } from './contexts/RouteContext';
 
 export interface WormholeConnectProps {
  // theme can be updated at any time to change the colors of Connect
@@ -32,7 +33,9 @@ export default function WormholeConnect({
  <ThemeProvider theme={muiTheme}>
  <ScopedCssBaseline enableColorScheme>
  <ErrorBoundary>
- <AppRouter config={config} />
+ <RouteProvider>
+ <AppRouter config={config} />
+ </RouteProvider>
  </ErrorBoundary>
  </ScopedCssBaseline>
  </ThemeProvider>

wormhole-connect/src/config/converter.ts

@@ -64,12 +64,29 @@ export class SDKConverter {
  }
  }
 
- toTokenIdV2(token: v1.TokenId | TokenConfigV1): v2.TokenId {
+ toTokenIdV2(
+ token: v1.TokenId | TokenConfigV1,
+ chain?: v1.ChainName,
+ ): v2.TokenId {
  if (this.isTokenConfigV1(token)) {
- return v2.Wormhole.tokenId(
- this.toChainV2(token.nativeChain),
- token.tokenId?.address ?? 'native',
- );
+ if (chain && chain != token.nativeChain) {
+ // Getting foreign address
+ const foreignAsset = token.foreignAssets?.[chain];
+ if (foreignAsset) {
+ return v2.Wormhole.tokenId(
+ this.toChainV2(chain),
+ foreignAsset.address,
+ );
+ } else {
+ throw new Error('no foreign asset');
+ }
+ } else {
+ // Getting native address
+ return v2.Wormhole.tokenId(
+ this.toChainV2(token.nativeChain),
+ token.tokenId?.address ?? 'native',
+ );
+ }
  } else {
  return v2.Wormhole.tokenId(this.toChainV2(token.chain), token.address);
  }

wormhole-connect/src/contexts/RouteContext.tsx

@@ -0,0 +1,44 @@
+import React, { useCallback } from 'react';
+import { Network, routes } from '@wormhole-foundation/sdk';
+
+interface RouteContextType {
+ route: routes.Route<Network> | null;
+ receipt: routes.Receipt | null;
+ setRoute: (route: routes.Route<Network>) => void;
+ setReceipt: (receipt: routes.Receipt) => void;
+ clear: () => void;
+}
+
+export const RouteContext = React.createContext<RouteContextType>({
+ route: null,
+ receipt: null,
+ setRoute: () => {
+ // Keep the empty function for initial context value
+ },
+ setReceipt: () => {
+ // Keep the empty function for initial context value
+ },
+ clear: () => {
+ // Keep the empty function for initial context value
+ },
+});
+
+export const RouteProvider: React.FC<{ children: React.ReactNode }> = ({
+ children,
+}) => {
+ const [route, setRoute] = React.useState<routes.Route<Network> | null>(null);
+ const [receipt, setReceipt] = React.useState<routes.Receipt | null>(null);
+
+ const clear = useCallback(() => {
+ setRoute(null);
+ setReceipt(null);
+ }, []);
+
+ return (
+ <RouteContext.Provider
+ value={{ route, receipt, setRoute, setReceipt, clear }}
+ >
+ {children}
+ </RouteContext.Provider>
+ );
+};

wormhole-connect/src/hooks/useComputeDestinationTokens.ts

@@ -6,18 +6,18 @@ import {
  setDestToken,
  setSupportedDestTokens,
  setAllSupportedDestTokens,
- getNativeVersionOfToken,
+ //getNativeVersionOfToken,
 } from 'store/transferInput';
 
 import type { Route } from 'config/types';
 import type { ChainName } from 'sdklegacy';
 
-import { isPorticoRoute } from 'routes/porticoBridge/utils';
-import { ETHBridge } from 'routes/porticoBridge/ethBridge';
-import { wstETHBridge } from 'routes/porticoBridge/wstETHBridge';
+//import { isPorticoRoute } from 'routes/porticoBridge/utils';
+//import { ETHBridge } from 'routes/porticoBridge/ethBridge';
+//import { wstETHBridge } from 'routes/porticoBridge/wstETHBridge';
 import RouteOperator from 'routes/operator';
 
-import { getWrappedToken } from 'utils';
+//import { getWrappedToken } from 'utils';
 
 type Props = {
  sourceChain: ChainName | undefined;
@@ -86,6 +86,7 @@ export const useComputeDestinationTokens = (props: Props): void => {
  }
  }
 
+ /*
  // If the source token is supported by a Portico bridge route,
  // then select the native version on the dest chain
  if (sourceToken && destChain && (!route || isPorticoRoute(route))) {
@@ -107,6 +108,7 @@ export const useComputeDestinationTokens = (props: Props): void => {
  }
  }
  }
+ */
  };
 
  computeDestTokens();

wormhole-connect/src/hooks/useGetTokenBalances.ts

@@ -68,6 +68,7 @@ const useGetTokenBalances = (
  needsUpdate.push(token as TokenConfigWithId);
  }
  }
+
  if (needsUpdate.length > 0) {
  try {
  const wh = await getWormholeContextV2();
@@ -85,19 +86,27 @@ const useGetTokenBalances = (
  try {
  let address: string | null = null;
 
- const foreignAddress = await getForeignTokenAddress(
- config.sdkConverter.toTokenIdV2(tokenConfig),
- chainV2,
- );
-
- if (foreignAddress) {
- address = foreignAddress.toString();
+ if (
+ tokenConfig.nativeChain === chain &&
+ tokenConfig.tokenId === undefined
+ ) {
+ tokenAddresses.push('native');
+ tokenIdMapping['native'] = tokenConfig;
  } else {
- console.error('no fa', tokenConfig);
- continue;
+ const foreignAddress = await getForeignTokenAddress(
+ config.sdkConverter.toTokenIdV2(tokenConfig),
+ chainV2,
+ );
+
+ if (foreignAddress) {
+ address = foreignAddress.toString();
+ } else {
+ console.error('no fa', tokenConfig);
+ continue;
+ }
+ tokenIdMapping[address] = tokenConfig;
+ tokenAddresses.push(address);
  }
- tokenIdMapping[address] = tokenConfig;
- tokenAddresses.push(address);
  } catch (e) {
  // TODO SDKV2 SUI ISNT WORKING
  console.error(e);

wormhole-connect/src/hooks/usePorticoSwapInfo.ts

@@ -1,4 +1,4 @@
-import { useEffect } from 'react';
+/*import { useEffect } from 'react';
 import { useDispatch, useSelector } from 'react-redux';
 import RouteOperator from 'routes/operator';
 import { PorticoBridge } from 'routes/porticoBridge';
@@ -88,3 +88,4 @@ export const usePorticoSwapInfo = (): void => {
  dispatch,
  ]);
 };
+*/

wormhole-connect/src/hooks/useTrackTransfer.ts

@@ -0,0 +1,57 @@
+import { isCompleted } from '@wormhole-foundation/sdk';
+import { RouteContext } from 'contexts/RouteContext';
+import { useContext, useEffect } from 'react';
+import { useDispatch } from 'react-redux';
+import { setTransferComplete } from 'store/redeem';
+import { sleep } from 'utils';
+
+const TRACK_TIMEOUT = 120 * 1000;
+
+// TODO: document this hook, especially since it sets and depends on the receipt state
+const useTrackTransfer = () => {
+ const dispatch = useDispatch();
+
+ const routeContext = useContext(RouteContext);
+
+ useEffect(() => {
+ let isActive = true;
+
+ const track = async () => {
+ const { route, receipt } = routeContext;
+ if (!route || !receipt) {
+ return;
+ }
+ while (isActive && !isCompleted(receipt)) {
+ try {
+ // TODO: the timeout may be longer for chains with slower finality times
+ // but we will retry so maybe it doesn't matter
+ const result = await route.track(receipt, TRACK_TIMEOUT).next();
+ if (result.done || !isActive) {
+ break;
+ }
+ const currentReceipt = result.value;
+ if (currentReceipt.state !== receipt.state) {
+ routeContext.setReceipt(currentReceipt);
+ if (isCompleted(currentReceipt)) {
+ dispatch(setTransferComplete(true));
+ }
+ break;
+ }
+ } catch (e) {
+ console.error('Error tracking transfer:', e);
+ }
+ // retry
+ // TODO: exponential backoff depending on the current state?
+ await sleep(5000);
+ }
+ };
+
+ track();
+
+ return () => {
+ isActive = false;
+ };
+ }, [routeContext]);
+};
+
+export default useTrackTransfer;

wormhole-connect/src/routes/abstracts/routeAbstract.ts

@@ -135,7 +135,7 @@ export abstract class RouteAbstract {
  public abstract getMaxSendAmount(): number;
 
  public abstract send(
- token: TokenId | 'native',
+ token: TokenConfig,
  amount: string,
  sendingChain: ChainName | ChainId,
  senderAddress: string,

wormhole-connect/src/routes/mappings.ts

@@ -5,11 +5,11 @@ import { routes } from '@wormhole-foundation/sdk';
 import { SDKv2Route } from './sdkv2/route';
 
 // Legacy routes
-import { RouteAbstract } from './abstracts/routeAbstract';
-import { ETHBridge } from './porticoBridge/ethBridge';
-import { wstETHBridge } from './porticoBridge/wstETHBridge';
+//import { RouteAbstract } from './abstracts/routeAbstract';
+//import { ETHBridge } from './porticoBridge/ethBridge';
+//import { wstETHBridge } from './porticoBridge/wstETHBridge';
 
-export function getRoute(route: Route): RouteAbstract {
+export function getRoute(route: Route): SDKv2Route {
  switch (route) {
  // Migrated routes:
  case Route.Bridge:
@@ -18,10 +18,12 @@ export function getRoute(route: Route): RouteAbstract {
  return new SDKv2Route(routes.AutomaticTokenBridgeRoute, Route.Bridge);
 
  // Legacy routes:
+ /*
  case Route.ETHBridge:
  return new ETHBridge();
  case Route.wstETHBridge:
  return new wstETHBridge();
+ */
  // TODO SDKV2
  default:
  return new SDKv2Route(routes.TokenBridgeRoute, Route.Bridge);

wormhole-connect/src/routes/operator.ts

@@ -16,7 +16,7 @@ import {
 } from './types';
 import { TokenPrices } from 'store/tokenPrices';
 
-import { routes } from '@wormhole-foundation/sdk';
+import { Network, routes } from '@wormhole-foundation/sdk';
 
 import { getRoute } from './mappings';
 
@@ -428,15 +428,15 @@ export class Operator {
 
  async send(
  route: Route,
- token: TokenId | 'native',
+ token: TokenConfig,
  amount: string,
  sendingChain: ChainName | ChainId,
  senderAddress: string,
  recipientChain: ChainName | ChainId,
  recipientAddress: string,
  destToken: string,
  routeOptions: any,
- ): Promise<string | routes.Receipt> {
+ ): Promise<[routes.Route<Network>, routes.Receipt]> {
  const r = this.getRoute(route);
  return await r.send(
  token,