@wormhole-foundation/sdk-definitions 0.1.3-beta.4 → 0.1.3-beta.6

package/dist/esm/types.d.ts

@@ -24,7 +24,7 @@ export type ChainConfig = {
     platform: PlatformName;
     contracts: Contracts;
     finalityThreshold: number;
-    nativeTokenDecimals: number;
+    nativeTokenDecimals: bigint;
     explorer: ExplorerSettings;
     rpc: string;
 };

package/dist/esm/vaa.d.ts

@@ -61,8 +61,8 @@ declare const baseLayout: readonly [{
     readonly size: 4;
 }, {
     readonly custom: {
-        to: (val: number) => "Solana" | "Btc" | "Algorand" | "Sui" | "Aptos" | "Osmosis" | "Wormchain" | "Near" | "Ethereum" | "Terra" | "Bsc" | "Polygon" | "Avalanche" | "Oasis" | "Aurora" | "Fantom" | "Karura" | "Acala" | "Klaytn" | "Celo" | "Moonbeam" | "Neon" | "Terra2" | "Injective" | "Arbitrum" | "Optimism" | "Gnosis" | "Pythnet" | "Xpla" | "Base" | "Sei" | "Sepolia";
-        from: (val: "Solana" | "Btc" | "Algorand" | "Sui" | "Aptos" | "Osmosis" | "Wormchain" | "Near" | "Ethereum" | "Terra" | "Bsc" | "Polygon" | "Avalanche" | "Oasis" | "Aurora" | "Fantom" | "Karura" | "Acala" | "Klaytn" | "Celo" | "Moonbeam" | "Neon" | "Terra2" | "Injective" | "Arbitrum" | "Optimism" | "Gnosis" | "Pythnet" | "Xpla" | "Base" | "Sei" | "Sepolia") => number;
+        to: (val: number) => "Solana" | "Btc" | "Algorand" | "Sui" | "Aptos" | "Near" | "Ethereum" | "Terra" | "Bsc" | "Polygon" | "Avalanche" | "Oasis" | "Aurora" | "Fantom" | "Karura" | "Acala" | "Klaytn" | "Celo" | "Moonbeam" | "Neon" | "Terra2" | "Injective" | "Osmosis" | "Arbitrum" | "Optimism" | "Gnosis" | "Pythnet" | "Xpla" | "Base" | "Sei" | "Rootstock" | "Wormchain" | "Cosmoshub" | "Evmos" | "Kujira" | "Sepolia";
+        from: (val: "Solana" | "Btc" | "Algorand" | "Sui" | "Aptos" | "Near" | "Ethereum" | "Terra" | "Bsc" | "Polygon" | "Avalanche" | "Oasis" | "Aurora" | "Fantom" | "Karura" | "Acala" | "Klaytn" | "Celo" | "Moonbeam" | "Neon" | "Terra2" | "Injective" | "Osmosis" | "Arbitrum" | "Optimism" | "Gnosis" | "Pythnet" | "Xpla" | "Base" | "Sei" | "Rootstock" | "Wormchain" | "Cosmoshub" | "Evmos" | "Kujira" | "Sepolia") => number;
     };
     readonly binary: "uint";
     readonly size: 2;
@@ -121,8 +121,8 @@ export declare const create: <PL extends keyof Wormhole.PayloadLiteralToDescript
     readonly size: 4;
 }, {
     readonly custom: {
-        to: (val: number) => "Solana" | "Btc" | "Algorand" | "Sui" | "Aptos" | "Osmosis" | "Wormchain" | "Near" | "Ethereum" | "Terra" | "Bsc" | "Polygon" | "Avalanche" | "Oasis" | "Aurora" | "Fantom" | "Karura" | "Acala" | "Klaytn" | "Celo" | "Moonbeam" | "Neon" | "Terra2" | "Injective" | "Arbitrum" | "Optimism" | "Gnosis" | "Pythnet" | "Xpla" | "Base" | "Sei" | "Sepolia";
-        from: (val: "Solana" | "Btc" | "Algorand" | "Sui" | "Aptos" | "Osmosis" | "Wormchain" | "Near" | "Ethereum" | "Terra" | "Bsc" | "Polygon" | "Avalanche" | "Oasis" | "Aurora" | "Fantom" | "Karura" | "Acala" | "Klaytn" | "Celo" | "Moonbeam" | "Neon" | "Terra2" | "Injective" | "Arbitrum" | "Optimism" | "Gnosis" | "Pythnet" | "Xpla" | "Base" | "Sei" | "Sepolia") => number;
+        to: (val: number) => "Solana" | "Btc" | "Algorand" | "Sui" | "Aptos" | "Near" | "Ethereum" | "Terra" | "Bsc" | "Polygon" | "Avalanche" | "Oasis" | "Aurora" | "Fantom" | "Karura" | "Acala" | "Klaytn" | "Celo" | "Moonbeam" | "Neon" | "Terra2" | "Injective" | "Osmosis" | "Arbitrum" | "Optimism" | "Gnosis" | "Pythnet" | "Xpla" | "Base" | "Sei" | "Rootstock" | "Wormchain" | "Cosmoshub" | "Evmos" | "Kujira" | "Sepolia";
+        from: (val: "Solana" | "Btc" | "Algorand" | "Sui" | "Aptos" | "Near" | "Ethereum" | "Terra" | "Bsc" | "Polygon" | "Avalanche" | "Oasis" | "Aurora" | "Fantom" | "Karura" | "Acala" | "Klaytn" | "Celo" | "Moonbeam" | "Neon" | "Terra2" | "Injective" | "Osmosis" | "Arbitrum" | "Optimism" | "Gnosis" | "Pythnet" | "Xpla" | "Base" | "Sei" | "Rootstock" | "Wormchain" | "Cosmoshub" | "Evmos" | "Kujira" | "Sepolia") => number;
     };
     readonly binary: "uint";
     readonly size: 2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wormhole-foundation/sdk-definitions",
-  "version": "0.1.3-beta.4",
+  "version": "0.1.3-beta.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/wormhole-foundation/connect-sdk.git"

package/src/chain.ts

@@ -1,105 +1,122 @@
 import { ChainName, PlatformName } from "@wormhole-foundation/sdk-base";
 import { Platform } from "./platform";
+
+import {
+  supportsAutomaticCircleBridge,
+  supportsCircleBridge,
+} from "./protocols/cctp";
+import {
+  supportsAutomaticTokenBridge,
+  supportsTokenBridge,
+} from "./protocols/tokenBridge";
 import { RpcConnection } from "./rpc";
 import { AutomaticTokenBridge, TokenBridge } from "./protocols/tokenBridge";
 import { AutomaticCircleBridge, CircleBridge } from "./protocols/cctp";
-
-// TODO: there has to be a nicer way to do this
-// This requires the arguments in the function definition come in the same order
-// [chain], [rpc], ...
-
-type _omitChain<Fn> = Fn extends (chain: ChainName, ...args: infer A) => infer R
-  ? (...args: A) => R
-  : Fn;
-type _omitRpc<P extends PlatformName, Fn> = Fn extends (
-  rpc: RpcConnection<P>,
-  ...args: infer A
-) => infer R
-  ? (...args: A) => R
-  : Fn;
-
-type OmitChainRpc<
-  P extends PlatformName,
-  F extends keyof Platform<P>
-> = _omitRpc<P, _omitChain<Platform<P>[F]>>;
-
-type OmitRpc<P extends PlatformName, F extends keyof Platform<P>> = _omitRpc<
-  P,
-  Platform<P>[F]
->;
-
-type OmitChain<
-  P extends PlatformName,
-  F extends keyof Platform<P>
-> = _omitChain<Platform<P>[F]>;
+import { SignedTx, TokenId } from "./types";
+import { WormholeMessageId } from "./attestation";
+import { NativeAddress } from "./address";
 
 export abstract class ChainContext<P extends PlatformName> {
   // Cached Protocol clients
+  protected rpc?: RpcConnection<P>;
   protected tokenBridge?: TokenBridge<P>;
   protected autoTokenBridge?: AutomaticTokenBridge<P>;
   protected circleBridge?: CircleBridge<P>;
   protected autoCircleBridge?: AutomaticCircleBridge<P>;
 
-  constructor(readonly platform: Platform<P>, readonly chain: ChainName) {}
+  abstract platform: Platform<P>;
 
-  abstract getRpc(): RpcConnection<P>;
+  constructor(readonly chain: ChainName) {}
 
-  // Utils for platform specific queries
-  getDecimals: OmitChainRpc<P, "getDecimals"> = (token) => {
+  getRpc(): RpcConnection<P> {
+    this.rpc = this.rpc ? this.rpc : this.platform.getRpc(this.chain);
+    return this.rpc;
+  }
+
+  // Get the number of decimals for a token
+  async getDecimals(token: TokenId | "native"): Promise<bigint> {
     return this.platform.getDecimals(this.chain, this.getRpc(), token);
-  };
+  }
 
-  getBalance: OmitChainRpc<P, "getBalance"> = (walletAddr, token) => {
+  // Get the balance of a token for a given address
+  async getBalance(
+    walletAddr: string,
+    token: TokenId | "native"
+  ): Promise<bigint | null> {
     return this.platform.getBalance(
       this.chain,
       this.getRpc(),
       walletAddr,
       token
     );
-  };
+  }
+
+  async getCurrentBlock(): Promise<number> {
+    return this.platform.getCurrentBlock(this.getRpc());
+  }
 
   // Get details about the transaction
-  parseTransaction: OmitChainRpc<P, "parseTransaction"> = (txid) => {
+  async parseTransaction(txid: string): Promise<WormholeMessageId[]> {
     return this.platform.parseTransaction(this.chain, this.getRpc(), txid);
-  };
+  }
 
   // Send a transaction and wait for it to be confirmed
-  sendWait: OmitChainRpc<P, "sendWait"> = (stxns) => {
+  async sendWait(stxns: SignedTx): Promise<string[]> {
     return this.platform.sendWait(this.chain, this.getRpc(), stxns);
-  };
-
-  // Take a native address and convert it to a UniversalAddress
-  parseAddress: OmitChain<P, "parseAddress"> = (address) => {
-    return this.platform.parseAddress(this.chain, address);
-  };
+  }
 
+  //
   // protocols
-  getTokenBridge: OmitRpc<P, "getTokenBridge"> = async () => {
+  //
+
+  //
+  supportsTokenBridge = () => supportsTokenBridge<P>(this.platform);
+  async getTokenBridge(): Promise<TokenBridge<P>> {
+    if (!supportsTokenBridge<P>(this.platform))
+      throw new Error("Platform does not support TokenBridge");
+
     this.tokenBridge = this.tokenBridge
       ? this.tokenBridge
       : await this.platform.getTokenBridge(this.getRpc());
+
     return this.tokenBridge;
-  };
+  }
+
+  supportsAutomaticTokenBridge = () =>
+    supportsAutomaticTokenBridge<P>(this.platform);
+  async getAutomaticTokenBridge(): Promise<AutomaticTokenBridge<P>> {
+    if (!supportsAutomaticTokenBridge<P>(this.platform))
+      throw new Error("Platform does not support AutomaticTokenBridge");
 
-  getAutomaticTokenBridge: OmitRpc<P, "getAutomaticTokenBridge"> = async () => {
     this.autoTokenBridge = this.autoTokenBridge
       ? this.autoTokenBridge
       : await this.platform.getAutomaticTokenBridge(this.getRpc());
     return this.autoTokenBridge;
-  };
+  }
+
+  //
+  supportsCircleBridge = () => supportsCircleBridge<P>(this.platform);
+  async getCircleBridge(): Promise<CircleBridge<P>> {
+    if (!supportsCircleBridge<P>(this.platform))
+      throw new Error("Platform does not support CircleBridge");
 
-  getCircleBridge: OmitRpc<P, "getCircleBridge"> = async () => {
     this.circleBridge = this.circleBridge
       ? this.circleBridge
       : await this.platform.getCircleBridge(this.getRpc());
     return this.circleBridge;
-  };
-
-  getAutomaticCircleBridge: OmitRpc<P, "getAutomaticCircleBridge"> =
-    async () => {
-      this.autoCircleBridge = this.autoCircleBridge
-        ? this.autoCircleBridge
-        : await this.platform.getAutomaticCircleBridge(this.getRpc());
-      return this.autoCircleBridge;
-    };
+  }
+
+  //
+  supportsAutomaticCircleBridge = () =>
+    supportsAutomaticCircleBridge<P>(this.platform);
+
+  async getAutomaticCircleBridge(): Promise<AutomaticCircleBridge<P>> {
+    if (!supportsAutomaticCircleBridge<P>(this.platform))
+      throw new Error("Platform does not support AutomaticCircleBridge");
+
+    this.autoCircleBridge = this.autoCircleBridge
+      ? this.autoCircleBridge
+      : await this.platform.getAutomaticCircleBridge(this.getRpc());
+    return this.autoCircleBridge;
+  }
 }

package/src/index.ts

@@ -3,6 +3,7 @@ import "./payloads/connect";
 import "./payloads/relayer";
 import "./payloads/governance";
 import "./payloads/tokenBridge";
+import "./payloads/bam";
 
 export * from "./address";
 export * from "./universalAddress";

package/src/layout-items/chain.ts

@@ -9,7 +9,7 @@ import {
   ChainName,
 } from "@wormhole-foundation/sdk-base";
 
-const chainItemBase = { binary: "uint", size: 2 } as const;
+export const chainItemBase = { binary: "uint", size: 2 } as const;
 
 type AllowNull<T, B extends boolean> = B extends true ? T | null : T;
 

package/src/payloads/bam.ts

@@ -0,0 +1,66 @@
+import { Layout, UintLayoutItem, LengthPrefixedBytesLayoutItem, ShallowMapping } from "@wormhole-foundation/sdk-base";
+import { chainItem, amountItem } from "../layout-items";
+import { registerPayloadType } from "../vaa";
+
+const bamAddressItem = {
+  binary: "bytes",
+  lengthSize: 2
+} as const satisfies Omit<LengthPrefixedBytesLayoutItem, "name">;
+
+const customOrEmpty = (custom: any) => custom ? { custom } : {};
+
+const messageLayout = <
+  const T extends number,
+  const C extends Pick<LengthPrefixedBytesLayoutItem, "custom">,
+>(type: T, customContents?: C) => [
+  { name: "magicByte", binary: "uint", size: 1, custom: 0xbb, omit: true },
+  { name: "version", binary: "uint", size: 1, custom: 0, omit: true },
+  { name: "type", binary: "uint", size: 1, custom: type, omit: true },
+  { name: "index", binary: "uint", size: 8 },
+  { name: "targetChain", ...chainItem() },
+  { name: "targetAddress", ...bamAddressItem },
+  { name: "senderAddress", ...bamAddressItem },
+  { name: "contents", binary: "bytes", lengthSize: 2, ...customOrEmpty(customContents) },
+] as const satisfies Layout;
+
+const tokenMessageLayout = <
+  const C extends Pick<LengthPrefixedBytesLayoutItem, "custom">,
+  const B extends Pick<UintLayoutItem, "custom">,
+  const A extends Pick<UintLayoutItem, "custom">,
+>(
+  custom?: { contents?: C, bridge?: B, assetIdentifier?: A },
+) => [
+  ...messageLayout(1, custom?.contents),
+  { name: "bridge", binary: "uint", size: 1, ...customOrEmpty(custom?.bridge) },
+  { name: "assetIdentifier", binary: "uint", size: 2, ...customOrEmpty(custom?.assetIdentifier) },
+  { name: "amount", ...amountItem },
+] as const satisfies Layout;
+
+const extendedMessageLayout = <
+  const C extends Pick<LengthPrefixedBytesLayoutItem, "custom">,
+  const R extends Pick<LengthPrefixedBytesLayoutItem, "custom">,
+>(
+  custom?: { contents?: C, relaySignal?: R },
+) => [
+  ...messageLayout(2, custom?.contents),
+  { name: "relaySignal", binary: "bytes", lengthSize: 2, ...customOrEmpty(custom?.relaySignal) },
+] as const satisfies Layout;
+
+export const bamPayloads = [
+  [ "BamMessage", messageLayout(0) ],
+  [ "BamTokenMessage", tokenMessageLayout() ],
+  [ "BamExtendedMessage", extendedMessageLayout() ],
+] as const satisfies readonly (readonly [string, Layout])[];
+
+// factory registration:
+
+declare global {
+  namespace Wormhole {
+    interface PayloadLiteralToDescriptionMapping
+      extends ShallowMapping<typeof bamPayloads> {}
+  }
+}
+
+bamPayloads.forEach(([payloadLiteral, layout]) =>
+  registerPayloadType(payloadLiteral, layout)
+);

package/src/platform.ts

@@ -1,25 +1,20 @@
-import { PlatformName, ChainName } from "@wormhole-foundation/sdk-base";
+import {
+  PlatformName,
+  ChainName,
+  Network,
+} from "@wormhole-foundation/sdk-base";
 import { ChainContext } from "./chain";
 import { RpcConnection } from "./rpc";
 import { ChainsConfig, TokenId, TxHash } from "./types";
 import { WormholeMessageId } from "./attestation";
 import { SignedTx } from "./types";
-// protocols
-import { TokenBridge, AutomaticTokenBridge } from "./protocols/tokenBridge";
-import { CircleBridge, AutomaticCircleBridge } from "./protocols/cctp";
-import { WormholeCore } from "./protocols/core";
-import { NativeAddress } from "./address";
 
-export type PlatformCtr<P extends PlatformName> = {
-  _platform: P;
-  new (conf: ChainsConfig): Platform<P>;
-};
+export interface PlatformUtils<P extends PlatformName> {
+  nativeTokenId(chain: ChainName): TokenId;
 
-// Force passing RPC connection so we don't create a new one with every fn call
-export interface Platform<P extends PlatformName> {
-  readonly platform: P;
-  readonly conf: ChainsConfig;
-  getChain(chain: ChainName): ChainContext<P>;
+  isSupportedChain(chain: ChainName): boolean;
+
+  isNativeTokenId(chain: ChainName, tokenId: TokenId): boolean;
 
   // Utils for platform specific queries
   getDecimals(
@@ -33,7 +28,7 @@ export interface Platform<P extends PlatformName> {
     walletAddr: string,
     token: TokenId | "native"
   ): Promise<bigint | null>;
-  getRpc(chain: ChainName): RpcConnection<P>;
+  getCurrentBlock(rpc: RpcConnection<P>): Promise<number>;
 
   // Platform interaction utils
   sendWait(
@@ -41,21 +36,27 @@ export interface Platform<P extends PlatformName> {
     rpc: RpcConnection<P>,
     stxns: SignedTx[]
   ): Promise<TxHash[]>;
+
+  chainFromRpc(rpc: RpcConnection<P>): Promise<[Network, ChainName]>;
+}
+
+// Force passing RPC connection so we don't create a new one with every fn call
+export interface Platform<P extends PlatformName> extends PlatformUtils<P> {
+  readonly platform: P;
+  readonly conf: ChainsConfig;
+  readonly network: Network;
+
+  // update the config for this platform
+  setConfig(network: Network, _conf?: ChainsConfig): Platform<P>;
+
+  // Create a new Chain context object
+  getChain(chain: ChainName): ChainContext<P>;
+
+  getRpc(chain: ChainName): RpcConnection<P>;
+
   parseTransaction(
     chain: ChainName,
     rpc: RpcConnection<P>,
     txid: TxHash
   ): Promise<WormholeMessageId[]>;
-  parseAddress(chain: ChainName, address: string): NativeAddress<P>;
-
-  // protocol clients
-  getWormholeCore(rpc: RpcConnection<P>): Promise<WormholeCore<P>>;
-  getTokenBridge(rpc: RpcConnection<P>): Promise<TokenBridge<P>>;
-  getAutomaticTokenBridge(
-    rpc: RpcConnection<P>
-  ): Promise<AutomaticTokenBridge<P>>;
-  getAutomaticCircleBridge(
-    rpc: RpcConnection<P>
-  ): Promise<AutomaticCircleBridge<P>>;
-  getCircleBridge(rpc: RpcConnection<P>): Promise<CircleBridge<P>>;
 }

package/src/protocols/cctp.ts

@@ -4,9 +4,35 @@ import { CircleMessageId } from "../attestation";
 import { UnsignedTransaction } from "../unsignedTransaction";
 import { TokenId, TxHash } from "../types";
 import "../payloads/connect";
+import { RpcConnection } from "../rpc";
 
 // https://github.com/circlefin/evm-cctp-contracts
 
+export interface SupportsCircleBridge<P extends PlatformName> {
+  getCircleBridge(rpc: RpcConnection<P>): Promise<CircleBridge<P>>;
+}
+
+export function supportsCircleBridge<P extends PlatformName>(
+  thing: SupportsCircleBridge<P> | any
+): thing is SupportsCircleBridge<P> {
+  return typeof (<SupportsCircleBridge<P>>thing).getCircleBridge === "function";
+}
+
+export interface SupportsAutomaticCircleBridge<P extends PlatformName> {
+  getAutomaticCircleBridge(
+    rpc: RpcConnection<P>
+  ): Promise<AutomaticCircleBridge<P>>;
+}
+
+export function supportsAutomaticCircleBridge<P extends PlatformName>(
+  thing: SupportsAutomaticCircleBridge<P> | any
+): thing is SupportsAutomaticCircleBridge<P> {
+  return (
+    typeof (<SupportsAutomaticCircleBridge<P>>thing)
+      .getAutomaticCircleBridge === "function"
+  );
+}
+
 export type CircleTransferDetails = {
   txid: TxHash;
   token: TokenId;
@@ -29,6 +55,7 @@ export interface AutomaticCircleBridge<P extends PlatformName> {
     amount: bigint,
     nativeGas?: bigint
   ): AsyncGenerator<UnsignedTransaction>;
+  // TODO: events
 }
 
 export interface CircleBridge<P extends PlatformName> {

package/src/protocols/core.ts

@@ -1,10 +1,23 @@
 import { PlatformName } from "@wormhole-foundation/sdk-base";
 import { UniversalOrNative } from "../address";
 import { UnsignedTransaction } from "../unsignedTransaction";
+import { RpcConnection } from "../rpc";
+
+export interface SupportsWormholeCore<P extends PlatformName> {
+  getWormholeCore(rpc: RpcConnection<P>): Promise<WormholeCore<P>>;
+}
+
+export function supportsWormholeCore<P extends PlatformName>(
+  thing: SupportsWormholeCore<P> | any
+): thing is SupportsWormholeCore<P> {
+  return typeof (<SupportsWormholeCore<P>>thing).getWormholeCore === "function";
+}
 
 export interface WormholeCore<P extends PlatformName> {
   publishMessage(
     sender: UniversalOrNative<P>,
     message: string | Uint8Array
   ): AsyncGenerator<UnsignedTransaction>;
+  // TODO: parseTransactionDetails
+  // TODO: events?
 }

package/src/protocols/tokenBridge.ts

@@ -4,10 +4,36 @@ import { TokenId } from "../types";
 import { VAA } from "../vaa";
 import { UnsignedTransaction } from "../unsignedTransaction";
 import "../payloads/tokenBridge";
+import { RpcConnection } from "../rpc";
 
 export const ErrNotWrapped = (token: string) =>
   new Error(`Token ${token} is not a wrapped asset`);
 
+export interface SupportsTokenBridge<P extends PlatformName> {
+  getTokenBridge(rpc: RpcConnection<P>): Promise<TokenBridge<P>>;
+}
+
+export function supportsTokenBridge<P extends PlatformName>(
+  thing: SupportsTokenBridge<P> | any
+): thing is SupportsTokenBridge<P> {
+  return typeof (<SupportsTokenBridge<P>>thing).getTokenBridge === "function";
+}
+
+export interface SupportsAutomaticTokenBridge<P extends PlatformName> {
+  getAutomaticTokenBridge(
+    rpc: RpcConnection<P>
+  ): Promise<AutomaticTokenBridge<P>>;
+}
+
+export function supportsAutomaticTokenBridge<P extends PlatformName>(
+  thing: SupportsAutomaticTokenBridge<P> | any
+): thing is SupportsAutomaticTokenBridge<P> {
+  return (
+    typeof (<SupportsAutomaticTokenBridge<P>>thing).getAutomaticTokenBridge ===
+    "function"
+  );
+}
+
 export interface TokenBridge<P extends PlatformName> {
   // checks a native address to see if its a wrapped version
   isWrappedAsset(nativeAddress: UniversalOrNative<P>): Promise<boolean>;
@@ -21,6 +47,7 @@ export interface TokenBridge<P extends PlatformName> {
   // Returns the address of the native version of this asset
   getWrappedAsset(foreignToken: TokenId): Promise<NativeAddress<P>>;
 
+  // TODO: preview (receive amount, fees, gas estimates, estimated blocks/time)
   isTransferCompleted(
     vaa: VAA<"Transfer"> | VAA<"TransferWithPayload">
   ): Promise<boolean>;
@@ -47,6 +74,7 @@ export interface TokenBridge<P extends PlatformName> {
     vaa: VAA<"Transfer"> | VAA<"TransferWithPayload">,
     unwrapNative?: boolean //default: true
   ): AsyncGenerator<UnsignedTransaction>;
+  // TODO: parse transaction
 }
 
 export interface AutomaticTokenBridge<P extends PlatformName> {
@@ -67,4 +95,19 @@ export interface AutomaticTokenBridge<P extends PlatformName> {
     recipient: ChainAddress,
     token: TokenId | "native"
   ): Promise<bigint>;
+  // the amount of native tokens a user would receive by swapping x amount of sending tokens
+  // nativeTokenAmount(
+  //   destChain: ChainName | ChainId,
+  //   token: TokenId,
+  //   amount: BigNumber,
+  //   walletAddress: string,
+  // ): Promise<BigNumber>;
+
+  // the maximum amount of sending tokens that can be swapped for native tokens
+  // maxSwapAmount(
+  //   destChain: ChainName | ChainId,
+  //   token: TokenId,
+  //   walletAddress: string,
+  // ): Promise<BigNumber>;
+  // TODO: events (Redeem, Swap)
 }

package/src/rpc.ts

@@ -1,16 +1,2 @@
 import { PlatformName } from "@wormhole-foundation/sdk-base";
-
-export interface EvmRpc {
-  broadcastTransaction(stxns: string): Promise<any>;
-  getBalance(address: string): Promise<bigint>;
-}
-export interface SolRpc {
-  getBalance(publicKey: any, commitmentOrConfig: any): Promise<number>;
-  getParsedAccountInfo(publickKey: any): Promise<any>;
-}
-
-export type RpcConnection<P extends PlatformName> = P extends "Evm"
-  ? EvmRpc
-  : P extends "Solana"
-  ? SolRpc
-  : never;
+export type RpcConnection<P extends PlatformName> = any;

package/src/testing/mocks/chain.ts

@@ -1,18 +1,27 @@
-import { ChainName, PlatformName } from "@wormhole-foundation/sdk-base";
-import { RpcConnection, ChainContext, Platform } from "../..";
+import {
+  ChainName,
+  Network,
+  PlatformName,
+} from "@wormhole-foundation/sdk-base";
+import { ChainContext, Platform } from "../..";
+import { mockPlatformFactory } from "./platform";
 
 export function chainFactory<P extends PlatformName>(
+  network: Network,
   p: Platform<P>,
   chain: ChainName
 ): ChainContext<P> {
-  return new MockChain<P>(p, chain);
+  return new MockChain<P>(network, p.platform, chain);
 }
 
 export class MockChain<P extends PlatformName> extends ChainContext<P> {
-  private rpc?: RpcConnection<P>;
-
-  getRpc(): RpcConnection<P> {
-    this.rpc = this.rpc ? this.rpc : this.platform.getRpc(this.chain);
-    return this.rpc!;
+  readonly platform: Platform<P>;
+  constructor(
+    network: Network,
+    platform: PlatformName,
+    readonly chain: ChainName
+  ) {
+    super(chain);
+    this.platform = mockPlatformFactory<P>(network, platform as P, {});
   }
 }