import { Wormhole, Signer } from "@wormhole-foundation/connect-sdk";
import { EvmPlatform } from "@wormhole-foundation/connect-sdk-evm";
import { SolanaPlatform } from "@wormhole-foundation/connect-sdk-solana";
import { AlgorandPlatform } from "@wormhole-foundation/connect-sdk-algorand";

// Include the protocols you wish to use
// these imports register the protocol to be used by higher level abstractions
// like WormholeTransfers 
import "@wormhole-foundation/connect-sdk-evm-tokenbridge";
import "@wormhole-foundation/connect-sdk-solana-tokenbridge";
import "@wormhole-foundation/connect-sdk-algorand-tokenbridge";

const network = "Mainnet"; // Or "Testnet"
const wh = new Wormhole(network, [EvmPlatform, SolanaPlatform, AlgorandPlatform]);

// Get a ChainContext object for a specific chain
// Useful to do things like get the rpc client, make Protocol clients,
// look up configuration parameters or  even fetch balances
const srcChain = wh.getChain("Ethereum");

// In this SDK, the string literal `'native'` is an alias for the gas token
// native to the chain
const balance = await srcChain.getBalance( "0xdeadbeef...", "native" ) // => BigInt

// returns a TokenBridge client for `srcChain` 
await srcChain.getTokenBridge(); // => TokenBridge<'Evm'>
// util to grab an RPC client, cached after the first call  
srcChain.getRpc(); // => RpcConnection<'Evm'>

// Get the chain context for the source and destination chains
// This is useful to grab direct clients for the protocols
const srcChain = wh.getChain(senderAddress.chain);
const dstChain = wh.getChain(receiverAddress.chain);

const tb = await srcChain.getTokenBridge(); // => TokenBridge<'Evm'>
srcChain.getRpcClient(); // => RpcClient<'Evm'>

// Its 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()

// Returns a TokenId 
const sourceToken: TokenId = Wormhole.tokenId("Ethereum","0xbeef...");

// Whereas the ChainAddress is limited to valid addresses, a TokenId may
// have the string literal 'native' to consistently denote the native
// gas token of the chain
const gasToken: TokenId = Wormhole.tokenId("Ethereum","native");

// the same method can be used to convert the TokenId back to its canonical string address format
const strAddress = Wormhole.canonicalAddress(senderAddress); // => '0xbeef...'

// A Signer is an interface that must be provided to certain methods
// in the SDK to sign transactions. It can be either a SignOnlySigner
// or a SignAndSendSigner depending on circumstances.
// A Signer can be implemented by wrapping an existing offline wallet
// or a web wallet
export type Signer = SignOnlySigner | SignAndSendSigner;

// A SignOnlySender is for situations where the signer is not
// connected to the network or does not wish to broadcast the
// transactions themselves
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.
  // Note: The serialization is chain specific, if in doubt,
  // see the example implementations linked below
  sign(tx: UnsignedTransaction[]): Promise<SignedTx[]>;
}

// A SignAndSendSigner is for situations where the signer is
// connected to the network and wishes to broadcast the
// transactions themselves
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[]>;
}

//  ...
// register the protocol
import "@wormhole-foundation/connect-sdk-solana-core";

// ...

// get chain context
const chain = wh.getChain("Solana");
// Get the core brige client for Solana
const coreBridge = await chain.getWormholeCore();
// Generate transactions necessary to simply publish a message
const publishTxs = coreBridge.publishMessage(address.address, encoding.bytes.encode("lol"), 0, 0);

// ... posibly later, after fetching the signed VAA, generate the transactions to verify the VAA
const verifyTxs = coreBridge.verifyMessage(address.address, vaa);

import { signSendWait } from "@wormhole-foundation/connect-sdk";

import "@wormhole-foundation/connect-sdk-evm-tokenbridge";

// ...

const tb = await srcChain.getTokenBridge(); // => TokenBridge<'Evm'>

const token = "0xdeadbeef...";
const txGenerator = tb.createAttestation(token); // => AsyncGenerator<UnsignedTransaction, ...>
const txids = await signSendWait(srcChain, txGenerator, src.signer); // => TxHash[]

// We'll send the native gas token on source chain
const token = "native";

// Format it for base units
const amount = baseUnits(parseAmount(1, srcChain.config.nativeTokenDecimals));

// Create a TokenTransfer object, allowing us to shepherd the transfer through the process and get updates on its status
const manualXfer = wh.tokenTransfer(
  token, // TokenId of the token to transfer or 'native'
  amount, // Amount in base units
  senderAddress, // Sender address on source chain
  recipientAddress, // Recipient address on destination chain
  false, // No Automatic transfer
);

// 1) Submit the transactions to the source chain, passing a signer to sign any txns
const srcTxids = await manualXfer.initiateTransfer(src.signer);

// 2) Wait for the VAA to be signed and ready (not required for auto transfer)
// Note: Depending on chain finality, this timeout may need to be increased.
// See https://docs.wormhole.com/wormhole/reference/constants#consistency-levels for more info on specific chain finality.
const timeout = 60_000;
const attestIds = await manualXfer.fetchAttestation(timeout);

// 3) Redeem the VAA on the destination chain
const destTxids = await manualXfer.completeTransfer(dst.signer);

// OR for an native USDC transfer
const usdcXfer = wh.cctpTransfer(
  1_000_000n, // amount in base units (1 USDC)
  senderAddress, // Sender address on source chain
  recipientAddress, // Recipient address on destination chain
  false, // Automatic transfer
);

// 1) Submit the transactions to the source chain, passing a signer to sign any txns
const srcTxids = await usdcXfer.initiateTransfer(src.signer);

// 2) Wait for the Circle Attestations to be signed and ready (not required for auto transfer)
// Note: Depending on chain finality, this timeout may need to be increased.
// See https://developers.circle.com/stablecoin/docs/cctp-technical-reference#mainnet for more
const timeout = 120_000;
const attestIds = await usdcXfer.fetchAttestation(timeout);

// 3) Redeem the Circle Attestation on the dest chain
const destTxids = await usdcXfer.completeTransfer(dst.signer);

// OR for an automatic transfer
const automaticXfer = wh.tokenTransfer(
  "native", // send native gas on source chain
  amt, // amount in base units
  senderAddress, // Sender address on source chain
  recipientAddress, // Recipient address on destination chain
  true, // Automatic transfer
);

// 1) Submit the transactions to the source chain, passing a signer to sign any txns
const srcTxids = await automaticXfer.initiateTransfer(src.signer);
// 2) If automatic, we're done, just wait for the transfer to complete
if (automatic) return waitLog(automaticXfer);

// Note, this will attempt to recover the transfer from the source chain
// and attestation types so it may wait depending on the chain finality
// and when the transactions were issued.
const timeout = 60_000;
const xfer = await TokenTransfer.from(
  {
    chain: "Ethereum",
    txid: "0x1234...",
  },
  timeout,
);

const dstTxIds = await xfer.completeTransfer(dst.signer);

const xfer = await TokenTransfer.from({
  chain: "Ethereum",
  emitter: toNative("Ethereum", emitterAddress).toUniversalAddress(),
  sequence: "0x1234...",
});

const dstTxIds = await xfer.completeTransfer(dst.signer);