diff --git a/.snippets/code/build/build-apps/wormhole-sdk/addresses.ts b/.snippets/code/build/build-apps/wormhole-sdk/addresses.ts
new file mode 100644
index 000000000..193d362b2
--- /dev/null
+++ b/.snippets/code/build/build-apps/wormhole-sdk/addresses.ts
@@ -0,0 +1,19 @@
+// It's possible to convert a string address to its Native address
+const ethAddr: NativeAddress<'Evm'> = toNative('Ethereum', '0xbeef...');
+
+// A common type in the SDK is the `ChainAddress` which provides
+// the additional context of the `Chain` this address is relevant for
+const senderAddress: ChainAddress = Wormhole.chainAddress(
+  'Ethereum',
+  '0xbeef...'
+);
+const receiverAddress: ChainAddress = Wormhole.chainAddress(
+  'Solana',
+  'Sol1111...'
+);
+
+// Convert the ChainAddress back to its canonical string address format
+const strAddress = Wormhole.canonicalAddress(senderAddress); // => '0xbeef...'
+
+// Or if the ethAddr above is for an emitter and you need the UniversalAddress
+const emitterAddr = ethAddr.toUniversalAddress().toString();
\ No newline at end of file
diff --git a/.snippets/code/build/build-apps/wormhole-sdk/cctp.ts b/.snippets/code/build/build-apps/wormhole-sdk/cctp.ts
new file mode 100644
index 000000000..cdb759122
--- /dev/null
+++ b/.snippets/code/build/build-apps/wormhole-sdk/cctp.ts
@@ -0,0 +1,127 @@
+import {
+  Chain,
+  CircleTransfer,
+  Network,
+  Signer,
+  TransactionId,
+  TransferState,
+  Wormhole,
+  amount,
+  wormhole,
+} from '@wormhole-foundation/sdk';
+import evm from '@wormhole-foundation/sdk/evm';
+import solana from '@wormhole-foundation/sdk/solana';
+import { SignerStuff, getSigner, waitForRelay } from './helpers/index.js';
+
+/*
+Notes:
+Only a subset of chains are supported by Circle for CCTP, see core/base/src/constants/circle.ts for currently supported chains
+
+AutoRelayer takes a 0.1 USDC fee when transferring to any chain beside Goerli, which is 1 USDC
+*/
+//
+
+(async function () {
+  // Init the Wormhole object, passing in the config for which network
+  // to use (e.g. Mainnet/Testnet) and what Platforms to support
+  const wh = await wormhole('Testnet', [evm, solana]);
+
+  // Grab chain Contexts
+  const sendChain = wh.getChain('Avalanche');
+  const rcvChain = wh.getChain('Solana');
+
+  // Get signer from local key but anything that implements
+  // Signer interface (e.g. wrapper around web wallet) should work
+  const source = await getSigner(sendChain);
+  const destination = await getSigner(rcvChain);
+
+  // 6 decimals for USDC (except for BSC, so check decimals before using this)
+  const amt = amount.units(amount.parse('0.2', 6));
+
+  // Choose whether or not to have the attestation delivered for you
+  const automatic = false;
+
+  // If the transfer is requested to be automatic, you can also request that
+  // during redemption, the receiver gets some amount of native gas transferred to them
+  // so that they may pay for subsequent transactions
+  // The amount specified here is denominated in the token being transferred (USDC here)
+  const nativeGas = automatic ? amount.units(amount.parse('0.0', 6)) : 0n;
+
+  await cctpTransfer(wh, source, destination, {
+    amount: amt,
+    automatic,
+    nativeGas,
+  });
+
+})();
+
+async function cctpTransfer<N extends Network>(
+  wh: Wormhole<N>,
+  src: SignerStuff<N, any>,
+  dst: SignerStuff<N, any>,
+  req: {
+    amount: bigint;
+    automatic: boolean;
+    nativeGas?: bigint;
+  }
+) {
+
+  const xfer = await wh.circleTransfer(
+    // Amount as bigint (base units)
+    req.amount,
+    // Sender chain/address
+    src.address,
+    // Receiver chain/address
+    dst.address,
+    // Automatic delivery boolean
+    req.automatic,
+    // Payload to be sent with the transfer
+    undefined,
+    // If automatic, native gas can be requested to be sent to the receiver
+    req.nativeGas
+  );
+
+  // Note, if the transfer is requested to be Automatic, a fee for performing the relay
+  // will be present in the quote. The fee comes out of the amount requested to be sent.
+  // If the user wants to receive 1.0 on the destination, the amount to send should be 1.0 + fee.
+  // The same applies for native gas dropoff
+  const quote = await CircleTransfer.quoteTransfer(
+    src.chain,
+    dst.chain,
+    xfer.transfer
+  );
+  console.log('Quote', quote);
+
+  console.log('Starting Transfer');
+  const srcTxids = await xfer.initiateTransfer(src.signer);
+  console.log(`Started Transfer: `, srcTxids);
+
+  if (req.automatic) {
+    const relayStatus = await waitForRelay(srcTxids[srcTxids.length - 1]!);
+    console.log(`Finished relay: `, relayStatus);
+    return;
+  }
+
+  console.log('Waiting for Attestation');
+  const attestIds = await xfer.fetchAttestation(60_000);
+  console.log(`Got Attestation: `, attestIds);
+
+  console.log('Completing Transfer');
+  const dstTxids = await xfer.completeTransfer(dst.signer);
+  console.log(`Completed Transfer: `, dstTxids);
+}
+
+export async function completeTransfer(
+  wh: Wormhole<Network>,
+  txid: TransactionId,
+  signer: Signer
+): Promise<void> {
+
+  const xfer = await CircleTransfer.from(wh, txid);
+
+  const attestIds = await xfer.fetchAttestation(60 * 60 * 1000);
+  console.log('Got attestation: ', attestIds);
+
+  const dstTxIds = await xfer.completeTransfer(signer);
+  console.log('Completed transfer: ', dstTxIds);
+}
diff --git a/.snippets/code/build/build-apps/wormhole-sdk/config-override.ts b/.snippets/code/build/build-apps/wormhole-sdk/config-override.ts
new file mode 100644
index 000000000..b2168a9bc
--- /dev/null
+++ b/.snippets/code/build/build-apps/wormhole-sdk/config-override.ts
@@ -0,0 +1,10 @@
+const wh = await wormhole('Testnet', [solana], {
+  chains: {
+    Solana: {
+      contracts: {
+        coreBridge: '11111111111111111111111111111',
+      },
+      rpc: 'https://api.devnet.solana.com',
+    },
+  },
+});
\ No newline at end of file
diff --git a/.snippets/code/build/build-apps/wormhole-sdk/config.ts b/.snippets/code/build/build-apps/wormhole-sdk/config.ts
new file mode 100644
index 000000000..c688dc139
--- /dev/null
+++ b/.snippets/code/build/build-apps/wormhole-sdk/config.ts
@@ -0,0 +1,15 @@
+import { wormhole } from '@wormhole-foundation/sdk';
+import solana from '@wormhole-foundation/sdk/solana';
+(async function () {
+  const wh = await wormhole('Testnet', [solana], {
+    chains: {
+      Solana: {
+        contracts: {
+          coreBridge: '11111111111111111111111111111',
+        },
+        rpc: 'https://api.devnet.solana.com',
+      },
+    },
+  });
+  console.log(wh.config.chains.Solana);
+})();
diff --git a/.snippets/code/build/build-apps/wormhole-sdk/cosmos.ts b/.snippets/code/build/build-apps/wormhole-sdk/cosmos.ts
new file mode 100644
index 000000000..09702f4e4
--- /dev/null
+++ b/.snippets/code/build/build-apps/wormhole-sdk/cosmos.ts
@@ -0,0 +1,210 @@
+import {
+  Chain,
+  GatewayTransfer,
+  GatewayTransferDetails,
+  Network,
+  TokenId,
+  Wormhole,
+  amount,
+  wormhole,
+} from '@wormhole-foundation/sdk';
+
+// Import the platform specific packages
+
+import cosmwasm from '@wormhole-foundation/sdk/cosmwasm';
+import evm from '@wormhole-foundation/sdk/evm';
+import solana from '@wormhole-foundation/sdk/solana';
+import { SignerStuff, getSigner } from './helpers/index.js';
+
+// We're going to transfer into, around, and out of the Cosmos ecosystem
+// First on Avalanche, transparently through gateway and over IBC to Cosmoshub
+// Then over IBC, transparently through gateway and over IBC to Osmosis
+// Finally out of Osmosis, transparently through gateway, out to Avalanche
+
+// eg:
+//  Avalanche[avax] => {Gateway ->}Osmosis[gateway/wrapped avax]
+//  Osmosis[gateway/wrapped avax] -> {Gateway ->} Cosmoshub[gateway/wrapped avax]
+//  Cosmoshub[gateway/wrapped avax] -> {Gateway} => Avalanch[avax]
+
+// Key:
+//   => : Regular contract call
+//   -> : IBC Transfer
+//   {*}: Transparently handled by Gateway
+
+(async function () {
+  // Init Wormhole object, passing config for which network
+  // to use (e.g. Mainnet/Testnet) and what Platforms to support
+  const wh = await wormhole('Mainnet', [evm, solana, cosmwasm]);
+  // Pick up where you left off by updating the txids as you go
+  let fakeIt = false;
+
+  // Grab chain Contexts for each leg of our journey
+  const external = wh.getChain('Solana');
+  const cosmos1 = wh.getChain('Dymension');
+  const cosmos2 = wh.getChain('Injective');
+
+  // Get signer from local key but anything that implements
+  // Signer interface (e.g. wrapper around web wallet) should work
+  const leg1 = await getSigner(external);
+  const leg2 = await getSigner(cosmos1);
+  const leg3 = await getSigner(cosmos2);
+
+  // We'll use the native token on the source chain
+  const token: TokenId = Wormhole.tokenId(external.chain, 'native');
+  const amt = amount.units(
+    amount.parse('0.001', external.config.nativeTokenDecimals)
+  );
+
+  // Transfer native token from source chain, through gateway, to a cosmos chain
+  let route1 = fakeIt
+    ? await GatewayTransfer.from(
+        wh,
+        {
+          chain: external.chain,
+          txid: '5y2BnJ1Nwqe4m6KTSrry5Ni88xqVrqo4jdbuNwAPDuXEonQRVLbALf7abViwucKKr8U8cDfJtDmqnuRAAC6i6wtb',
+        },
+        600_000
+      )
+    : await transferIntoCosmos(wh, token, amt, leg1, leg2);
+  console.log('Route 1 (External => Cosmos)', route1);
+
+  // Lookup the Gateway representation of the wrappd token
+  const { denom } = route1.ibcTransfers![0]!.data;
+  const cosmosTokenAddress = Wormhole.parseAddress('Wormchain', denom);
+
+  // Transfer Gateway factory tokens over IBC through gateway to another Cosmos chain
+  let route2 = fakeIt
+    ? await GatewayTransfer.from(
+        wh,
+        {
+          chain: cosmos1.chain,
+          txid: '3014CABA727C8A1BFCBD282095C771ACBAB3B13CC595B702ABFD3A4502315FBD',
+        },
+        600_000
+      )
+    : await transferBetweenCosmos(
+        wh,
+        { chain: cosmos1.chain, address: cosmosTokenAddress },
+        1000n,
+        leg2,
+        leg3
+      );
+  console.log('Route 2 (Cosmos -> Cosmos): ', route2);
+
+  // Transfer Gateway factory token through gateway back to source chain
+  let route3 = fakeIt
+    ? await GatewayTransfer.from(
+        wh,
+        {
+          chain: cosmos2.chain,
+          txid: 'BEDD0CE2FEA8FF5DF81FCA5142E72745E154F87D496CDA147FC4D5D46A7C7D81',
+        },
+        600_000
+      )
+    : await transferOutOfCosmos(
+        wh,
+        { chain: cosmos2.chain, address: cosmosTokenAddress },
+        1000n,
+        leg3,
+        leg1
+      );
+  console.log('Route 3 (Cosmos => External): ', route3);
+})();
+
+async function transferIntoCosmos(
+  wh: Wormhole<Network>,
+  token: TokenId,
+  amount: bigint,
+  src: SignerStuff<Network, Chain>,
+  dst: SignerStuff<Network, Chain>
+): Promise<GatewayTransfer<Network>> {
+  console.log(
+    `Beginning transfer into Cosmos from ${
+      src.chain.chain
+    }:${src.address.address.toString()} to ${
+      dst.chain.chain
+    }:${dst.address.address.toString()}`
+  );
+
+  const xfer = await GatewayTransfer.from(wh, {
+    token: token,
+    amount: amount,
+    from: src.address,
+    to: dst.address,
+  } as GatewayTransferDetails);
+  console.log('Created GatewayTransfer: ', xfer.transfer);
+
+  const srcTxIds = await xfer.initiateTransfer(src.signer);
+  console.log('Started transfer on source chain', srcTxIds);
+
+  const attests = await xfer.fetchAttestation(600_000);
+  console.log('Got Attestations', attests);
+  return xfer;
+}
+
+async function transferBetweenCosmos<N extends Network>(
+  wh: Wormhole<N>,
+  token: TokenId,
+  amount: bigint,
+  src: SignerStuff<N, Chain>,
+  dst: SignerStuff<N, Chain>
+): Promise<GatewayTransfer<N>> {
+  console.log(
+    `Beginning transfer within cosmos from ${
+      src.chain.chain
+    }:${src.address.address.toString()} to ${
+      dst.chain.chain
+    }:${dst.address.address.toString()}`
+  );
+
+  const xfer = await GatewayTransfer.from(wh, {
+    token: token,
+    amount: amount,
+    from: src.address,
+    to: dst.address,
+  } as GatewayTransferDetails);
+  console.log('Created GatewayTransfer: ', xfer.transfer);
+
+  const srcTxIds = await xfer.initiateTransfer(src.signer);
+  console.log('Started transfer on source chain', srcTxIds);
+
+  const attests = await xfer.fetchAttestation(60_000);
+  console.log('Got attests: ', attests);
+
+  return xfer;
+}
+
+async function transferOutOfCosmos<N extends Network>(
+  wh: Wormhole<N>,
+  token: TokenId,
+  amount: bigint,
+  src: SignerStuff<N, Chain>,
+  dst: SignerStuff<N, Chain>
+): Promise<GatewayTransfer<N>> {
+  console.log(
+    `Beginning transfer out of cosmos from ${
+      src.chain.chain
+    }:${src.address.address.toString()} to ${
+      dst.chain.chain
+    }:${dst.address.address.toString()}`
+  );
+
+  const xfer = await GatewayTransfer.from(wh, {
+    token: token,
+    amount: amount,
+    from: src.address,
+    to: dst.address,
+  } as GatewayTransferDetails);
+  console.log('Created GatewayTransfer: ', xfer.transfer);
+  const srcTxIds = await xfer.initiateTransfer(src.signer);
+  console.log('Started transfer on source chain', srcTxIds);
+
+  const attests = await xfer.fetchAttestation(600_000);
+  console.log('Got attests', attests);
+
+  // Since we're leaving cosmos, this is required to complete the transfer
+  const dstTxIds = await xfer.completeTransfer(dst.signer);
+  console.log('Completed transfer on destination chain', dstTxIds);
+
+  return xfer;
+}
diff --git a/.snippets/code/build/build-apps/wormhole-sdk/example-core-bridge.ts b/.snippets/code/build/build-apps/wormhole-sdk/example-core-bridge.ts
new file mode 100644
index 000000000..72c065062
--- /dev/null
+++ b/.snippets/code/build/build-apps/wormhole-sdk/example-core-bridge.ts
@@ -0,0 +1,47 @@
+import { encoding, signSendWait, wormhole } from '@wormhole-foundation/sdk';
+import { getSigner } from './helpers/index.js';
+import solana from '@wormhole-foundation/sdk/solana';
+import evm from '@wormhole-foundation/sdk/evm';
+
+(async function () {
+  const wh = await wormhole('Testnet', [solana, evm]);
+
+  const chain = wh.getChain('Avalanche');
+  const { signer, address } = await getSigner(chain);
+
+  // Get a reference to the core messaging bridge
+  const coreBridge = await chain.getWormholeCore();
+
+  // Generate transactions, sign and send them
+  const publishTxs = coreBridge.publishMessage(
+    // Address of sender (emitter in VAA)
+    address.address,
+    // Message to send (payload in VAA)
+    encoding.bytes.encode('lol'),
+    // Nonce (user defined, no requirement for a specific value, useful to provide a unique identifier for the message)
+    0,
+    // ConsistencyLevel (ie finality of the message, see wormhole docs for more)
+    0
+  );
+  // Send the transaction(s) to publish the message
+  const txids = await signSendWait(chain, publishTxs, signer);
+
+  // Take the last txid in case multiple were sent
+  // The last one should be the one containing the relevant
+  // event or log info
+  const txid = txids[txids.length - 1];
+
+  // Grab the wormhole message id from the transaction logs or storage
+  const [whm] = await chain.parseTransaction(txid!.txid);
+
+  // Wait for the vaa to be signed and available with a timeout
+  const vaa = await wh.getVaa(whm!, 'Uint8Array', 60_000);
+  console.log(vaa);
+
+  // Note: calling verifyMessage manually is typically not a useful thing to do
+  // As the VAA is typically submitted to the counterpart contract for
+  // A given protocol and the counterpart contract will verify the VAA
+  // This is simply for demo purposes
+  const verifyTxs = coreBridge.verifyMessage(address.address, vaa!);
+  console.log(await signSendWait(chain, verifyTxs, signer));
+})();
diff --git a/.snippets/code/build/build-apps/wormhole-sdk/get-chain.ts b/.snippets/code/build/build-apps/wormhole-sdk/get-chain.ts
new file mode 100644
index 000000000..3ff5d59ae
--- /dev/null
+++ b/.snippets/code/build/build-apps/wormhole-sdk/get-chain.ts
@@ -0,0 +1,5 @@
+const srcChain = wh.getChain(senderAddress.chain);
+const dstChain = wh.getChain(receiverAddress.chain);
+
+const tb = await srcChain.getTokenBridge(); // => TokenBridge<'Evm'>
+srcChain.getRpcClient(); // => RpcClient<'Evm'>
\ No newline at end of file
diff --git a/.snippets/code/build/build-apps/wormhole-sdk/get-vaa.ts b/.snippets/code/build/build-apps/wormhole-sdk/get-vaa.ts
new file mode 100644
index 000000000..9d27eb69c
--- /dev/null
+++ b/.snippets/code/build/build-apps/wormhole-sdk/get-vaa.ts
@@ -0,0 +1,77 @@
+import { wormhole } from '@wormhole-foundation/sdk';
+
+import { Wormhole, amount, signSendWait } from '@wormhole-foundation/sdk';
+import algorand from '@wormhole-foundation/sdk/algorand';
+import aptos from '@wormhole-foundation/sdk/aptos';
+import cosmwasm from '@wormhole-foundation/sdk/cosmwasm';
+import evm from '@wormhole-foundation/sdk/evm';
+import solana from '@wormhole-foundation/sdk/solana';
+import sui from '@wormhole-foundation/sdk/sui';
+import { getSigner } from './helpers/index.js';
+
+(async function () {
+  const wh = await wormhole('Testnet', [
+    evm,
+    solana,
+    aptos,
+    algorand,
+    cosmwasm,
+    sui,
+  ]);
+
+  const ctx = wh.getChain('Solana');
+
+  const rcv = wh.getChain('Algorand');
+
+  const sender = await getSigner(ctx);
+  const receiver = await getSigner(rcv);
+
+  // Get a Token Bridge contract client on the source
+  const sndTb = await ctx.getTokenBridge();
+
+  // Send the native token of the source chain
+  const tokenId = Wormhole.tokenId(ctx.chain, 'native');
+
+  // Bigint amount using `amount` module
+  const amt = amount.units(amount.parse('0.1', ctx.config.nativeTokenDecimals));
+
+  // Create a transaction stream for transfers
+  const transfer = sndTb.transfer(
+    sender.address.address,
+    receiver.address,
+    tokenId.address,
+    amt
+  );
+
+  // Sign and send the transaction
+  const txids = await signSendWait(ctx, transfer, sender.signer);
+  console.log('Sent: ', txids);
+
+  // Get the Wormhole message ID from the transaction
+  const [whm] = await ctx.parseTransaction(txids[txids.length - 1]!.txid);
+  console.log('Wormhole Messages: ', whm);
+
+  const vaa = await wh.getVaa(
+    // Wormhole Message ID
+    whm!,
+    // Protocol:Payload name to use for decoding the VAA payload
+    'TokenBridge:Transfer',
+    // Timeout in milliseconds, depending on the chain and network, the VAA may take some time to be available
+    60_000
+  );
+
+  // Now get the token bridge on the redeem side
+  const rcvTb = await rcv.getTokenBridge();
+
+  // Create a transaction stream for redeeming
+  const redeem = rcvTb.redeem(receiver.address.address, vaa!);
+
+  // Sign and send the transaction
+  const rcvTxids = await signSendWait(rcv, redeem, receiver.signer);
+  console.log('Sent: ', rcvTxids);
+
+  // Now check if the transfer is completed according to
+  // the destination token bridge
+  const finished = await rcvTb.isTransferCompleted(vaa!);
+  console.log('Transfer completed: ', finished);
+})();
diff --git a/.snippets/code/build/build-apps/wormhole-sdk/router.ts b/.snippets/code/build/build-apps/wormhole-sdk/router.ts
new file mode 100644
index 000000000..c5535e689
--- /dev/null
+++ b/.snippets/code/build/build-apps/wormhole-sdk/router.ts
@@ -0,0 +1,114 @@
+import {
+  Wormhole,
+  canonicalAddress,
+  routes,
+  wormhole,
+} from '@wormhole-foundation/sdk';
+
+import evm from '@wormhole-foundation/sdk/evm';
+import solana from '@wormhole-foundation/sdk/solana';
+import { getSigner } from './helpers/index.js';
+
+(async function () {
+  // Setup
+  const wh = await wormhole('Testnet', [evm, solana]);
+
+  // Get chain contexts
+  const sendChain = wh.getChain('Avalanche');
+  const destChain = wh.getChain('Solana');
+
+  // Get signers from local config
+  const sender = await getSigner(sendChain);
+  const receiver = await getSigner(destChain);
+
+  // Create new resolver, passing the set of routes to consider
+  const resolver = wh.resolver([
+    routes.TokenBridgeRoute, // manual token bridge
+    routes.AutomaticTokenBridgeRoute, // automatic token bridge
+    routes.CCTPRoute, // manual CCTP
+    routes.AutomaticCCTPRoute, // automatic CCTP
+    routes.AutomaticPorticoRoute, // Native eth transfers
+  ]);
+
+  // What tokens are available on the source chain?
+  const srcTokens = await resolver.supportedSourceTokens(sendChain);
+  console.log(
+    'Allowed source tokens: ',
+    srcTokens.map((t) => canonicalAddress(t))
+  );
+
+  const sendToken = Wormhole.tokenId(sendChain.chain, 'native');
+
+  // Given the send token, what can we possibly get on the destination chain?
+  const destTokens = await resolver.supportedDestinationTokens(
+    sendToken,
+    sendChain,
+    destChain
+  );
+  console.log(
+    'For the given source token and routes configured, the following tokens may be receivable: ',
+    destTokens.map((t) => canonicalAddress(t))
+  );
+  // Grab the first one for the example
+  const destinationToken = destTokens[0]!;
+
+  // Creating a transfer request fetches token details
+  // Since all routes will need to know about the tokens
+  const tr = await routes.RouteTransferRequest.create(wh, {
+    source: sendToken,
+    destination: destinationToken,
+  });
+
+  // Resolve the transfer request to a set of routes that can perform it
+  const foundRoutes = await resolver.findRoutes(tr);
+  console.log(
+    'For the transfer parameters, we found these routes: ',
+    foundRoutes
+  );
+
+  const bestRoute = foundRoutes[0]!;
+  console.log('Selected: ', bestRoute);
+
+  console.log(
+    'This route offers the following default options',
+    bestRoute.getDefaultOptions()
+  );
+
+  // Specify the amount as a decimal string
+  const amt = '0.001';
+  // Create the transfer params for this request
+  const transferParams = { amount: amt, options: { nativeGas: 0 } };
+
+  // Validate the transfer params passed, this returns a new type of ValidatedTransferParams
+  // which (believe it or not) is a validated version of the input params
+  // This new var must be passed to the next step, quote
+  const validated = await bestRoute.validate(tr, transferParams);
+  if (!validated.valid) throw validated.error;
+  console.log('Validated parameters: ', validated.params);
+
+  // Get a quote for the transfer, this too returns a new type that must
+  // be passed to the next step, execute (if you like the quote)
+  const quote = await bestRoute.quote(tr, validated.params);
+  if (!quote.success) throw quote.error;
+  console.log('Best route quote: ', quote);
+
+  // If you're sure you want to do this, set this to true
+  const imSure = false;
+  if (imSure) {
+    // Now the transfer may be initiated
+    // A receipt will be returned, guess what you gotta do with that?
+    const receipt = await bestRoute.initiate(
+      tr,
+      sender.signer,
+      quote,
+      receiver.address
+    );
+    console.log('Initiated transfer with receipt: ', receipt);
+
+    // Kick off a wait log, if there is an opportunity to complete, this function will do it
+    // See the implementation for how this works
+    await routes.checkAndCompleteTransfer(bestRoute, receipt, receiver.signer);
+  } else {
+    console.log('Not initiating transfer (set `imSure` to true to do so)');
+  }
+})();
diff --git a/.snippets/code/build/build-apps/wormhole-sdk/signers.ts b/.snippets/code/build/build-apps/wormhole-sdk/signers.ts
new file mode 100644
index 000000000..0cd982884
--- /dev/null
+++ b/.snippets/code/build/build-apps/wormhole-sdk/signers.ts
@@ -0,0 +1,20 @@
+export type Signer = SignOnlySigner | SignAndSendSigner;
+
+export interface SignOnlySigner {
+  chain(): ChainName;
+  address(): string;
+  // Accept an array of unsigned transactions and return
+  // an array of signed and serialized transactions.
+  // The transactions may be inspected or altered before
+  // signing.
+  sign(tx: UnsignedTransaction[]): Promise<SignedTx[]>;
+}
+
+export interface SignAndSendSigner {
+  chain(): ChainName;
+  address(): string;
+  // Accept an array of unsigned transactions and return
+  // an array of transaction ids in the same order as the
+  // unsignedTransactions array.
+  signAndSend(tx: UnsignedTransaction[]): Promise<TxHash[]>;
+}
\ No newline at end of file
diff --git a/.snippets/code/build/build-apps/wormhole-sdk/token-bridge-snippet.ts b/.snippets/code/build/build-apps/wormhole-sdk/token-bridge-snippet.ts
new file mode 100644
index 000000000..34febd240
--- /dev/null
+++ b/.snippets/code/build/build-apps/wormhole-sdk/token-bridge-snippet.ts
@@ -0,0 +1,7 @@
+import { signSendWait } from '@wormhole-foundation/sdk';
+
+const tb = await srcChain.getTokenBridge(); 
+
+const token = '0xdeadbeef...';
+const txGenerator = tb.createAttestation(token); 
+const txids = await signSendWait(srcChain, txGenerator, src.signer);
\ No newline at end of file
diff --git a/.snippets/code/build/build-apps/wormhole-sdk/token-bridge.ts b/.snippets/code/build/build-apps/wormhole-sdk/token-bridge.ts
new file mode 100644
index 000000000..c12ab3766
--- /dev/null
+++ b/.snippets/code/build/build-apps/wormhole-sdk/token-bridge.ts
@@ -0,0 +1,171 @@
+import {
+  Chain,
+  Network,
+  TokenId,
+  TokenTransfer,
+  Wormhole,
+  amount,
+  isTokenId,
+  wormhole,
+} from '@wormhole-foundation/sdk';
+
+import evm from '@wormhole-foundation/sdk/evm';
+import solana from '@wormhole-foundation/sdk/solana';
+import { SignerStuff, getSigner, waitLog } from './helpers/index.js';
+
+(async function () {
+  // Init Wormhole object, passing config for which network
+  // to use (e.g. Mainnet/Testnet) and what Platforms to support
+  const wh = await wormhole('Testnet', [evm, solana]);
+
+  // Grab chain Contexts -- these hold a reference to a cached rpc client
+  const sendChain = wh.getChain('Avalanche');
+  const rcvChain = wh.getChain('Solana');
+
+  // Shortcut to allow transferring native gas token
+  const token = Wormhole.tokenId(sendChain.chain, 'native');
+
+  // A TokenId is just a `{chain, address}` pair and an alias for ChainAddress
+  // The `address` field must be a parsed address.
+  // You can get a TokenId (or ChainAddress) prepared for you
+  // by calling the static `chainAddress` method on the Wormhole class.
+  // e.g.
+  // wAvax on Solana
+  // const token = Wormhole.tokenId("Solana", "3Ftc5hTz9sG4huk79onufGiebJNDMZNL8HYgdMJ9E7JR");
+  // wSol on Avax
+  // const token = Wormhole.tokenId("Avalanche", "0xb10563644a6AB8948ee6d7f5b0a1fb15AaEa1E03");
+
+  // Normalized given token decimals later but can just pass bigints as base units
+  // Note: The Token bridge will dedust past 8 decimals
+  // This means any amount specified past that point will be returned
+  // To the caller
+  const amt = '0.05';
+
+  // With automatic set to true, perform an automatic transfer. This will invoke a relayer
+  // Contract intermediary that knows to pick up the transfers
+  // With automatic set to false, perform a manual transfer from source to destination
+  // Of the token
+  // On the destination side, a wrapped version of the token will be minted
+  // To the address specified in the transfer VAA
+  const automatic = false;
+
+  // The automatic relayer has the ability to deliver some native gas funds to the destination account
+  // The amount specified for native gas will be swapped for the native gas token according
+  // To the swap rate provided by the contract, denominated in native gas tokens
+  const nativeGas = automatic ? '0.01' : undefined;
+
+  // Get signer from local key but anything that implements
+  // Signer interface (e.g. wrapper around web wallet) should work
+  const source = await getSigner(sendChain);
+  const destination = await getSigner(rcvChain);
+
+  // Used to normalize the amount to account for the tokens decimals
+  const decimals = isTokenId(token)
+    ? Number(await wh.getDecimals(token.chain, token.address))
+    : sendChain.config.nativeTokenDecimals;
+
+  // Set this to true if you want to perform a round trip transfer
+  const roundTrip: boolean = false;
+
+  // Set this to the transfer txid of the initiating transaction to recover a token transfer
+  // And attempt to fetch details about its progress.
+  let recoverTxid = undefined;
+
+  // Finally create and perform the transfer given the parameters set above
+  const xfer = !recoverTxid
+    ? // Perform the token transfer
+      await tokenTransfer(
+        wh,
+        {
+          token,
+          amount: amount.units(amount.parse(amt, decimals)),
+          source,
+          destination,
+          delivery: {
+            automatic,
+            nativeGas: nativeGas
+              ? amount.units(amount.parse(nativeGas, decimals))
+              : undefined,
+          },
+        },
+        roundTrip
+      )
+    : // Recover the transfer from the originating txid
+      await TokenTransfer.from(wh, {
+        chain: source.chain.chain,
+        txid: recoverTxid,
+      });
+
+  const receipt = await waitLog(wh, xfer);
+
+  // Log out the results
+  console.log(receipt);
+})();
+
+async function tokenTransfer<N extends Network>(
+  wh: Wormhole<N>,
+  route: {
+    token: TokenId;
+    amount: bigint;
+    source: SignerStuff<N, Chain>;
+    destination: SignerStuff<N, Chain>;
+    delivery?: {
+      automatic: boolean;
+      nativeGas?: bigint;
+    };
+    payload?: Uint8Array;
+  },
+  roundTrip?: boolean
+): Promise<TokenTransfer<N>> {
+  // Create a TokenTransfer object to track the state of the transfer over time
+  const xfer = await wh.tokenTransfer(
+    route.token,
+    route.amount,
+    route.source.address,
+    route.destination.address,
+    route.delivery?.automatic ?? false,
+    route.payload,
+    route.delivery?.nativeGas
+  );
+
+  const quote = await TokenTransfer.quoteTransfer(
+    wh,
+    route.source.chain,
+    route.destination.chain,
+    xfer.transfer
+  );
+  console.log(quote);
+
+  if (xfer.transfer.automatic && quote.destinationToken.amount < 0)
+    throw 'The amount requested is too low to cover the fee and any native gas requested.';
+
+  // 1) Submit the transactions to the source chain, passing a signer to sign any txns
+  console.log('Starting transfer');
+  const srcTxids = await xfer.initiateTransfer(route.source.signer);
+  console.log(`Started transfer: `, srcTxids);
+
+  // If automatic, we're done
+  if (route.delivery?.automatic) return xfer;
+
+  // 2) Wait for the VAA to be signed and ready (not required for auto transfer)
+  console.log('Getting Attestation');
+  const attestIds = await xfer.fetchAttestation(60_000);
+  console.log(`Got Attestation: `, attestIds);
+
+  // 3) Redeem the VAA on the dest chain
+  console.log('Completing Transfer');
+  const destTxids = await xfer.completeTransfer(route.destination.signer);
+  console.log(`Completed Transfer: `, destTxids);
+
+  // If no need to send back, dip
+  if (!roundTrip) return xfer;
+
+  const { destinationToken: token } = quote;
+  return await tokenTransfer(wh, {
+    ...route,
+    token: token.token,
+    amount: token.amount,
+    source: route.destination,
+    destination: route.source,
+  });
+}
diff --git a/.snippets/code/build/build-apps/wormhole-sdk/tokens.ts b/.snippets/code/build/build-apps/wormhole-sdk/tokens.ts
new file mode 100644
index 000000000..4298b7020
--- /dev/null
+++ b/.snippets/code/build/build-apps/wormhole-sdk/tokens.ts
@@ -0,0 +1,5 @@
+const sourceToken: TokenId = Wormhole.tokenId('Ethereum', '0xbeef...');
+
+const gasToken: TokenId = Wormhole.tokenId('Ethereum', 'native');
+
+const strAddress = Wormhole.canonicalAddress(senderAddress); // => '0xbeef...'
\ No newline at end of file
diff --git a/build/.pages b/build/.pages
index 53755afec..b9c6980e2 100644
--- a/build/.pages
+++ b/build/.pages
@@ -2,3 +2,4 @@ title: Build
 nav:
  - index.md
  - start-building
+ - build-apps
diff --git a/build/build-apps/.pages b/build/build-apps/.pages
new file mode 100644
index 000000000..c686b3d7a
--- /dev/null
+++ b/build/build-apps/.pages
@@ -0,0 +1,4 @@
+title: Build Multichain Apps
+nav:
+ - index.md
+ - 'Wormhole SDK': 'wormhole-sdk.md'
diff --git a/build/build-apps/index.md b/build/build-apps/index.md
new file mode 100644
index 000000000..61e80317a
--- /dev/null
+++ b/build/build-apps/index.md
@@ -0,0 +1,4 @@
+---
+title: TODO
+description: TODO
+---
diff --git a/build/build-apps/wormhole-sdk.md b/build/build-apps/wormhole-sdk.md
new file mode 100644
index 000000000..b5cb51682
--- /dev/null
+++ b/build/build-apps/wormhole-sdk.md
@@ -0,0 +1,335 @@
+---
+title: Wormhole TS SDK 
+description: Explore Wormhole's TypeScript SDK and learn about how to perform different types of transfers, including native, token, USDC, and Gateway transfers.
+---
+
+# Wormhole TS SDK {: #wormhole-ts-sdk}
+
+The Wormhole Typescript SDK is useful for interacting with the chains Wormhole supports and the [protocols](#protocols) built on top of Wormhole.
+
+!!! warning
+    This package is a work in progress, so the interface may change, and there are likely bugs. Please [report](https://github.com/wormhole-foundation/connect-sdk/issues){target=\_blank} any issues you find.
+
+## Installation {: #installation}
+
+### Basic {: #basic}
+
+Install the (meta) package:
+
+```bash
+npm install @wormhole-foundation/sdk
+```
+
+This package combines all the individual packages to make setup easier while allowing for tree shaking.  
+
+### Advanced {: #advanced}
+
+Alternatively, you can install a specific set of published packages:
+
+- `sdk-base` - exposes constants
+```sh
+npm install @wormhole-foundation/sdk-base
+```
+
+- `sdk-definitions` - exposes contract interfaces, basic types, and VAA payload definitions
+```sh
+npm install @wormhole-foundation/sdk-definitions
+```
+
+- `sdk-evm` - exposes EVM-specific utilities
+```sh
+npm install @wormhole-foundation/sdk-evm
+```
+
+- `sdk-evm-tokenbridge` - exposes the EVM Token Bridge protocol client
+```sh
+npm install @wormhole-foundation/sdk-evm-tokenbridge
+```
+
+## Usage {: #usage}
+
+Getting started is simple; just import Wormhole:
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/get-vaa.ts::1'
+```
+
+Then, import each of the ecosystem [platforms](#platforms) that you wish to support:
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/get-vaa.ts:4:9'
+```
+
+
+To make the [platform](#platforms) modules available for use, pass them to the Wormhole constructor:
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/get-vaa.ts:13:20'
+```
+
+With a configured Wormhole object, you can do things like parse addresses for the provided platforms, get a [`ChainContext`](#chain-context) object, or fetch VAAs.
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/get-vaa.ts:22:22'
+```
+
+You can retrieve a VAA as follows. In this example, a timeout of `60,000` milliseconds is used. The amount of time required for the VAA to become available will vary by network. 
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/get-vaa.ts:54:61'
+```
+
+??? code "View the complete script"
+    ```ts
+    --8<-- 'code/build/build-apps/wormhole-sdk/get-vaa.ts'
+    ```
+
+Optionally, you can override the default configuration with a partial `WormholeConfig` object to specify particular fields, such as a different RPC endpoint.
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/config-override.ts'
+```
+
+??? code "View the complete script"
+    ```ts
+    --8<-- 'code/build/build-apps/wormhole-sdk/config.ts'
+    ```
+
+## Concepts {: #concepts}
+
+Understanding several higher-level concepts of the SDK will help you use it effectively. The following sections will introduce and discuss the concepts of platforms, chain contexts, addresses, tokens, signers, and protocols.
+
+### Platforms {: #platforms}
+
+Every chain is unique, but many share similar functionality. The `Platform` modules provide a consistent interface for interacting with the chains that share a platform.
+
+Each platform can be installed separately so that dependencies can stay as slim as possible.
+
+Wormhole currently supports the following platforms:
+
+- EVM
+- Solana
+- Cosmwasm
+- Sui
+- Aptos
+
+See the [Platforms folder of the TypeScript SDK](https://github.com/wormhole-foundation/wormhole-sdk-ts/tree/main/platforms){target=\_blank} for an up-to-date list of the platforms supported by the Wormhole TypeScript SDK. 
+
+### Chain Context {: #chain-context}
+
+The `Wormhole` class provides a `getChain` method that returns a `ChainContext` object for a given chain. This object provides access to the chain specific methods and utilities. Much of the functionality in the `ChainContext` is provided by the `Platform` methods but the specific chain may have overridden methods.
+
+The `ChainContext` object is also responsible for holding a cached RPC client and protocol clients.
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/get-chain.ts'
+```
+
+### Addresses {: #addresses}
+
+Within the Wormhole context, addresses are often [normalized](https://docs.wormhole.com/wormhole/blockchain-environments/evm#addresses){target=\_blank} to 32 bytes and referred to in this SDK as a `UniversalAddress`.
+
+Each platform has an address type that understands the native address formats, referred to as `NativeAddress.` This abstraction allows the SDK to work with addresses consistently regardless of the underlying chain.
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/addresses.ts'
+```
+
+### Tokens {: #tokens} 
+
+Similar to the `ChainAddress` type, the `TokenId` type provides the chain and address of a given token. The following snippet introduces `TokenId`, a way to uniquely identify any token, whether it's a standard token or a blockchain's native currency (like ETH for Ethereum).
+
+For standard tokens, Wormhole uses their contract address to create a `TokenId`. For native currencies, Wormhole uses the keyword `native` instead of an address. This makes it easy to work with any type of token consistently.
+
+Finally, the snippet also demonstrates how to convert a `TokenId` back into a regular address format when needed.
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/tokens.ts'
+```
+
+### Signers {: #signers}
+
+In the SDK, a `Signer` interface is required for certain methods to sign transactions. This interface can be fulfilled by either a `SignOnlySigner` or a `SignAndSendSigner`, depending on the specific requirements. A signer can be created by wrapping an existing offline wallet or a web wallet.
+
+A `SignOnlySigner` is used in scenarios where the signer is not connected to the network or prefers not to broadcast transactions themselves. It accepts an array of unsigned transactions and returns an array of signed and serialized transactions. Before signing, the transactions may be inspected or altered. It's important to note that the serialization process is chain-specific; refer to the testing signers (e.g., [EVM](https://github.com/wormhole-foundation/connect-sdk/blob/main/platforms/evm/src/signer.ts){target=\_blank} or [Solana](https://github.com/wormhole-foundation/connect-sdk/blob/main/platforms/solana/src/signer.ts){target=\_blank}) for an example of how to implement a signer for a specific chain or platform.
+
+Conversely, a `SignAndSendSigner` is appropriate when the signer is connected to the network and intends to broadcast the transactions. This type of signer also accepts an array of unsigned transactions but returns an array of transaction IDs, corresponding to the order of the unsigned transactions.
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/signers.ts'
+```
+
+### Protocols {: #protocols}
+
+While Wormhole is a Generic Message Passing (GMP) protocol, several protocols have been built to provide specific functionality. If available, each protocol will have a platform-specific implementation. These implementations provide methods to generate transactions or read state from the contract on-chain.
+
+#### Wormhole Core {: #wormhole-core}
+
+The core protocol underlies all Wormhole activity. This protocol is responsible for emitting the message containing the information necessary to perform bridging, including the [emitter address](https://docs.wormhole.com/wormhole/reference/glossary#emitter){target=\_blank}, the [sequence number](https://docs.wormhole.com/wormhole/reference/glossary#sequence){target=\_blank} for the message, and the payload of the message itself.
+
+The following example demonstrates sending and verifying a message using the Wormhole Core protocol on Solana. 
+
+First, we initialize a Wormhole instance for the Testnet environment, specifically for the Solana chain. We then obtain a signer and its associated address, which will be used to sign transactions.
+Next, we get a reference to the core messaging bridge, which is the main interface for interacting with Wormhole's cross-chain messaging capabilities.
+The code then prepares a message for publication. This message includes:
+
+- The sender's address
+- The message payload (in this case, the encoded string "lol")
+- A nonce (set to `0` here, but can be any user-defined value to uniquely identify the message)
+- A consistency level (set to `0`, which determines the finality requirements for the message)
+
+After preparing the message, the next steps are to generate, sign, and send the transaction(s) required to publish the message on the Solana blockchain. Once the transaction is confirmed, the Wormhole message ID is extracted from the transaction logs. This ID is crucial for tracking the message across chains.
+
+The code then waits for the Wormhole network to process and sign the message, turning it into a Verified Action Approval (VAA). This VAA is retrieved in a `Uint8Array` format, with a timeout of 60 seconds.
+
+Lastly, the code will demonstrate how to verify the message on the receiving end. A verification transaction is prepared using the original sender's address and the VAA, and finally this transaction is signed and sent.
+
+???+ code "View the complete script"
+    ```ts
+    --8<-- 'code/build/build-apps/wormhole-sdk/example-core-bridge.ts'
+    ```
+
+The payload contains the information necessary to perform whatever action is required based on the protocol that uses it. 
+
+#### Token Bridge {: #token-bridge}
+
+The most familiar protocol built on Wormhole is the Token Bridge. Every chain has a `TokenBridge` protocol client that provides a consistent interface for interacting with the Token Bridge. This includes methods to generate the transactions required to transfer tokens and methods to generate and redeem attestations. `WormholeTransfer` abstractions are the recommended way to interact with these protocols but it is possible to use them directly.
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/token-bridge-snippet.ts'
+```
+
+Supported protocols are defined in the [definitions module](https://github.com/wormhole-foundation/connect-sdk/tree/main/core/definitions/src/protocols){target=\_blank}.
+
+## Transfers {: #transfers}
+
+While using the [`ChainContext`](#chain-context) and [`Protocol`](#protocols) clients directly is possible, the SDK provides some helpful abstractions for doing things like transferring tokens.
+
+The `WormholeTransfer` interface provides a convenient abstraction to encapsulate the steps involved in a cross-chain transfer.
+
+### Token Transfers {: #token-transfers}
+
+Performing a token transfer is trivial for any source and destination chains. You can create a new `Wormhole` object to make objects like `TokenTransfer`, `CircleTransfer`, and `GatewayTransfer`, to transfer tokens between chains. 
+
+The following example demonstrates the process of initiating and completing a token transfer. It starts by creating a `TokenTransfer` object, which tracks the transfer's state throughout its lifecycle. The code then obtains a quote for the transfer, ensuring the amount is sufficient to cover fees and any requested native gas.
+
+The transfer process is divided into three main steps: 
+
+1. Initiating the transfer on the source chain
+2. Waiting for the transfer to be attested (if not automatic)
+3. Completing the transfer on the destination chain 
+
+For automatic transfers, the process ends after initiation. For manual transfers, the code waits for the transfer to be attested and then completes it on the destination chain.
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/token-bridge.ts:120:158'
+```
+
+??? code "View the complete script"
+    ```ts hl_lines="122"
+    --8<-- 'code/build/build-apps/wormhole-sdk/token-bridge.ts'
+    ```
+
+Internally, this uses the [TokenBridge](#token-bridge) protocol client to transfer tokens. Like other Protocols, the `TokenBridge` protocol provides a consistent set of methods across all chains to generate a set of transactions for that specific chain.
+
+### Native USDC Transfers {: #native-usdc-transfers}
+
+You can also transfer native USDC using [Circle's CCTP](https://www.circle.com/en/cross-chain-transfer-protocol){target=\_blank}. Please note that if the transfer is set to `Automatic` mode, a fee for performing the relay will be included in the quote. This fee is deducted from the total amount requested to be sent. For example, if the user wishes to receive `1.0` on the destination, the amount sent should be adjusted to `1.0` plus the relay fee. The same principle applies to native gas dropoffs.
+
+In the following example, the `wh.circleTransfer` function is called with several parameters to set up the transfer. It takes the amount to be transferred (in the token's base units), the sender's chain and address, and the receiver's chain and address. The function also allows specifying whether the transfer should be automatic, meaning it will be completed without further user intervention.
+
+An optional payload can be included with the transfer, though in this case it's set to undefined. Finally, if the transfer is automatic, you can request that native gas (the blockchain's native currency used for transaction fees) be sent to the receiver along with the transferred tokens. 
+
+When waiting for the `VAA`, a timeout of `60,000` milliseconds is used. The amount of time required for the VAA to become available will [vary by network](https://developers.circle.com/stablecoin/docs/cctp-technical-reference#mainnet){target=\_blank}. 
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/cctp.ts:69:112'
+```
+
+??? code "View the complete script"
+    ```ts
+    --8<-- 'code/build/build-apps/wormhole-sdk/cctp.ts'
+    ```
+
+### Gateway Transfers {: #gateway-transfers}
+
+Gateway transfers are passed through the Wormhole Gateway to or from Cosmos chains. A transfer into Cosmos from outside Cosmos will be automatically delivered to the destination via IBC from the Gateway chain (fka Wormchain). A transfer within Cosmos will use IBC to transfer from the origin to the Gateway chain, then out from the Gateway to the destination chain.
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/cosmos.ts:152:172'
+```
+
+A transfer leaving Cosmos will produce a VAA from the Gateway that must be manually redeemed on the destination chain.
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/cosmos.ts:184:207'
+```
+
+??? code "View the complete script"
+    ```ts
+    --8<-- 'code/build/build-apps/wormhole-sdk/cosmos.ts'
+    ```
+
+### Recovering Transfers {: #recovering-transfers}
+
+It may be necessary to recover an abandoned transfer before being completed. To do this, instantiate the `Transfer` class with the `from` static method and pass one of several types of identifiers. A `TransactionId` or `WormholeMessageId` may be used to recover the transfer.
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/cctp.ts:120:126'
+```
+
+??? code "View the complete script"
+    ```ts hl_lines="130"
+    --8<-- 'code/build/build-apps/wormhole-sdk/cctp.ts'
+    ```
+
+## Routes {: #routes}
+
+While a specific `WormholeTransfer` may be used (`TokenTransfer`, `CCTPTransfer`, etc.), the developer must know exactly which transfer type to use for a given request. 
+
+To provide a more flexible and generic interface, the `Wormhole` class provides a method to produce a `RouteResolver` that can be configured with a set of possible routes to be supported.
+
+The following section demonstrates the process of setting up and validating a token transfer using Wormhole's routing system.
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/router.ts:24:31'
+```
+
+Once created, the resolver can be used to provide a list of input and possible output tokens.
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/router.ts:33:53'
+```
+
+Once the tokens are selected, a `RouteTransferRequest` may be created to provide a list of routes that can fulfill the request. Creating a transfer request fetches the token details since all routes will need to know about the tokens.
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/router.ts:55:67'
+```
+
+Choosing the best route is currently left to the developer, but strategies might include sorting by output amount or expected time to complete the transfer (no estimate is currently provided).
+
+After choosing the best route, extra parameters like `amount`, `nativeGasDropoff`, and `slippage` can be passed, depending on the specific route selected and a quote can be retrieved with the validated request. 
+
+After successful validation, the code requests a transfer quote. This quote likely includes important details such as fees, estimated time, and the final amount to be received. If the quote is generated successfully, it's displayed for the user to review and decide whether to proceed with the transfer. This process ensures that all transfer details are properly set up and verified before any actual transfer takes place.
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/router.ts:72:93'
+```
+
+Finally, assuming the quote looks good, the route can initiate the request with the quote and the `signer`.
+
+```ts
+--8<-- 'code/build/build-apps/wormhole-sdk/router.ts:100:106'
+```
+
+??? code "View the complete script"
+    ```ts
+    --8<-- 'code/build/build-apps/wormhole-sdk/router.ts'
+    ```
+
+See the `router.ts` example in the [examples directory](https://github.com/wormhole-foundation/wormhole-sdk-ts/tree/main/examples){target=\_blank} for a full working example.
+
+## See Also {: #see-also}
+
+The tsdoc is available [on GitHub](https://wormhole-foundation.github.io/wormhole-sdk-ts/){target=\_blank}.
\ No newline at end of file