Wormhole

https://wormhole.com/docs
Admin
Wormhole is a leading cross-chain interoperability platform that enables developers to build secure...
Tokens:720,587
Snippets:9,160
Trust Score:9.9
Update:5 months ago
Show doc for...
Tokens:
Raw
### Get Started with NTT

Source: https://wormhole.com/docs/llms.txt

A guide to getting started with NTT, including CLI installation, test token deployment, and project scaffolding for integration.

```APIDOC
## Get Started with NTT

### Description
NTT enables cross-chain token movement without wrapping. Install the CLI, deploy test tokens, and scaffold a project to integrate NTT into your app.

### Endpoint
N/A (Getting Started Guide)
```

--------------------------------

### Installation and Setup

Source: https://wormhole.com/docs/ai/pages/tools-cli-get-started.md

Instructions for installing the Wormhole CLI and setting up the necessary environment variables.

```APIDOC
## Installation and Setup

### Description

This section details how to install the Wormhole CLI tool by cloning the repository, building the binaries, and configuring environment variables.

### Steps

1.  **Clone the repository:**
    ```bash
    git clone https://github.com/wormhole-foundation/wormhole &&
    cd wormhole/clients/js
    ```

2.  **Build and install the CLI tool:**
    ```bash
    make install
    ```
    This command installs `worm-fetch-governance` and `worm` binaries to your system's PATH.

3.  **Configure environment variables:**
    Create a `$HOME/.wormhole/.env` file and populate it with your private keys, referencing the `.env.sample` file in the `clients/js` directory for structure.
```

--------------------------------

### Clone Demo Repository and Install Dependencies

Source: https://wormhole.com/docs/ai/pages/products-connect-get-started.md

Clone the demo repository and install its dependencies. This example uses Connect version 5.1.1.

```bash
git clone https://github.com/wormhole-foundation/demo-basic-connect.git
cd demo-basic-connect
npm install
```

--------------------------------

### Example: Sending a Hello World Message (EVM)

Source: https://wormhole.com/docs/ai/pages/products-messaging-guides-core-contracts.md

This example demonstrates how to send a 'Hello World' message using the `publishMessage` function. It includes steps for getting the fee, encoding the message, and calling the function.

```solidity
IWormhole wormhole = IWormhole(wormholeAddr);

        // Get the fee for publishing a message
        uint256 wormholeFee = wormhole.messageFee();

        // Check fee and send parameters

        // Create the HelloWorldMessage struct
        HelloWorldMessage memory parsedMessage = HelloWorldMessage({
            payloadID: uint8(1),
            message: helloWorldMessage
        });

        // Encode the HelloWorldMessage struct into bytes
        bytes memory encodedMessage = encodeMessage(parsedMessage);

        // Send the HelloWorld message by calling publishMessage on the
        // wormhole core contract and paying the Wormhole protocol fee.
        messageSequence = wormhole.publishMessage{value: wormholeFee}(
            0, // batchID
            encodedMessage,
            wormholeFinality()
        );
```

--------------------------------

### Clone Repository and Install Dependencies

Source: https://wormhole.com/docs/ai/categories/settlement.md

Clone the demo repository and install project dependencies using npm. This is a necessary setup step before running verification scripts.

```bash
git clone https://github.com/wormhole-foundation/demo-cross-chain-token-transfer.git
cd cross-chain-token-transfers
npm install
```

--------------------------------

### Get Started with Wormhole NTT CLI

Source: https://wormhole.com/docs/llms.txt

Begin using Wormhole NTT by installing the CLI, deploying test tokens, and scaffolding a new project to integrate NTT into your application for cross-chain token movement without wrapping.

```bash
# Install the Wormhole CLI
npm install -g @wormhole-foundation/wormhole-cli

# Deploy test tokens on a local network
wormhole token deploy --chain <chain-id> --name "TestToken" --symbol "TT"

# Scaffold a new NTT project
wormhole ntt scaffold --chain <chain-id> --token-address <token-address>
```

--------------------------------

### Clone Example NTT Token Repository (EVM)

Source: https://wormhole.com/docs/ai/pages/products-token-transfers-native-token-transfers-get-started.md

Clone the example repository to deploy an ERC-20 token on an EVM testnet. Ensure you have Foundry installed.

```bash
git clone https://github.com/wormhole-foundation/example-ntt-token-evm.git
cd example-ntt-token
```

--------------------------------

### Example Deployment Output

Source: https://wormhole.com/docs/ai/categories/solidity-sdk.md

Illustrates the expected terminal output after a successful execution of the deployment script, showing the command run and the start of the deployment process.

```bash
npx ts-node deploy.ts
> cross-chain-token-transfer@1.0.0 deploy
```

--------------------------------

### Start the Application

Source: https://wormhole.com/docs/ai/pages/products-connect-get-started.md

Start the React application locally. Access it at http://localhost:3000.

```bash
npm start
```

--------------------------------

### Install SDK Definitions

Source: https://wormhole.com/docs/ai/pages/protocol-infrastructure-guides-ntt-executor.md

Install the `@wormhole-foundation/sdk-definitions` package to access relay instruction layouts.

```sh
npm i @wormhole-foundation/sdk-definitions
```

--------------------------------

### Create Project Directory and Navigate

Source: https://wormhole.com/docs/ai/pages/products-messaging-guides-wormholescan-api.md

Sets up the project directory and navigates into it. This is the initial step for any new project.

```bash
mkdir wormholescan-api-demo
cd wormholescan-api-demo
```

--------------------------------

### Get Started with Wrapped Token Transfers (TypeScript SDK)

Source: https://wormhole.com/docs/llms.txt

Perform token transfers using Wormhole’s WTT with the TypeScript SDK. This example demonstrates manual and automatic transfer flows.

```typescript
import {Chains} from "@wormhole-foundation/sdk";

// Example for manual transfer (Solana-Sepolia)
const manualTransfer = async () => {
    const {payer, connection} = await getSolanaClient("SolanaSepolia");
    const tokenBridge = await getTokenBridge(Chains.Solana, "SolanaSepolia");
    const amount = 1000000n;
    const tokenAddress = "71a9f3669207838078711487023041722749f802"; // Example token address

    const vaa = await tokenBridge.transfer(payer, tokenAddress, amount, "0x0000000000000000000000000000000000000000", 0n);
    console.log("VAA received:", vaa);
};

// Example for automatic transfer (Fuji-Base Sepolia)
const automaticTransfer = async () => {
    const {signer} = await getEvmClient("Fuji");
    const tokenBridge = await getTokenBridge(Chains.Ethereum, "Fuji");
    const amount = 1000000n;
    const tokenAddress = "0x0000000000000000000000000000000000000000"; // Example token address

    const vaa = await tokenBridge.transfer(signer, tokenAddress, amount, "0x0000000000000000000000000000000000000000", 0n);
    console.log("VAA received:", vaa);
};

manualTransfer().catch(console.error);
automaticTransfer().catch(console.error);
```

--------------------------------

### Get Started with CCTP using TypeScript SDK

Source: https://wormhole.com/docs/llms.txt

Transfer USDC across chains using Wormhole's CCTP integration with the TypeScript SDK, including setup, attestation, and redemption steps.

```typescript
import { Wormhole } from '@wormhole-foundation/connect-sdk';

async function transferUSDC() {
  const wh = new Wormhole('YOUR_MAINNET_API_KEY');

  const tx = await wh.cctpTransfer({
    fromChain: 'ethereum',
    toChain: 'avalanche',
    amount: '1000000',
    recipient: '0x...', // Recipient address on Avalanche
    token: 'USDC',
  });

  console.log('CCTP Transfer initiated:', tx);
}
```

--------------------------------

### Clone Demo Repository and Navigate

Source: https://wormhole.com/docs/products/connect/get-started

Clone the basic Connect demo repository and navigate into the project directory to begin setup.

```bash
git clone https://github.com/wormhole-foundation/demo-basic-connect.git
cd demo-basic-connect
```

--------------------------------

### Create Project Structure

Source: https://wormhole.com/docs/ai/categories/basics.md

Set up the necessary directories and empty files for configuration, helpers, and scripts.

```bash
mkdir -p src/config && touch src/config/constants.ts src/config/layouts.ts
mkdir -p src/helpers && touch src/helpers/vaaHelper.ts
mkdir -p src/scripts && touch scripts/replaceSignatures.ts
```

--------------------------------

### Set Up Environment Variables

Source: https://wormhole.com/docs/ai/pages/products-multigov-guides-deploy-to-evm.md

Copy the example environment file and edit it with your specific configuration. This file typically contains API keys and network endpoints.

```bash
cp .env.example .env
```

--------------------------------

### Initialize Project with npm

Source: https://wormhole.com/docs/ai/pages/products-token-transfers-wrapped-token-transfers-tutorials-transfer-workflow.md

Create a new project directory and initialize it with npm. This sets up the package.json file.

```bash
mkdir native-transfers
cd native-transfers
npm init -y
```

--------------------------------

### Create Project Directory and Initialize npm

Source: https://wormhole.com/docs/ai/pages/products-settlement-get-started.md

Scaffolds a new Node.js project and initializes npm. Ensure Node.js and npm are installed.

```bash
mkdir settlement-swap
cd settlement-swap
npm init -y
```

--------------------------------

### Full deployment.json Example

Source: https://wormhole.com/docs/products/token-transfers/native-token-transfers/configuration/rate-limiting

An example of a complete 'deployment.json' file showing network, chain configurations, and detailed rate limits for outbound and inbound transfers.

```json
{
    "network": "Testnet",
    "chains": {
        "Sepolia": {
            "version": "1.1.0",
            "mode": "burning",
            "paused": false,
            "owner": "0x0088DFAC40029f266e0FF62B82E47A07467A0345",
            "manager": "0x5592809cf5352a882Ad5E9d435C6B7355B716357",
            "token": "0x5CF5D6f366eEa7123BeECec1B7c44B2493569995",
            "transceivers": {
                "threshold": 1,
                "wormhole": {
                    "address": "0x91D4E9629545129D427Fd416860696a9659AD6a1",
                    "pauser": "0x0088DFAC40029f266e0FF62B82E47A07467A0345"
                }
            },
            "limits": {
                "outbound": "184467440737.095516150000000000",
                "inbound": {
                    "ArbitrumSepolia": "500.000000000000000000"
                }
            },
            "pauser": "0x0088DFAC40029f266e0FF62B82E47A07467A0345"
        }
    }
}

```

--------------------------------

### Clone Example NTT Token Repository (Sui)

Source: https://wormhole.com/docs/ai/pages/products-token-transfers-native-token-transfers-get-started.md

Clone the example repository to deploy a Sui Coin contract on the Sui testnet. Ensure you have the Sui CLI installed.

```bash
git clone https://github.com/wormhole-foundation/example-ntt-token-sui
cd example-ntt-token-sui
```

--------------------------------

### Example Query Request JSON Output

Source: https://wormhole.com/docs/products/queries/guides/use-queries

An example of the JSON output for a Wormhole Query Request targeting an eth_call on the Ethereum network to get WETH total supply.

```json
  // {
  //   "nonce": 0,
  //   "requests": [
  //     {
  //       "chainId": 2,
  //       "query": {
  //         "callData": [
  //           {
  //             "to": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
  //             "data": "0x18160ddd"
  //           }
  //         ],
  //         "blockTag": "0x11e9068"
  //       }
  //     }
  //   ],
  //   "version": 1
  // }

```

--------------------------------

### Initialize New NTT Project

Source: https://wormhole.com/docs/products/native-token-transfers/guides/deploy-to-solana

Scaffolds a new NTT project directory and navigates into it. Replace 'my-ntt-project' with your desired project name.

```bash
ntt new my-ntt-project
cd my-ntt-project

```

--------------------------------

### Hello World Example in Wormhole Scaffolding

Source: https://wormhole.com/docs/ai/categories/solidity-sdk.md

This TypeScript code is an example from the Wormhole Scaffolding repository, illustrating a 'Hello World' test case. It can be used as a starting point for understanding basic Wormhole interactions in a test environment.

```typescript
// Example from wormhole-scaffolding/evm/ts-test/01_hello_world.ts

import { expect } from "chai";
import { ethers } from "hardhat";
import { Wormhole } from "@wormhole-foundation/sdk-base";

describe("HelloWorld", function () {
  it("Should deploy and interact with HelloWorld contract", async function () {
    const HelloWorld = await ethers.getContractFactory("HelloWorld");
    const helloWorld = await HelloWorld.deploy();
    await helloWorld.deployed();

    const message = "Hello Wormhole!";
    const tx = await helloWorld.update(message);
    const receipt = await tx.wait();

    // You would typically verify emitted events or contract state here
    console.log("HelloWorld updated. Transaction receipt:", receipt);

    // Example of checking contract state (if applicable)
    // const currentMessage = await helloWorld.getMessage();
    // expect(currentMessage).to.equal(message);
  });
});

```

--------------------------------

### Initialize Node.js Project

Source: https://wormhole.com/docs/ai/pages/products-queries-get-started.md

Sets up a new directory and initializes a Node.js project for the query script.

```bash
mkdir queries
cd queries
npm init -y
```

--------------------------------

### Run React Application

Source: https://wormhole.com/docs/ai/pages/products-connect-tutorials-react-dapp.md

Execute this command in the root of your React app to start the development server. Ensure you have Node.js and npm installed.

```bash
npm run dev
```

--------------------------------

### Create Project File Structure

Source: https://wormhole.com/docs/ai/pages/products-settlement-get-started.md

Sets up the basic directory and file structure for the project, including source files and a gitignore file.

```bash
mkdir src
touch src/helpers.ts src/swap.ts .gitignore
```

--------------------------------

### Initialize Node.js Project

Source: https://wormhole.com/docs/ai/pages/products-token-transfers-wrapped-token-transfers-get-started.md

Create a new directory and initialize a Node.js project for your WTT implementation.

```bash
mkdir wh-wtt
cd wh-wtt
npm init -y
```

--------------------------------

### Native Token Transfers Sui Deployment

Source: https://wormhole.com/docs/llms.txt

Guide to deploying and configuring Wormhole NTT for Sui, including setup, token compatibility, and CLI usage.

```APIDOC
## Native Token Transfers Sui Deployment

### Description
Deploy and configure Wormhole’s Native Token Transfers (NTT) for Sui, including setup, token compatibility, mint/burn modes, and CLI usage.

### Endpoint
N/A (Deployment Guide)
```

--------------------------------

### Full Example: Mocking an Ethereum EthCall Query

Source: https://wormhole.com/docs/products/queries/guides/use-queries

This comprehensive example demonstrates setting up an Ethereum RPC, fetching the latest block, making an eth_call, constructing a QueryRequest, and mocking the response using QueryProxyMock. Ensure you have the necessary SDK imports.

```typescript
import {
  EthCallData,
  EthCallQueryRequest,
  EthCallQueryResponse,
  PerChainQueryRequest,
  QueryProxyMock,
  QueryRequest,
  QueryResponse,
} from '@wormhole-foundation/wormhole-query-sdk';
import axios from 'axios';

const rpc = 'https://ethereum.publicnode.com';
const callData: EthCallData = {
  to: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', // WETH
  data: '0x18160ddd', // web3.eth.abi.encodeFunctionSignature("totalSupply()")
};

(async () => {
  const latestBlock: string = (
    await axios.post(rpc, {
      method: 'eth_getBlockByNumber',
      params: ['latest', false],
      id: 1,
      jsonrpc: '2.0',
    })
  ).data?.result?.number;
  if (!latestBlock) {
    console.error(`❌ Invalid block returned`);
    return;
  }
  console.log('Latest Block:     ', latestBlock, `(${BigInt(latestBlock)})`);
  const targetResponse = await axios.post(rpc, {
    method: 'eth_call',
    params: [callData, latestBlock],
    id: 1,
    jsonrpc: '2.0',
  });
  // console.log(finalizedResponse.data);
  if (targetResponse.data.error) {
    console.error(`❌ ${targetResponse.data.error.message}`);
  }
  const targetResult = targetResponse.data?.result;
  console.log('Target Result:    ', targetResult, `(${BigInt(targetResult)})`);
  // Form the query request
  const request = new QueryRequest(
    0, // Nonce
    [
      new PerChainQueryRequest(
        2, // Ethereum Wormhole Chain ID
        new EthCallQueryRequest(latestBlock, [callData])
      ),
    ]
  );
  console.log(JSON.stringify(request, undefined, 2));
  const mock = new QueryProxyMock({ 2: rpc });
  const mockData = await mock.mock(request);
  console.log(mockData);
  const mockQueryResponse = QueryResponse.from(mockData.bytes);
  const mockQueryResult = (
    mockQueryResponse.responses[0].response as EthCallQueryResponse
  ).results[0];
  console.log(
    `Mock Query Result: ${mockQueryResult} (${BigInt(mockQueryResult)})`
  );
})();

```

--------------------------------

### Native Token Transfers EVM Deployment

Source: https://wormhole.com/docs/llms.txt

Guide to deploying and configuring Wormhole NTT for EVM chains, including setup, token compatibility, and CLI usage.

```APIDOC
## Native Token Transfers EVM Deployment

### Description
Deploy and configure Wormhole’s Native Token Transfers (NTT) for EVM chains, including setup, token compatibility, mint/burn modes, and CLI usage.

### Endpoint
N/A (Deployment Guide)
```

--------------------------------

### Native Token Transfers SVM Deployment

Source: https://wormhole.com/docs/llms.txt

Guide to deploying and configuring Wormhole NTT for SVM chains (e.g., Solana), including setup, token compatibility, and CLI usage.

```APIDOC
## Native Token Transfers SVM Deployment

### Description
Deploy and configure Wormhole's Native Token Transfers (NTT) for SVM chains, including setup, token compatibility, mint/burn modes, and CLI usage.

### Endpoint
N/A (Deployment Guide)
```

--------------------------------

### Full CCTP Transfer Script Example (TypeScript)

Source: https://wormhole.com/docs/ai/categories/typescript-sdk

A comprehensive example demonstrating the setup and execution of a CCTP transfer using the Wormhole SDK. It initializes the Wormhole object, defines sender and receiver chains, obtains signers, sets transfer amounts, and calls the `cctpTransfer` function. This script showcases a typical end-to-end workflow.

```typescript
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

```

--------------------------------

### Initialize Project Directory

Source: https://wormhole.com/docs/ai/pages/products-cctp-bridge-tutorials-complete-usdc-transfer.md

Creates a new directory for the project and initializes it with npm. This sets up the package.json file.

```bash
mkdir cctp-circle
cd cctp-circle
npm init -y
```

--------------------------------

### Create Project Directory and Initialize npm

Source: https://wormhole.com/docs/products/settlement/get-started

Scaffolds a new Node.js project and initializes npm. Ensure you are in your desired project directory before running.

```bash
mkdir settlement-swap
cd settlement-swap
npm init -y

```

--------------------------------

### Setup Docker Environment for Wormhole NTT CLI Development

Source: https://wormhole.com/docs/products/token-transfers/native-token-transfers/guides/troubleshoot

Use this Dockerfile to create an environment with all necessary dependencies for Wormhole NTT CLI development. It installs Rust, Solana CLI, Anchor, Node.js, Bun, and Foundry.

```docker
FROM ubuntu:20.04
    # Set environment variables to prevent interactive prompts during installation
    ENV DEBIAN_FRONTEND=noninteractive

    # Update and install necessary dependencies
    RUN apt-get update && apt-get install -y \
        curl \
        wget \
        git \
        build-essential \
        libssl-dev \
        libudev-dev \
        pkg-config \
        python3 \
        python3-pip \
        software-properties-common \
        ca-certificates \
        unzip \
        clang \
        cmake \
        protobuf-compiler \
        && apt-get clean && rm -rf /var/lib/apt/lists/*

    # Install Rust
    RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
    ENV PATH="/root/.cargo/bin:$PATH"

    # Install Solana CLI (v1.18.26)
    RUN sh -c "$(curl -sSfL https://release.solana.com/v1.18.26/install)"
    ENV PATH="/root/.local/share/solana/install/active_release/bin:$PATH"

    # Install Anchor using avm
    RUN cargo install --git https://github.com/coral-xyz/anchor avm --locked --force \
        && avm install 0.29.0 \
        && avm use 0.29.0
    ENV PATH="/root/.avm/bin:$PATH"


    ENV NVM_DIR=/root/.nvm
    RUN curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash \
        && . "$NVM_DIR/nvm.sh" \
        && nvm install 22 \
        && nvm use 22 \
        && nvm alias default 22
    ENV PATH="$NVM_DIR/versions/node/v22.12.0/bin:$PATH"

    # Install Bun
    RUN curl -fsSL https://bun.sh/install | bash
    ENV PATH="/root/.bun/bin:$PATH"

    # Install Foundry
    RUN curl -L https://foundry.paradigm.xyz | bash
    ENV PATH="/root/.foundry/bin:${PATH}"
    RUN /bin/bash -c "source /root/.bashrc && foundryup"

    # Install Wormhole NTT CLI
    RUN curl -fsSL https://raw.githubusercontent.com/wormhole-foundation/native-token-transfers/main/cli/install.sh | bash

    # Add a default working directory
    WORKDIR /app

    # Expose port for development if needed
    EXPOSE 8899

    # Entry point for the container
    CMD ["bash"]

```

--------------------------------

### Create Project Structure

Source: https://wormhole.com/docs/products/messaging/guides/wormholescan-api

Sets up the required directories and files for the project. This includes helper modules for API logic and utility functions, and scripts for fetching data.

```bash
mkdir -p src/helpers src/scripts
touch \
    src/helpers/api-client.ts \
    src/helpers/utils.ts \
    src/helpers/types.ts \
    src/scripts/fetch-ntt-tokens.ts \
    src/scripts/fetch-operations.ts
```

--------------------------------

### CCTP v1 Native USDC Transfer Example

Source: https://wormhole.com/docs/tools/typescript-sdk/sdk-reference

Demonstrates constructing a CCTP v1 transfer request, validating parameters, and preparing for an automatic USDC transfer. Requires initializing Wormhole, getting chain contexts, signers, and USDC contract addresses.

```typescript
import { Wormhole, circle, routes } from '@wormhole-foundation/sdk';
import evm from '@wormhole-foundation/sdk/platforms/evm';
import solana from '@wormhole-foundation/sdk/platforms/solana';
import sui from '@wormhole-foundation/sdk/platforms/sui';
import '@wormhole-labs/cctp-executor-route';
import { cctpExecutorRoute } from '@wormhole-labs/cctp-executor-route';
import type { CCTPExecutorRoute } from '@wormhole-labs/cctp-executor-route/dist/esm/routes/cctpV1';
import { getSigner } from './helper';

(async function () {
  // Initialize Wormhole for the Testnet environment and add supported chains (evm, solana and sui)
  const network = 'Testnet';
  const wh = new Wormhole(network, [
    evm.Platform,
    solana.Platform,
    sui.Platform,
  ]);

  // Grab chain contexts (cached RPC clients under the hood)
  const src = wh.getChain('Solana');
  const dst = wh.getChain('BaseSepolia');

  // Get signers from local keys
  const srcSigner = await getSigner(src);
  const dstSigner = await getSigner(dst);

  // Fetch the USDC contract addresses for these chains
  const srcUsdc = circle.usdcContract.get(network, src.chain);
  const dstUsdc = circle.usdcContract.get(network, dst.chain);

  if (!srcUsdc || !dstUsdc) {
    throw new Error(
      'USDC is not configured on the selected source/destination'
    );
  }

  // Build the transfer request for the CCTP v1 executor
  const tr = await routes.RouteTransferRequest.create(wh, {
    source: Wormhole.tokenId(src.chain, srcUsdc),
    destination: Wormhole.tokenId(dst.chain, dstUsdc),
    sourceDecimals: 6,
    destinationDecimals: 6,
    sender: srcSigner.address,
    recipient: dstSigner.address,
  });

  // Configure the executor route (referrer fee off)
  const ExecutorRoute = cctpExecutorRoute({ referrerFeeDbps: 0n });
  const route = new ExecutorRoute(wh);

  // Define the amount of USDC to transfer (in the smallest unit, so 1.000001 USDC = 1,000,001 units assuming 6 decimals)
  const transferAmount = '1.000001';

  // Set the native gas drop-off (0 <= nativeGas <= 1)
  const nativeGasPercent = 0.1;

  const validated = await route.validate(tr, {
    amount: transferAmount,
    options: { nativeGas: nativeGasPercent },
  });

  // Validate inputs and exit early on failure
  if (!validated.valid) {
    const { error } = validated as Extract<typeof validated, { valid: false }>;
    throw new Error(`Validation failed: ${error.message}`);
  }

  // Quote expects the normalized params produced by validate(); cast to that shape
  const validatedParams = validated.params as CCTPExecutorRoute.ValidatedParams;

```

--------------------------------

### Transfer USDC Across Chains with CCTP and TypeScript SDK

Source: https://wormhole.com/docs/llms.txt

Transfer USDC across chains using Wormhole's CCTP integration with the TypeScript SDK. This involves setup, attestation, and redemption steps. Ensure the SDK is installed and configured for CCTP.

```typescript
import { CCTPTransfer } from "@wormhole-foundation/sdk";

async function transferUSDC() {
  const transfer = new CCTPTransfer();
  const result = await transfer.transfer({
    fromChain: "ethereum",
    toChain: "solana",
    fromAddress: "0x123...",
    toAddress: "0x456...",
    amount: "1000000",
    tokenAddress: "0xabc...",
  });
  console.log(result);
}
```

--------------------------------

### Deployment Configuration Example

Source: https://wormhole.com/docs/ai/pages/products-token-transfers-native-token-transfers-guides-deploy-to-hyperliquid.md

A JSON snippet showing the 'deployment.json' file structure after a successful HyperCore token linking, including the 'tokenIndex'.

```json
{
  "network": "Testnet",
  "chains": {
    "HyperEVM": {
      "token": "0x..."
    }
  },
  "hypercore": {
    "tokenIndex": 1591
  }
}
```

--------------------------------

### Create Project File Structure

Source: https://wormhole.com/docs/products/settlement/get-started

Sets up the basic directory and file structure for the project. This includes creating a 'src' directory and essential files.

```bash
mkdir src
touch src/helpers.ts src/swap.ts .gitignore

```

--------------------------------

### Wormhole SDK: Set Up Signer with Ethers.js for Transaction Signing (JavaScript)

Source: https://wormhole.com/docs/ai/categories/typescript-sdk

Provides an example of how to configure and use a signer with the Wormhole SDK by integrating with Ethers.js. This setup allows for programmatic signing and sending of transactions using private keys managed by Ethers.js.

```javascript
import { ethers } from 'ethers';

// Update the following variables
const rpcUrl = 'INSERT_RPC_URL';
const privateKey = 'INSERT_PRIVATE_KEY';
const toAddress = 'INSERT_RECIPIENT_ADDRESS';

// Set up a provider and signer
const provider = new ethers.JsonRpcProvider(rpcUrl);
const signer = new ethers.Wallet(privateKey, provider);

// Example: Signing and sending a transaction
async function sendTransaction() {
  const tx = {
    to: toAddress,
    value: ethers.parseUnits('0.1'), // Sending 0.1 ETH
    gasPrice: await provider.getGasPrice(),
    gasLimit: ethers.toBeHex(21000),
  };

  const transaction = await signer.sendTransaction(tx);
  console.log('Transaction hash:', transaction.hash);
}
sendTransaction();

```

--------------------------------

### Discover and Initiate Token Transfer with Wormhole SDK

Source: https://wormhole.com/docs/ai/pages/tools-typescript-sdk-sdk-reference.md

This example demonstrates the full lifecycle of a token transfer using the Wormhole SDK. It covers discovering supported tokens, finding suitable routes, validating transfer parameters, getting a quote, and optionally initiating the transfer. Ensure you have the necessary network and signer configurations.

```typescript
import { Wormhole, Network, routes } from '@wormhole-foundation/sdk-connect';
import { canonicalAddress } from '@wormhole-foundation/sdk-base';

// Assuming you have initialized Wormhole, network configurations, sender, receiver, etc.
// const wh = new Wormhole(networkConfig);
// const sendChain = Network.Ethereum;
// const destChain = Network.Polygon;
// const sender = { signer: /* your signer */ };
// const receiver = { address: '0x...', signer: /* your signer */ };

(async () => {
  // Initialize Wormhole
  const wh = new Wormhole(Network.Ethereum);

  // Define source and destination chains
  const sendChain = Network.Ethereum;
  const destChain = Network.Polygon;

  // Placeholder for sender and receiver objects
  const sender = { signer: null }; // Replace with actual signer
  const receiver = { address: '0x1234567890abcdef1234567890abcdef12345678', signer: null }; // Replace with actual address and signer

  // Resolver to find routes
  const resolver = routes.getRouteResolver(wh);

  // 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, '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)');
  }
})();
```

--------------------------------

### Setup Contract Instances and Providers

Source: https://wormhole.com/docs/ai/categories/wtt.md

Initializes providers, wallets, and contract instances for cross-chain communication. Loads contract ABIs from compiled artifacts.

```typescript
const { chainId: sourceChainId, networkName: sourceNetworkName } =
            selectSourceChain(deployedContracts);
          const sourceChain = chains.find((chain) => chain.chainId === sourceChainId)!;

          // Select the target chain (only show chains with CrossChainReceiver deployed)
          const { chainId: targetChainId, networkName: targetNetworkName } =
            selectTargetChain(deployedContracts);
          const targetChain = chains.find((chain) => chain.chainId === targetChainId)!;

          // Set up providers and wallets
          const sourceProvider = new ethers.JsonRpcProvider(sourceChain.rpc);
          const wallet = new ethers.Wallet(process.env.PRIVATE_KEY!, sourceProvider);

          // Load the ABI from the JSON file (use the compiled ABI from Forge or Hardhat)
          const CrossChainSenderArtifact = JSON.parse(
            fs.readFileSync(
              path.resolve(
                __dirname,
                '../out/CrossChainSender.sol/CrossChainSender.json'
              ),
              'utf8'
            )
          );

          const abi = CrossChainSenderArtifact.abi;

          // Create the contract instance using the full ABI
          const CrossChainSender = new ethers.Contract(
            deployedContracts[sourceChainId].CrossChainSender!,
            abi,
            wallet
          );
```

--------------------------------

### Wormhole SDK Setup and Manual Token Transfer Example (TypeScript)

Source: https://wormhole.com/docs/ai/categories/typescript-sdk

A comprehensive example script for setting up the Wormhole SDK and executing a manual token transfer. It initializes the Wormhole object for a specific network and supported platforms, retrieves chain contexts, defines token and transfer details (amount, automatic flag, native gas), obtains signers, and includes logic for fetching token decimals. This script provides a practical template for using the SDK's transfer functionalities.

```typescript
    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 WTT (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 Wormhole 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))

```

--------------------------------

### Generate and Submit NTT Transfer with Executor on Solana

Source: https://wormhole.com/docs/protocol/infrastructure-guides/ntt-executor

This example demonstrates how to use the Wormhole TypeScript SDK with helper programs to perform an NTT transfer on Solana. It includes logic for managing Lookup Tables and attaching Executor relay instructions to reduce transaction size. Ensure necessary SDK setup and account configurations are in place before execution.

```typescript
const ntt = await s.getProtocol("Ntt", {
  ntt: {
    chain: "Solana",
    manager: ..., 
    token: ..., 
    transceiver: { wormhole: ... },
  },
});
...
// as of this writing, there's only one tx on Solana
const txs = ntt.transfer(
  new SolanaAddress(payer.publicKey),
  1n,
  {
    chain: "Sepolia",
    address: new UniversalAddress(
      recipientWallet,
      "hex"
    ),
  },
  { queue: false, automatic: false }
);
for await (const tx of txs) {
    // https://github.com/wormhole-foundation/native-token-transfers/blob/b4aa0e34755f735fca40e4566e07c17ac6b2b812/solana/ts/sdk/ntt.ts#L970C8-L970C20
    if (tx.description === "Ntt.Transfer") {
        // Not sure if the first signer will always be the outbox
      const outboxKeypair = tx.transaction.signers[0];
      // Get the lookup tables configured on the NTT manager
      const luts: AddressLookupTableAccount[] = [];
      try {
        // @ts-ignore
        luts.push(await ntt.getAddressLookupTable());
      } catch (e) {
        console.log(e.message);
      }
      // Decompile the message
      const message = TransactionMessage.decompile(
        tx.transaction.transaction.message,
        { addressLookupTableAccounts: luts }
      );
      // Add the execution request to the message
      const exampleNttWithExecutorProgram = new Program<ExampleNttWithExecutor>(
      ExampleNttWithExecutorIdl as ExampleNttWithExecutor,
      provider
    );
    message.instructions.push(
      await exampleNttWithExecutorProgram.methods
        .relayNttMesage({
          execAmount: new BN(estimate.toString()),
          recipientChain: chainToChainId("Sepolia"),
          signedQuoteBytes,
          relayInstructions: Buffer.from(relayInstructions.substring(2), "hex"),
        })
        .accounts({
          payee: new web3.PublicKey(signedQuoteBytes.subarray(24, 56)),
          nttProgramId,
          nttPeer: web3.PublicKey.findProgramAddressSync(
            [Buffer.from("peer"), encoding.bignum.toBytes(chainToChainId("Sepolia"))],
            nttProgramId
          )[0],
          nttMessage: outboxKeypair.publicKey,
        })
        .instruction()
    );
    // If the canonical NTT manager lookup table did not exist
    if (luts.length === 0) {
      // This should probably check the program version and only do this for versions without the canonical lookup table
      // Otherwise, it should call `initializeLut` on the manager(?)
      // I'm not sure if that is already checked somewhere in the SDK
      console.log("no manager lookup table found, checking helper program");
      const exampleNttSvmLutProgram = new Program<ExampleNttSvmLut>(
        ExampleNttSvmLutIdl as ExampleNttSvmLut,
        provider
      );
      const lutPointerAddress = web3.PublicKey.findProgramAddressSync(
        [Buffer.from("lut"), nttProgramId.toBuffer()],
        exampleNttSvmLutProgram.programId
      )[0];
      let lutPointer = await exampleNttSvmLutProgram.account.lut.fetchNullable(
        lutPointerAddress
      );
      if (!lutPointer) {
        console.log("no helper program lookup table found, initializing...");
        const recentSlot =
          (await exampleNttSvmLutProgram.provider.connection.getSlot()) - 1;
        const tx = await exampleNttSvmLutProgram.methods
          .initializeLut(new BN(recentSlot))
          .accounts({
            nttProgramId,
          })
          .rpc();
        console.log(`initialized lookup table: ${tx}`);
        while (!lutPointer) {
          // wait for lut to warm up
          await new Promise((resolve) => setTimeout(resolve, 2000));
          lutPointer = await exampleNttSvmLutProgram.account.lut.fetchNullable(
            lutPointerAddress
          );
        }
      }
      const response = await connection.getAddressLookupTable(
        lutPointer.address
      );
      if (!response.value) {
        throw new Error("unable to fetch lookup table");
      }
      luts.push(response.value);
    }
    // Recompile the message with the lookup table (whether manager or helper)
    tx.transaction.transaction.message = message.compileToV0Message(luts);
    // Broadcast
    const hash = await provider.sendAndConfirm(
      tx.transaction.transaction,
      tx.transaction.signers,
      { commitment: "confirmed" }
    );
  }
}
```

--------------------------------

### Initialize Deployment File

Source: https://wormhole.com/docs/ai/pages/products-token-transfers-native-token-transfers-reference-cli-commands.md

Initialize a new deployment file for a given network. This sets up the basic configuration.

```bash
ntt init devnet
```
Tokens:
Raw