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

package/src/relayer.ts

@@ -0,0 +1,50 @@
+import { Chain, PlatformName } from "@wormhole-foundation/sdk-base";
+import { UniversalOrNative } from "./address";
+
+export interface Relayer<P extends PlatformName> {
+  relaySupported(chain: Chain): boolean;
+  getRelayerFee(
+    sourceChain: Chain,
+    destChain: Chain,
+    tokenId: UniversalOrNative<P>
+  ): Promise<bigint>;
+  // TODO: What should this be named?
+  // I don't think it should return an UnisgnedTransaction
+  // rather it should take some signing callbacks and
+  // a ref to track the progress
+  startTransferWithRelay(
+    token: UniversalOrNative<P> | "native",
+    amount: bigint,
+    toNativeToken: string,
+    sendingChain: Chain,
+    senderAddress: string,
+    recipientChain: Chain,
+    recipientAddress: string,
+    overrides?: any
+  ): Promise<any>;
+  calculateNativeTokenAmt(
+    destChain: Chain,
+    tokenId: UniversalOrNative<P>,
+    amount: bigint,
+    walletAddress: string
+  ): Promise<bigint>;
+  calculateMaxSwapAmount(
+    destChain: Chain,
+    tokenId: UniversalOrNative<P>,
+    walletAddress: string
+  ): Promise<bigint>;
+}
+
+//function parseRelayerPayload(transferPayload: Buffer): ParsedRelayerPayload {
+//  return {
+//    relayerPayloadId: transferPayload.readUint8(0),
+//    relayerFee: BigNumber.from(
+//      "0x" + transferPayload.subarray(1, 33).toString("hex")
+//    ),
+//    toNativeTokenAmount: BigNumber.from(
+//      "0x" + transferPayload.subarray(33, 65).toString("hex")
+//    ),
+//    to: "0x" + transferPayload.subarray(65, 98).toString("hex"),
+//  };
+//}
+//

package/src/rpc.ts

@@ -0,0 +1,16 @@
+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;

package/src/signature.ts

@@ -0,0 +1,26 @@
+//TODO this should get properly wrapped and get its own interface so we don't expose implementation
+//  internals and can swap out the implementation if we choose to later. Maybe also rename
+//  recovery to v then (this seems to be the convention at least in EVM land)
+
+import { Signature as SignatureOptionalRecovery } from "@noble/secp256k1";
+
+export class Signature extends SignatureOptionalRecovery {
+  constructor(
+    readonly r: bigint,
+    readonly s: bigint,
+    readonly recovery: number
+  ) {
+    super(r, s, recovery);
+  }
+
+  toUint8Array(): Uint8Array {
+    const buff = new Uint8Array(65);
+    buff.set(this.toCompactRawBytes());
+    buff.set([this.recovery], 64);
+    return buff;
+  }
+
+  toBuffer(): Buffer {
+    return Buffer.from(this.toUint8Array());
+  }
+}

package/src/testing/README.md

@@ -0,0 +1,4 @@
+
+Mocks for Package defined structures
+
+Factories for creating test data

package/src/testing/index.ts

@@ -0,0 +1,2 @@
+export * as mocks from "./mocks";
+export * as utils from "./utils";

package/src/testing/mocks/api.ts

@@ -0,0 +1,9 @@
+import { VAA } from "../..";
+
+export class MockApi {
+  constructor(readonly url: string) {}
+
+  async getVaaBytes(): Promise<VAA<"Uint8Array">> {
+    throw new Error("Not implemented");
+  }
+}

package/src/testing/mocks/chain.ts

@@ -0,0 +1,18 @@
+import { ChainName, PlatformName } from "@wormhole-foundation/sdk-base";
+import { RpcConnection, ChainContext, Platform } from "../..";
+
+export function chainFactory<P extends PlatformName>(
+  p: Platform<P>,
+  chain: ChainName
+): ChainContext<P> {
+  return new MockChain<P>(p, 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!;
+  }
+}

package/src/testing/mocks/contracts.ts

@@ -0,0 +1,57 @@
+import { ChainName, ChainId, toChainName } from "@wormhole-foundation/sdk-base";
+import { ChainsConfig, Contracts } from "../..";
+
+export class MockContracts {
+  protected _contracts: Map<ChainName, Contracts>;
+
+  constructor(conf: ChainsConfig) {
+    this._contracts = new Map();
+    Object.entries(conf).forEach(([c, cfg]) => {
+      this._contracts.set(c as ChainName, cfg.contracts);
+    });
+  }
+
+  getContracts(chain: ChainName | ChainId): any | undefined {
+    const chainName = toChainName(chain);
+    return this._contracts.get(chainName);
+  }
+
+  mustGetContracts(chain: ChainName | ChainId): any {
+    const chainName = toChainName(chain);
+    const contracts = this._contracts.get(chainName);
+    if (!contracts) throw new Error(`no Sui contracts found for ${chain}`);
+    return contracts;
+  }
+
+  getCore(chain: ChainName | ChainId) {
+    throw new Error("Method not implemented.");
+  }
+
+  mustGetCore(chain: ChainName | ChainId) {
+    throw new Error("Method not implemented.");
+  }
+
+  getBridge(chain: ChainName | ChainId) {
+    throw new Error("Method not implemented.");
+  }
+
+  mustGetBridge(chain: ChainName | ChainId) {
+    throw new Error("Method not implemented.");
+  }
+
+  getNftBridge(chain: ChainName | ChainId) {
+    throw new Error("Method not implemented.");
+  }
+
+  mustGetNftBridge(chain: ChainName | ChainId) {
+    throw new Error("Method not implemented.");
+  }
+
+  getTokenBridgeRelayer(chain: ChainName | ChainId) {
+    throw new Error("Method not implemented.");
+  }
+
+  mustGetTokenBridgeRelayer(chain: ChainName | ChainId) {
+    throw new Error("Method not implemented.");
+  }
+}

package/src/testing/mocks/index.ts

@@ -0,0 +1,5 @@
+export * from './api';
+export * from './chain';
+export * from './platform';
+export * from './tokenBridge';
+export * from './contracts';

package/src/testing/mocks/platform.ts

@@ -0,0 +1,146 @@
+import {
+  ChainName,
+  PlatformName,
+  chainToPlatform,
+} from "@wormhole-foundation/sdk-base";
+import {
+  ChainContext,
+  Platform,
+  TxHash,
+  RpcConnection,
+  TokenId,
+  AutomaticTokenBridge,
+  TokenBridge,
+  UniversalAddress,
+  WormholeMessageId,
+  CircleBridge,
+  AutomaticCircleBridge,
+  ChainsConfig,
+  PlatformCtr,
+  toNative,
+  nativeIsRegistered,
+  NativeAddress,
+} from "../..";
+import { MockRpc } from "./rpc";
+import { MockChain } from "./chain";
+import { MockTokenBridge } from "./tokenBridge";
+import { WormholeCore } from "../../protocols/core";
+
+export function mockPlatformFactory(
+  p: PlatformName
+): PlatformCtr<PlatformName> {
+  class ConcreteMockPlatform extends MockPlatform<typeof p> {
+    static _platform: typeof p = p;
+    readonly platform = ConcreteMockPlatform._platform;
+  }
+  return ConcreteMockPlatform;
+}
+
+// Note: don't use this directly, instead create a ConcreteMockPlatform with the
+// mockPlatformFactory
+export class MockPlatform<P extends PlatformName> implements Platform<P> {
+  // @ts-ignore
+  readonly platform: P;
+
+  conf: ChainsConfig;
+
+  constructor(conf: ChainsConfig) {
+    this.conf = conf;
+  }
+  getDecimals(
+    chain: ChainName,
+    rpc: RpcConnection<P>,
+    token: TokenId | "native"
+  ): Promise<bigint> {
+    throw new Error("Method not implemented.");
+  }
+  getBalance(
+    chain: ChainName,
+    rpc: RpcConnection<P>,
+    walletAddr: string,
+    token: TokenId | "native"
+  ): Promise<bigint | null> {
+    throw new Error("Method not implemented.");
+  }
+
+  getChain(chain: ChainName): ChainContext<P> {
+    return new MockChain<P>(this, chain);
+  }
+  getRpc(chain: ChainName): RpcConnection<P> {
+    // @ts-ignore
+    return new MockRpc(chain);
+  }
+
+  async getWrappedAsset(
+    chain: ChainName,
+    rpc: RpcConnection<P>,
+    token: TokenId
+  ): Promise<TokenId | null> {
+    throw new Error("Method not implemented.");
+  }
+  async getTokenDecimals(
+    rpc: RpcConnection<P>,
+    token: TokenId
+  ): Promise<bigint> {
+    return 8n;
+  }
+  async getNativeBalance(
+    rpc: RpcConnection<P>,
+    walletAddr: string
+  ): Promise<bigint> {
+    return 0n;
+  }
+  async getTokenBalance(
+    chain: ChainName,
+    rpc: RpcConnection<P>,
+    walletAddr: string,
+    token: TokenId
+  ): Promise<bigint | null> {
+    return 10n;
+  }
+
+  async parseTransaction(
+    chain: ChainName,
+    rpc: RpcConnection<P>,
+    txid: TxHash
+  ): Promise<WormholeMessageId[]> {
+    throw new Error("Method not implemented");
+  }
+
+  parseAddress(chain: ChainName, address: string): NativeAddress<P> {
+    if (!nativeIsRegistered(chain)) throw new Error("Chain not registered");
+    //@ts-ignore
+    return toNative(chain, address).toUniversalAddress();
+  }
+
+  async sendWait(rpc: RpcConnection<P>, stxns: any[]): Promise<TxHash[]> {
+    throw new Error("Method not implemented.");
+  }
+
+  async getWormholeCore(rpc: RpcConnection<P>): Promise<WormholeCore<P>> {
+    throw new Error("Method not implemented.");
+  }
+  async getTokenBridge(rpc: RpcConnection<P>): Promise<TokenBridge<P>> {
+    // @ts-ignore
+    return new MockTokenBridge<P>(rpc);
+  }
+
+  async getAutomaticTokenBridge(
+    rpc: RpcConnection<P>
+  ): Promise<AutomaticTokenBridge<P>> {
+    throw new Error("Method not implemented.");
+  }
+  async getCircleBridge(rpc: RpcConnection<P>): Promise<CircleBridge<P>> {
+    throw new Error("Method not implemented.");
+  }
+  async getCircleRelayer(
+    rpc: RpcConnection<P>
+  ): Promise<AutomaticCircleBridge<P>> {
+    throw new Error("Method Not implemented.");
+  }
+  async getAutomaticCircleBridge(
+    rpc: RpcConnection<P>
+  ): Promise<AutomaticCircleBridge<P>> {
+    throw new Error("Method not implemented.");
+  }
+}

package/src/testing/mocks/rpc.ts

@@ -0,0 +1,12 @@
+import { ChainName } from '@wormhole-foundation/sdk-base';
+
+export class MockRpc {
+  constructor(chain: ChainName) {}
+
+  getBalance(address: string): Promise<bigint> {
+    throw new Error('Method not implemented.');
+  }
+  broadcastTransaction(stxns: any): any {
+    throw new Error('Not implemented');
+  }
+}

package/src/testing/mocks/tokenBridge.ts

@@ -0,0 +1,68 @@
+import { PlatformName } from "@wormhole-foundation/sdk-base";
+import {
+  ChainAddress,
+  NativeAddress,
+  RpcConnection,
+  TokenBridge,
+  TokenId,
+  UniversalOrNative,
+  UnsignedTransaction,
+  VAA,
+} from "../..";
+
+//export function mockTokenBridgeFactory(
+//  p: PlatformName,
+//): TokenBridge<PlatformName> {
+//  return new MockTokenBridge(p);
+//}
+
+export class MockTokenBridge<P extends PlatformName> implements TokenBridge<P> {
+  constructor(readonly rpc: RpcConnection<P>) {}
+
+  isWrappedAsset(token: UniversalOrNative<P>): Promise<boolean> {
+    throw new Error("Method not implemented.");
+  }
+  getOriginalAsset(token: UniversalOrNative<P>): Promise<ChainAddress> {
+    throw new Error("Method not implemented.");
+  }
+  hasWrappedAsset(original: ChainAddress): Promise<boolean> {
+    throw new Error("Method not implemented.");
+  }
+  async getWrappedAsset(original: ChainAddress): Promise<NativeAddress<P>> {
+    throw new Error("Method not implemented.");
+  }
+  isTransferCompleted(
+    vaa: VAA<"Transfer"> | VAA<"TransferWithPayload">
+  ): Promise<boolean> {
+    throw new Error("Method not implemented.");
+  }
+  createAttestation(
+    address: UniversalOrNative<P>
+  ): AsyncGenerator<UnsignedTransaction> {
+    throw new Error("Method not implemented.");
+  }
+  submitAttestation(
+    vaa: VAA<"AttestMeta">
+  ): AsyncGenerator<UnsignedTransaction> {
+    throw new Error("Method not implemented.");
+  }
+  transfer(
+    sender: UniversalOrNative<P>,
+    recipient: ChainAddress,
+    token: "native" | UniversalOrNative<P>,
+    amount: bigint,
+    payload?: Uint8Array | undefined
+  ): AsyncGenerator<UnsignedTransaction> {
+    throw new Error("Method not implemented.");
+  }
+  redeem(
+    sender: UniversalOrNative<P>,
+    vaa: VAA<"Transfer"> | VAA<"TransferWithPayload">,
+    unwrapNative?: boolean | undefined
+  ): AsyncGenerator<UnsignedTransaction> {
+    throw new Error("Method not implemented.");
+  }
+  getWrappedNative(): Promise<NativeAddress<P>> {
+    throw new Error("Method not implemented.");
+  }
+}

package/src/testing/utils/address.ts

@@ -0,0 +1,65 @@
+import crypto from "crypto";
+import {
+  ChainName,
+  PlatformName,
+  chainToPlatform,
+  isPlatform,
+  platformToChains,
+} from "@wormhole-foundation/sdk-base";
+import {
+  ChainAddress,
+  NativeAddress,
+  UniversalAddress,
+  toNative,
+} from "../../";
+
+// return a random buffer of length n
+function randomBuffer(n: number): Buffer {
+  const buff = new Uint8Array(n);
+  crypto.getRandomValues(buff);
+  return Buffer.from(buff);
+}
+
+// get a random 20 byte address
+function fake20ByteAddress(): string {
+  const buff = randomBuffer(20);
+  return buff.toString("hex");
+}
+
+// get a random 32 byte address
+function fake32ByteAddress(): string {
+  const buff = randomBuffer(32);
+  return buff.toString("hex");
+}
+
+// make a random native address for a given chain
+export function makeNativeAddressHexString(chain: ChainName): string {
+  switch (chainToPlatform(chain)) {
+    case "Evm":
+      return fake20ByteAddress();
+    default:
+      return fake32ByteAddress();
+  }
+}
+
+// make a random ChainAddress for a given chain
+export function makeChainAddress(chain: ChainName): ChainAddress {
+  const nativeAddress = makeNativeAddressHexString(chain);
+  const address = new UniversalAddress("0x" + nativeAddress.padStart(64, "0"));
+  return { chain, address };
+}
+
+// make a random NativeAddress for a given chain
+export function makeNativeAddress<T extends ChainName | PlatformName>(
+  chain: T
+): NativeAddress<T> {
+  let cn: ChainName;
+  if (isPlatform(chain)) {
+    // just grab the first one
+    cn = platformToChains(chain)[0];
+  } else {
+    cn = chain;
+  }
+
+  return toNative(cn, makeNativeAddressHexString(cn)) as NativeAddress<T>;
+}

package/src/testing/utils/index.ts

@@ -0,0 +1,2 @@
+export * from "./address";
+export * from "./vaa";

package/src/testing/utils/vaa.ts

@@ -0,0 +1,13 @@
+import { PayloadLiteralToPayloadType } from "../../vaa";
+
+export function makeVAA(payload: any) {
+  return {
+    version: 1,
+    guardianSetIndex: 0,
+    timestamp: 0,
+    nonce: 0,
+    payload: payload,
+    guardianSignature: new Uint8Array(65),
+    hash: new Uint8Array(32),
+  } as const;
+}

package/src/types.ts

@@ -0,0 +1,73 @@
+import {
+  ChainName,
+  ExplorerSettings,
+  PlatformName,
+  isChain,
+} from "@wormhole-foundation/sdk-base";
+import { ChainAddress, toNative } from "./address";
+import { Contracts } from "./contracts";
+import { UnsignedTransaction } from "./unsignedTransaction";
+
+export type TxHash = string;
+export type SequenceId = bigint;
+
+export type SignedTx = any;
+
+export type TokenId = ChainAddress;
+export function isTokenId(thing: TokenId | any): thing is TokenId {
+  return (
+    typeof (<TokenId>thing).address !== undefined &&
+    isChain((<TokenId>thing).chain)
+  );
+}
+
+export interface Signer {
+  chain(): ChainName;
+  address(): string;
+  sign(tx: UnsignedTransaction[]): Promise<SignedTx[]>;
+}
+export function isSigner(thing: Signer | any): thing is Signer {
+  return (
+    typeof (<Signer>thing).chain === "function" &&
+    typeof (<Signer>thing).address == "function" &&
+    typeof (<Signer>thing).sign === "function"
+  );
+}
+
+export function nativeChainAddress(s: Signer | TokenId): TokenId {
+  if (isSigner(s))
+    return {
+      chain: s.chain(),
+      address: toNative(s.chain(), s.address()),
+    };
+
+  return {
+    chain: s.chain,
+    address: s.address.toNative(s.chain),
+  };
+}
+
+// Fully qualifier Transaction ID
+export type TransactionId = { chain: ChainName; txid: TxHash };
+export function isTransactionIdentifier(
+  thing: TransactionId | any
+): thing is TransactionId {
+  return (
+    (<TransactionId>thing).chain !== undefined &&
+    (<TransactionId>thing).txid !== undefined
+  );
+}
+
+export type ChainConfig = {
+  key: ChainName;
+  platform: PlatformName;
+  contracts: Contracts;
+  finalityThreshold: number;
+  nativeTokenDecimals: number;
+  explorer: ExplorerSettings;
+  rpc: string;
+};
+
+export type ChainsConfig = {
+  [K in ChainName]?: ChainConfig;
+};

package/src/universalAddress.ts

@@ -0,0 +1,57 @@
+import {
+  hexByteStringToUint8Array,
+  uint8ArrayToHexByteString,
+  isHexByteString,
+} from "@wormhole-foundation/sdk-base";
+
+import { Address, NativeAddress, toNative } from "./address";
+
+export class UniversalAddress implements Address {
+  static readonly byteSize = 32;
+
+  private readonly address: Uint8Array;
+
+  constructor(address: string | Uint8Array) {
+    if (typeof address === "string") {
+      if (!UniversalAddress.isValidAddress(address))
+        throw new Error(
+          `Invalid Wormhole address, expected ${UniversalAddress.byteSize}-byte ` +
+            `hex string but got ${address}`
+        );
+
+      this.address = hexByteStringToUint8Array(address);
+    } else {
+      this.address = address;
+    }
+  }
+
+  toNative<T extends Parameters<typeof toNative>[0]>(
+    platform: T
+  ): NativeAddress<T> {
+    return toNative(platform, this);
+  }
+
+  unwrap(): Uint8Array {
+    return this.address;
+  }
+  toString() {
+    return uint8ArrayToHexByteString(this.address);
+  }
+  toUint8Array() {
+    return this.address;
+  }
+  toUniversalAddress() {
+    return this;
+  }
+
+  equals(other: UniversalAddress): boolean {
+    if (other instanceof UniversalAddress) {
+      return other.toString() === this.toString();
+    }
+    return false;
+  }
+
+  static isValidAddress(address: string) {
+    return isHexByteString(address, UniversalAddress.byteSize);
+  }
+}

package/src/unsignedTransaction.ts

@@ -0,0 +1,12 @@
+import { ChainName, Network } from "@wormhole-foundation/sdk-base";
+
+export interface UnsignedTransaction {
+  readonly transaction: any;
+  readonly network: Network;
+  readonly chain: ChainName;
+  readonly description: string;
+  // parallelizable describes whether or not the transaction can be
+  // executed in parallel with others.
+  // If order matters, this will be false to ensure ordered execution
+  readonly parallelizable: boolean;
+}

package/src/utils.ts

@@ -0,0 +1,4 @@
+//@noble is what ethers uses under the hood
+import { keccak_256 } from "@noble/hashes/sha3";
+
+export { keccak_256 as keccak256 };