@wormhole-foundation/sdk-definitions 0.1.0-beta.3

package/README.md

@@ -0,0 +1,3 @@
+should subsume/replace files from old sdk:
+  * vaa/parser
+  * mock

package/__tests__/connectVAA.ts

@@ -0,0 +1,21 @@
+import "../src/payloads/connect";
+import { connectPayloads } from "../src/payloads/connect";
+import { VAA, deserialize, deserializePayload } from "../src/vaa";
+
+const cases = [
+  "AQAAAAABANyb1oS4sD9gIp0m+dKOYmrEaxx3OeWWtUbim+6oL7VnX/zUXa/di9lA0SSDRZ3DCWoqgDC4pjPoMNUNLn1P3EcAZJjzeAAAAAAAAgAAAAAAAAAAAAAAAAppFGcWs6IWIih++hYHQkxmMGmkAAAAAAAAAHDIAQAAAAAAAAAAAAAAAAeGXG6HufcCVTd+AkrOZjDB6qN/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB6EgAAAAAAAAAAAwAAAAAAA5CKAAAAAAAAAAAAAAAAF9of9ThtBExj8AdHtbitHjgGRI0AAAAAAAAAAAAAAAC/aD1UHhEyBBjKeOwTMJk45sWSLwBhAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYagAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAInU4Tn/aAHroyfjAatH6hXg4Srg==",
+];
+
+describe("Circle Transfer VAA tests", function () {
+  it("should correctly deserialize and reserialize a Circle Transfer Relay VAA", function () {
+    for (const testCase of cases) {
+      const vaaBytes = Buffer.from(testCase, "base64");
+
+      const parsed = deserialize("Uint8Array", new Uint8Array(vaaBytes));
+
+      const x = deserializePayload("CircleTransferRelay", parsed.payload);
+      expect(x).toBeTruthy();
+      // ...
+    }
+  });
+});

package/__tests__/governanceVaa.ts

@@ -0,0 +1,139 @@
+import { describe, expect, it } from "@jest/globals";
+
+import { hexByteStringToUint8Array } from "@wormhole-foundation/sdk-base";
+import { UniversalAddress } from "../src/universalAddress";
+import { create, deserialize, serialize } from "../src/vaa";
+import "../src/payloads/governance";
+
+//monkey-patch to allow stringifying BigInts
+(BigInt.prototype as any).toJSON = function () {
+  return this.toString();
+};
+
+//from here: https://etherscan.io/tx/0xfe57d65421ddd689a660a7906c685954fa5c1102716452cbc8acada0214e4522
+//decode via https://vaa.dev
+const guardianSetUpgrade =
+  "0x" +
+  /*version*/ "01" +
+  /*guardianSet*/ "00000002" +
+  /*signature count*/ "0d" +
+  /*guardian*/ "00" +
+  /*r*/ "ce45474d9e1b1e7790a2d210871e195db53a70ffd6f237cfe70e2686a32859ac" +
+  /*s*/ "43c84a332267a8ef66f59719cf91cc8df0101fd7c36aa1878d5139241660edc0" +
+  /*v*/ "01" +
+  /*guardian*/ "03" +
+  /*r*/ "75cc906156ae530786661c0cd9aef444747bc3d8d5aa84cac6a6d2933d4e1a03" +
+  /*s*/ "1cffa30383d4af8131e929d9f203f460b07309a647d6cd32ab1cc7724089392c" +
+  /*v*/ "00" +
+  /*guardian*/ "04" +
+  /*r*/ "52305156cfc90343128f97e499311b5cae174f488ff22fbc09591991a0a73d8e" +
+  /*s*/ "6af3afb8a5968441d3ab8437836407481739e9850ad5c95e6acfcc871e951bc3" +
+  /*v*/ "01" +
+  /*guardian*/ "05" +
+  /*r*/ "a7956eefc23e7c945a1966d5ddbe9e4be376c2f54e45e3d5da88c2f8692510c7" +
+  /*s*/ "429b1ea860ae94d929bd97e84923a18187e777aa3db419813a80deb84cc8d22b" +
+  /*v*/ "00" +
+  /*guardian*/ "06" +
+  /*r*/ "1b2a4f3d2666608e0aa96737689e3ba5793810ff3a52ff28ad57d8efb2096773" +
+  /*s*/ "5dc5537a2e43ef10f583d144c12a1606542c207f5b79af08c38656d3ac407133" +
+  /*v*/ "01" +
+  /*guardian*/ "08" +
+  /*r*/ "6b62c8e130af3411b3c0d91b5b50dcb01ed5f293963f901fc36e7b0e50114dce" +
+  /*s*/ "203373b32eb45971cef8288e5d928d0ed51cd86e2a3006b0af6a65c396c00908" +
+  /*v*/ "00" +
+  /*guardian*/ "09" +
+  /*r*/ "e93ab4d2c8228901a5f4525934000b2c26d1dc679a05e47fdf0ff3231d98fbc2" +
+  /*s*/ "07103159ff4116df2832eea69b38275283434e6cd4a4af04d25fa7a82990b707" +
+  /*v*/ "01" +
+  /*guardian*/ "0a" +
+  /*r*/ "a643f4cf615dfff06ffd65830f7f6cf6512dabc3690d5d9e210fdc712842dc27" +
+  /*s*/ "08b8b2c22e224c99280cd25e5e8bfb40e3d1c55b8c41774e287c1e2c352aecfc" +
+  /*v*/ "01" +
+  /*guardian*/ "0b" +
+  /*r*/ "89c1e85faa20a30601964ccc6a79c0ae53cfd26fb10863db37783428cd91390a" +
+  /*s*/ "163346558239db3cd9d420cfe423a0df84c84399790e2e308011b4b63e6b8015" +
+  /*v*/ "01" +
+  /*guardian*/ "0c" +
+  /*r*/ "a31dcb564ac81a053a268d8090e72097f94f366711d0c5d13815af1ec7d47e66" +
+  /*s*/ "2e2d1bde22678113d15963da100b668ba26c0c325970d07114b83c5698f46097" +
+  /*v*/ "01" +
+  /*guardian*/ "0d" +
+  /*r*/ "c9fda39c0d592d9ed92cd22b5425cc6b37430e236f02d0d1f8a2ef45a00bde26" +
+  /*s*/ "223c0a6eb363c8b25fd3bf57234a1d9364976cefb8360e755a267cbbb674b395" +
+  /*v*/ "01" +
+  /*guardian*/ "10" +
+  /*r*/ "8db01e444ab1003dd8b6c96f8eb77958b40ba7a85fefecf32ad00b7a47c0ae75" +
+  /*s*/ "24216262495977e09c0989dd50f280c21453d3756843608eacd17f4fdfe47600" +
+  /*v*/ "00" +
+  /*guardian*/ "12" +
+  /*r*/ "61025228ef5af837cb060bcd986fcfa84ccef75b3fa100468cfd24e7fadf9916" +
+  /*s*/ "3938f3b841a33496c2706d0208faab088bd155b2e20fd74c625bb1cc8c43677a" +
+  /*v*/ "01" +
+  /*timestamp*/ "63c53c40" +
+  /*nonce*/ "9e0c5dfa" +
+  /*emitterChain*/ "0001" +
+  /*emitterAddress*/ "0000000000000000000000000000000000000000000000000000000000000004" +
+  /*seqeuence*/ "6c5a054d7833d1e4" +
+  /*consistencyLevel*/ "20" +
+  /*module*/ "00000000000000000000000000000000000000000000000000000000436f7265" +
+  /*action*/ "02" +
+  /*chain*/ "0000" +
+  /*guardianSet*/ "00000003" +
+  /*guardians*/ "13" +
+  /*guardian*/ "58cc3ae5c097b213ce3c81979e1b9f9570746aa5" +
+  /*guardian*/ "ff6cb952589bde862c25ef4392132fb9d4a42157" +
+  /*guardian*/ "114de8460193bdf3a2fcf81f86a09765f4762fd1" +
+  /*guardian*/ "107a0086b32d7a0977926a205131d8731d39cbeb" +
+  /*guardian*/ "8c82b2fd82faed2711d59af0f2499d16e726f6b2" +
+  /*guardian*/ "11b39756c042441be6d8650b69b54ebe715e2343" +
+  /*guardian*/ "54ce5b4d348fb74b958e8966e2ec3dbd4958a7cd" +
+  /*guardian*/ "15e7caf07c4e3dc8e7c469f92c8cd88fb8005a20" +
+  /*guardian*/ "74a3bf913953d695260d88bc1aa25a4eee363ef0" +
+  /*guardian*/ "000ac0076727b35fbea2dac28fee5ccb0fea768e" +
+  /*guardian*/ "af45ced136b9d9e24903464ae889f5c8a723fc14" +
+  /*guardian*/ "f93124b7c738843cbb89e864c862c38cddcccf95" +
+  /*guardian*/ "d2cc37a4dc036a8d232b48f62cdd4731412f4890" +
+  /*guardian*/ "da798f6896a3331f64b48c12d1d57fd9cbe70811" +
+  /*guardian*/ "71aa1be1d36cafe3867910f99c09e347899c19c3" +
+  /*guardian*/ "8192b6e7387ccd768277c17dab1b7a5027c0b3cf" +
+  /*guardian*/ "178e21ad2e77ae06711549cfbb1f9c7a9d8096e8" +
+  /*guardian*/ "5e1487f35515d02a92753504a8d75471b9f49edb" +
+  /*guardian*/ "6fbebc898f403e4773e95feb15e80c9a99c8348d";
+
+describe("Governance VAA tests", function () {
+  it("should create an empty VAA from an object with omitted fixed values", function () {
+    const vaa = create("CoreBridgeUpgradeContract", {
+      guardianSet: 0,
+      signatures: [],
+      nonce: 0,
+      timestamp: 0,
+      sequence: 0n,
+      emitterChain: "Solana",
+      emitterAddress: new UniversalAddress(new Uint8Array(32)),
+      consistencyLevel: 0,
+      payload: {
+        chain: "Ethereum",
+        //@ts-ignore
+        newContract: new UniversalAddress(new Uint8Array(32)),
+      },
+    });
+    expect(vaa.payload.protocol).toEqual("CoreBridge");
+    expect(vaa.payload.action).toEqual("UpgradeContract");
+  });
+
+  it("should correctly deserialize and reserialize a guardian set upgrade VAA", function () {
+    const vaa = deserialize("CoreBridgeGuardianSetUpgrade", guardianSetUpgrade);
+    expect(vaa.payloadLiteral).toBe("CoreBridgeGuardianSetUpgrade");
+    expect(vaa.guardianSet).toBe(2);
+    expect(vaa.signatures.length).toBe(13);
+    expect(vaa.nonce).toBe(2651610618);
+    expect(vaa.emitterChain).toBe("Solana");
+    expect(vaa.payload.protocol).toBe("CoreBridge");
+    expect(vaa.payload.action).toBe("GuardianSetUpgrade");
+    expect(vaa.payload.guardianSet).toBe(3);
+    expect(vaa.payload.guardians.length).toBe(19);
+
+    const encoded = serialize(vaa);
+    expect(encoded).toEqual(hexByteStringToUint8Array(guardianSetUpgrade));
+  });
+});

package/__tests__/relayerVaa.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "@jest/globals";
+
+import { hexByteStringToUint8Array } from "@wormhole-foundation/sdk-base";
+import { serializePayload, deserializePayload } from "../src/vaa";
+import "../src/payloads/relayer";
+
+//monkey-patch to allow stringifying BigInts
+(BigInt.prototype as any).toJSON = function () {
+  return this.toString();
+};
+
+//log taken from here: https://moonbeam.moonscan.io/tx/0x6a2c36673e8cbbef29cc3bad4eabfb8edb0851c0d27defba300f80561ccecec6
+const original =
+  "0x01000500000000000000000000000046AF49E93E92ACE9CB04545C6548E3F12BE61FD7000000600000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000C746573746772656574696E67000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000C350000000000000000000000000000000000000000000000000000000308FD36EDB00050000000000000000000000007A0A53847776F7E94CC35742971ACB2217B0DB810000000000000000000000007A0A53847776F7E94CC35742971ACB2217B0DB810000000000000000000000007A0A53847776F7E94CC35742971ACB2217B0DB8100000000000000000000000046AF49E93E92ACE9CB04545C6548E3F12BE61FD700";
+
+describe("Relayer VAA tests", function () {
+  it("should correctly deserialize and reserialize a relayer VAA", function () {
+    const payload = deserializePayload("DeliveryInstruction", original);
+    expect(payload.target.chain).toBe("Polygon");
+    expect(payload.refund.chain).toBe("Polygon");
+    const encoded = serializePayload("DeliveryInstruction", payload);
+    expect(encoded).toEqual(hexByteStringToUint8Array(original));
+  });
+});

package/__tests__/transferVaa.ts

@@ -0,0 +1,28 @@
+import { VAA, deserialize } from "../src/vaa";
+import "../src/payloads/tokenBridge";
+import { tokenBridgePayloads } from "../src/payloads/tokenBridge";
+
+const cases = [
+  "AQAAAAABAMysWsb94YzZxLiJtKr4hcT2qA/+8laXmeZiEtmVZ5kidTdadwYiXfowVtlUtMWNv1PHIU/eH4T1EI/aI6uhW/kBZN0dygAAAAAADgAAAAAAAAAAAAAAAAXKYDfsUfi3Eu0ub6ciGf6udOFTAAAAAAAAAdUBAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUk2Xpn9Q9KBiwox09gcDrskCipQADgAAAAAAAAAAAAAAAGYDtKfinfvbYVnDlakV50dXwfsTAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==",
+  "AQAAAAABAD/A72/ZwTe/pPNRmPLLf3qZY+od9NEqvGEFBv0lHhgJdBmBo4m9cBn2Fb/03XkfFrwM00YQgnmM883tENNnBY8BZOWtSQg8AQAABgAAAAAAAAAAAAAAAGHkTlBspWWebAu6m2eFhvotcpdWAAAAAAAAHWcBAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHoSAAAAAAAAAAAAAAAAAnDySg9PkSFRpfNItP6okDPsDKIkABW2a5rLTM8HWUwGlnaPu04jKXcYMsSSWWEt1y+axX9vtACAAAAAAAAAAAAAAAADUkwZkmKzkCQWf2kwbzS5z2M/+AXsiYmFzaWNfcmVjaXBpZW50Ijp7InJlY2lwaWVudCI6ImMyVnBNVFJqTldVM1pYWjJZM0JvZFdvMGFEaHVjWGxrWm01ek16SXdPWFptYW5SbWFtUndaVGhqIn19",
+];
+
+//const original =
+describe("Token Transfer VAA tests", function () {
+  it("should correctly deserialize and reserialize a transfer VAA", function () {
+    for (const testCase of cases) {
+      const vaaBytes = new Uint8Array(Buffer.from(testCase, "base64"));
+      let parsed:
+        | VAA<"Transfer" | "TransferWithPayload" | "AttestMeta">
+        | undefined;
+      for (const maybeType of tokenBridgePayloads) {
+        try {
+          parsed = deserialize(maybeType[0], vaaBytes);
+        } catch (e) {}
+      }
+      if (parsed === undefined) {
+        throw new Error(`Couldn't deserialize VAA: ${testCase}`);
+      }
+    }
+  });
+});

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@wormhole-foundation/sdk-definitions",
+  "version": "0.1.0-beta.3",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types":"./dist/esm/index.d.ts",
+  "scripts": {
+    "test": "jest --config ../../jest.config.ts __tests__/*.ts",
+    "build:cjs":"tsc -p ./tsconfig.cjs.json",
+    "build:esm":"tsc -p ./tsconfig.esm.json",
+    "build":"npm run build:cjs && npm run build:esm",
+    "rebuild":"npm run clean && npm run build:cjs && npm run build:esm",
+    "clean": "rm -rf ./dist && rm -f ./*.tsbuildinfo"
+  },
+  "dependencies": {
+    "@wormhole-foundation/sdk-base": "*",
+    "@noble/hashes": "^1.3.1",
+    "@noble/secp256k1": "^2.0.0"
+  }
+}

package/src/address.ts

@@ -0,0 +1,105 @@
+import {
+  ChainName,
+  isChain,
+  PlatformName,
+  chainToPlatform,
+  ChainToPlatform,
+} from "@wormhole-foundation/sdk-base";
+
+//TODO BRRRR circular include!!
+//I have yet to figure out how to get the equivalent of a forward declaration to work (without
+//  yet again having to rely on global scope...)
+//I first tried `declare class UniversalAddress {};` but this actually introduces a new, separate
+//  type in this module rather than telling the compiler that we already have this type elsewhere
+//I could also create an interface via `interface IUnverisalAddress {}` but that seems like an
+//  even worse solution, as is just throwing everything into this file here and just brushing
+//  things under the rug by not separating them out.
+import { UniversalAddress } from "./universalAddress";
+
+export interface Address {
+  //unwrap returns the underlying native address type, e.g.:
+  //  * a Uint8Array for UniversalAddress
+  //  * a checksum hex string string for EVM(ethers)
+  //  * a PublicKey for Solana
+  //  * etc.
+  unwrap(): unknown;
+  toString(): string;
+  toUint8Array(): Uint8Array;
+  toUniversalAddress(): UniversalAddress;
+  //static isValidAddress(str: string): boolean;
+
+  //other ideas:
+  //zeroAddress
+  //verify(message: Uint8Array, signature: Uint8Array): boolean;
+  //static byteSize(): number;
+}
+
+declare global {
+  namespace Wormhole {
+    export interface PlatformToNativeAddressMapping {}
+  }
+}
+
+export type MappedPlatforms = keyof Wormhole.PlatformToNativeAddressMapping;
+
+type ChainOrPlatformToPlatform<T extends ChainName | PlatformName> =
+  T extends ChainName ? ChainToPlatform<T> : T;
+type GetNativeAddress<T extends PlatformName> = T extends MappedPlatforms
+  ? Wormhole.PlatformToNativeAddressMapping[T]
+  : never;
+export type NativeAddress<T extends PlatformName | ChainName> =
+  GetNativeAddress<ChainOrPlatformToPlatform<T>>;
+
+export type UniversalOrNative<P extends PlatformName> =
+  | UniversalAddress
+  | NativeAddress<P>;
+
+export type ChainAddress<C extends ChainName = ChainName> = {
+  readonly chain: C;
+  readonly address: UniversalAddress | NativeAddress<C>;
+};
+
+type NativeAddressCtr = new (
+  ua: UniversalAddress | string | Uint8Array
+) => Address;
+
+const nativeFactory = new Map<PlatformName, NativeAddressCtr>();
+
+export function registerNative<P extends MappedPlatforms>(
+  platform: P,
+  ctr: NativeAddressCtr
+): void {
+  if (nativeFactory.has(platform))
+    throw new Error(
+      `Native address type for platform ${platform} has already registered`
+    );
+
+  nativeFactory.set(platform, ctr);
+}
+
+export function nativeIsRegistered<T extends PlatformName | ChainName>(
+  chainOrPlatform: T
+): boolean {
+  const platform: PlatformName = isChain(chainOrPlatform)
+    ? chainToPlatform.get(chainOrPlatform)!
+    : chainOrPlatform;
+
+  return nativeFactory.has(platform);
+}
+
+export function toNative<T extends PlatformName | ChainName>(
+  chainOrPlatform: T,
+  ua: UniversalAddress | string | Uint8Array
+): NativeAddress<T> {
+  const platform: PlatformName = isChain(chainOrPlatform)
+    ? chainToPlatform.get(chainOrPlatform)!
+    : chainOrPlatform;
+
+  const nativeCtr = nativeFactory.get(platform);
+  if (!nativeCtr)
+    throw new Error(
+      `No native address type registered for platform ${platform}`
+    );
+
+  return new nativeCtr(ua) as unknown as NativeAddress<T>;
+}

package/src/attestation.ts

@@ -0,0 +1,42 @@
+import { ChainName } from "@wormhole-foundation/sdk-base";
+import { VAA } from "./vaa";
+import { UniversalAddress } from "./universalAddress";
+import { SequenceId } from "./types";
+
+// Wormhole Message Identifier
+// used to fetch a VAA
+export type WormholeMessageId = {
+  chain: ChainName;
+  emitter: UniversalAddress;
+  sequence: SequenceId;
+};
+export function isWormholeMessageId(
+  thing: WormholeMessageId | any
+): thing is WormholeMessageId {
+  return (
+    (<WormholeMessageId>thing).sequence !== undefined &&
+    (<WormholeMessageId>thing).emitter !== undefined &&
+    (<WormholeMessageId>thing).chain !== undefined
+  );
+}
+
+export type getWormholeAttestation = (id: WormholeMessageId) => Promise<VAA>;
+
+// Circle Message Identifier
+// Used to fetch a Circle attestation
+export type CircleMessageId = {
+  message: string;
+  msgHash: string;
+};
+export function isCircleMessageId(
+  thing: CircleMessageId | any
+): thing is CircleMessageId {
+  return (<CircleMessageId>thing).msgHash !== undefined;
+}
+
+// No parsing
+export type CircleAttestation = string;
+
+export type getCircleAttestation = (
+  id: CircleMessageId
+) => Promise<CircleAttestation>;

package/src/chain.ts

@@ -0,0 +1,105 @@
+import { ChainName, PlatformName } from "@wormhole-foundation/sdk-base";
+import { Platform } from "./platform";
+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]>;
+
+export abstract class ChainContext<P extends PlatformName> {
+  // Cached Protocol clients
+  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 getRpc(): RpcConnection<P>;
+
+  // Utils for platform specific queries
+  getDecimals: OmitChainRpc<P, "getDecimals"> = (token) => {
+    return this.platform.getDecimals(this.chain, this.getRpc(), token);
+  };
+
+  getBalance: OmitChainRpc<P, "getBalance"> = (walletAddr, token) => {
+    return this.platform.getBalance(
+      this.chain,
+      this.getRpc(),
+      walletAddr,
+      token
+    );
+  };
+
+  // Get details about the transaction
+  parseTransaction: OmitChainRpc<P, "parseTransaction"> = (txid) => {
+    return this.platform.parseTransaction(this.chain, this.getRpc(), txid);
+  };
+
+  // Take a native address and convert it to a UniversalAddress
+  parseAddress: OmitChain<P, "parseAddress"> = (address) => {
+    return this.platform.parseAddress(this.chain, address);
+  };
+
+  // Send a transaction and wait for it to be confirmed
+  sendWait: OmitRpc<P, "sendWait"> = (stxns) => {
+    return this.platform.sendWait(this.getRpc(), stxns);
+  };
+
+  // protocols
+  getTokenBridge: OmitRpc<P, "getTokenBridge"> = async () => {
+    this.tokenBridge = this.tokenBridge
+      ? this.tokenBridge
+      : await this.platform.getTokenBridge(this.getRpc());
+    return this.tokenBridge;
+  };
+
+  getAutomaticTokenBridge: OmitRpc<P, "getAutomaticTokenBridge"> = async () => {
+    this.autoTokenBridge = this.autoTokenBridge
+      ? this.autoTokenBridge
+      : await this.platform.getAutomaticTokenBridge(this.getRpc());
+    return this.autoTokenBridge;
+  };
+
+  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;
+    };
+}

package/src/contracts.ts

@@ -0,0 +1,24 @@
+import { ChainName, Network, contracts } from "@wormhole-foundation/sdk-base";
+
+export type Contracts = {
+  coreBridge?: string;
+  tokenBridge?: string;
+  nftBridge?: string;
+  relayer?: string;
+  cctp?: contracts.CircleContracts;
+};
+
+export function getContracts(n: Network, c: ChainName): Contracts {
+  const ct: Contracts = {
+    coreBridge: contracts.coreBridge.get(n, c),
+    tokenBridge: contracts.tokenBridge.get(n, c),
+    nftBridge: contracts.nftBridge.get(n, c),
+    relayer: contracts.relayer.get(n, c),
+  };
+
+  if (contracts.circleContracts.has(n, c)) {
+    ct.cctp = contracts.circleContracts.get(n, c);
+  }
+
+  return ct;
+}

package/src/index.ts

@@ -0,0 +1,25 @@
+// Make sure payloads are registered
+import "./payloads/connect";
+import "./payloads/relayer";
+import "./payloads/governance";
+import "./payloads/tokenBridge";
+
+export * from "./address";
+export * from "./universalAddress";
+export * from "./unsignedTransaction";
+export * from "./vaa";
+export * from "./utils";
+export * from "./relayer";
+export * from "./platform";
+export * from "./chain";
+export * from "./contracts";
+export * from "./signature";
+export * from "./rpc";
+export * from "./attestation";
+export * from "./types";
+
+export * from "./protocols/core";
+export * from "./protocols/tokenBridge";
+export * from "./protocols/cctp";
+
+export * as testing from "./testing";

package/src/layout-items/amount.ts

@@ -0,0 +1,6 @@
+import { UintLayoutItem } from "@wormhole-foundation/sdk-base";
+
+export const amountItem = {
+  binary: "uint",
+  size: 32,
+} as const satisfies Omit<UintLayoutItem, "name">;

package/src/layout-items/chain.ts

@@ -0,0 +1,57 @@
+import {
+  chains,
+  toChainId,
+  chainToChainId,
+  chainIdToChain,
+  CustomConversion,
+  FixedConversion,
+  UintLayoutItem,
+  ChainName,
+} from "@wormhole-foundation/sdk-base";
+
+const chainItemBase = { binary: "uint", size: 2 } as const;
+
+type AllowNull<T, B extends boolean> = B extends true ? T | null : T;
+
+export const chainItem = <
+  C extends readonly ChainName[] = typeof chains,
+  N extends boolean = false
+>(opts?: {
+  allowedChains?: C;
+  allowNull?: N;
+}) =>
+  ({
+    ...chainItemBase,
+    custom: {
+      to: (val: number): AllowNull<C[number], N> => {
+        if (val === 0) {
+          if (!opts?.allowNull)
+            throw new Error(
+              "ChainId 0 is not valid for this module and action"
+            );
+
+          return null as AllowNull<C[number], N>;
+        }
+
+        const chain = chainIdToChain(toChainId(val));
+        const allowedChains = opts?.allowedChains ?? chains;
+        if (!allowedChains.includes(chain))
+          throw new Error(
+            `Chain ${chain} not in allowed chains ${allowedChains}`
+          );
+
+        return chain;
+      },
+      from: (val: AllowNull<C[number], N>): number =>
+        val == null ? 0 : chainToChainId(val),
+    } satisfies CustomConversion<number, AllowNull<C[number], N>>,
+  } as const satisfies Omit<UintLayoutItem, "name">);
+
+export const fixedChainItem = <C extends ChainName>(chain: C) =>
+  ({
+    ...chainItemBase,
+    custom: {
+      to: chain,
+      from: chainToChainId(chain),
+    } satisfies FixedConversion<number, C>,
+  } as const satisfies Omit<UintLayoutItem, "name">);

package/src/layout-items/guardianSet.ts

@@ -0,0 +1,6 @@
+import { UintLayoutItem } from "@wormhole-foundation/sdk-base";
+
+export const guardianSetItem = {
+  binary: "uint",
+  size: 4,
+} as const satisfies Omit<UintLayoutItem, "name">;

package/src/layout-items/index.ts

@@ -0,0 +1,7 @@
+export * from "./amount";
+export * from "./chain";
+export * from "./guardianSet";
+export * from "./payloadId";
+export * from "./sequence";
+export * from "./signature";
+export * from "./universalAddress";

package/src/layout-items/payloadId.ts

@@ -0,0 +1,10 @@
+import { UintLayoutItem } from "@wormhole-foundation/sdk-base";
+
+export const payloadIdItem = <ID extends number>(id: ID) =>
+  ({
+    name: "payloadId",
+    binary: "uint",
+    size: 1,
+    custom: id,
+    omit: true,
+  } as const satisfies UintLayoutItem);

package/src/layout-items/sequence.ts

@@ -0,0 +1,6 @@
+import { UintLayoutItem } from "@wormhole-foundation/sdk-base";
+
+export const sequenceItem = {
+  binary: "uint",
+  size: 8,
+} as const satisfies Omit<UintLayoutItem, "name">;