From f0f55499c4b7c5a10076fb0bdd1fef9fca8b3ed4 Mon Sep 17 00:00:00 2001 From: Ben Guidarelli Date: Fri, 3 May 2024 15:39:20 -0400 Subject: [PATCH 01/14] Move bindings to lib, refactor instruction creation utils --- sdk/__tests__/utils.ts | 4 +- solana/tests/anchor.test.ts | 4 +- solana/ts/{sdk => lib}/anchor-idl/1_0_0.ts | 0 solana/ts/{sdk => lib}/anchor-idl/2_0_0.ts | 0 solana/ts/{sdk => lib}/anchor-idl/index.ts | 0 solana/ts/{sdk => lib}/bindings.ts | 50 +- solana/ts/lib/index.ts | 1 + solana/ts/lib/ntt.ts | 1245 +++++++------------- solana/ts/lib/utils.ts | 80 +- solana/ts/sdk/index.ts | 2 +- solana/ts/sdk/ntt.ts | 87 +- 11 files changed, 490 insertions(+), 983 deletions(-) rename solana/ts/{sdk => lib}/anchor-idl/1_0_0.ts (100%) rename solana/ts/{sdk => lib}/anchor-idl/2_0_0.ts (100%) rename solana/ts/{sdk => lib}/anchor-idl/index.ts (100%) rename solana/ts/{sdk => lib}/bindings.ts (53%) diff --git a/sdk/__tests__/utils.ts b/sdk/__tests__/utils.ts index 3058f7d26..8e7064804 100644 --- a/sdk/__tests__/utils.ts +++ b/sdk/__tests__/utils.ts @@ -535,8 +535,8 @@ async function deploySolana(ctx: Ctx): Promise { ); const initTxs = manager.initialize({ - payer: keypair, - owner: keypair, + payer: keypair.publicKey, + owner: keypair.publicKey, chain: "Solana", mint, outboundLimit: 1000000000n, diff --git a/solana/tests/anchor.test.ts b/solana/tests/anchor.test.ts index 1ede579b0..a075181eb 100644 --- a/solana/tests/anchor.test.ts +++ b/solana/tests/anchor.test.ts @@ -223,8 +223,8 @@ describe("example-native-token-transfers", () => { // init const initTxs = ntt.initialize({ - payer, - owner: payer, + payer: payer.publicKey, + owner: payer.publicKey, chain: "Solana", mint: mint.publicKey, outboundLimit: 1000000n, diff --git a/solana/ts/sdk/anchor-idl/1_0_0.ts b/solana/ts/lib/anchor-idl/1_0_0.ts similarity index 100% rename from solana/ts/sdk/anchor-idl/1_0_0.ts rename to solana/ts/lib/anchor-idl/1_0_0.ts diff --git a/solana/ts/sdk/anchor-idl/2_0_0.ts b/solana/ts/lib/anchor-idl/2_0_0.ts similarity index 100% rename from solana/ts/sdk/anchor-idl/2_0_0.ts rename to solana/ts/lib/anchor-idl/2_0_0.ts diff --git a/solana/ts/sdk/anchor-idl/index.ts b/solana/ts/lib/anchor-idl/index.ts similarity index 100% rename from solana/ts/sdk/anchor-idl/index.ts rename to solana/ts/lib/anchor-idl/index.ts diff --git a/solana/ts/sdk/bindings.ts b/solana/ts/lib/bindings.ts similarity index 53% rename from solana/ts/sdk/bindings.ts rename to solana/ts/lib/bindings.ts index 6d92888ef..39b413478 100644 --- a/solana/ts/sdk/bindings.ts +++ b/solana/ts/lib/bindings.ts @@ -2,11 +2,18 @@ import { IdlAccounts, Program } from "@coral-xyz/anchor"; import { Connection } from "@solana/web3.js"; import { _1_0_0, _2_0_0 } from "./anchor-idl/index.js"; +export interface IdlBinding { + idl: { + ntt: NttBindings.NativeTokenTransfer; + quoter: NttBindings.Quoter; + }; +} + export const IdlVersions = { "1.0.0": _1_0_0, "2.0.0": _2_0_0, - default: _2_0_0, } as const; + export type IdlVersion = keyof typeof IdlVersions; export namespace NttBindings { @@ -22,43 +29,38 @@ export namespace NttBindings { NttBindings.NativeTokenTransfer >; - export type Config = - ProgramAccounts["config"]; - export type InboxItem = - ProgramAccounts["inboxItem"]; + export type Config = ProgramAccounts["config"]; + export type InboxItem = ProgramAccounts["inboxItem"]; } -function loadIdlVersion( - version: V -): (typeof IdlVersions)[V] { +function loadIdlVersion(version: V): IdlBinding { if (!(version in IdlVersions)) throw new Error(`Unknown IDL version: ${version}`); - return IdlVersions[version]; + return IdlVersions[version] as unknown as IdlBinding; } -export function getNttProgram( +export function getNttProgram( connection: Connection, address: string, version: V ): Program> { - return new Program>( - //@ts-ignore - loadIdlVersion(version).idl.ntt, - address, - { connection } - ); + const { + idl: { ntt }, + } = loadIdlVersion(version); + return new Program>(ntt, address, { + connection, + }); } -export function getQuoterProgram( +export function getQuoterProgram( connection: Connection, address: string, version: V ) { - return new Program>( - loadIdlVersion(version).idl.quoter, - address, - { - connection, - } - ); + const { + idl: { quoter }, + } = loadIdlVersion(version); + return new Program>(quoter, address, { + connection, + }); } diff --git a/solana/ts/lib/index.ts b/solana/ts/lib/index.ts index a934caede..417017f8d 100644 --- a/solana/ts/lib/index.ts +++ b/solana/ts/lib/index.ts @@ -1,2 +1,3 @@ export * from "./ntt.js"; export * from "./quoter.js"; +export * from "./bindings.js"; diff --git a/solana/ts/lib/ntt.ts b/solana/ts/lib/ntt.ts index 1cfa32b41..01409ca0b 100644 --- a/solana/ts/lib/ntt.ts +++ b/solana/ts/lib/ntt.ts @@ -1,66 +1,42 @@ -import { - Chain, - ChainId, - deserialize, - toChainId, -} from "@wormhole-foundation/sdk-connect"; - -import { BN, Program, translateError, web3 } from "@coral-xyz/anchor"; -import type { IdlAccounts } from "@coral-xyz/anchor"; +import { BN, Program } from "@coral-xyz/anchor"; import * as splToken from "@solana/spl-token"; -import { getAssociatedTokenAddressSync } from "@solana/spl-token"; import { AccountMeta, - AddressLookupTableAccount, - AddressLookupTableProgram, Commitment, + Connection, Keypair, PublicKey, + PublicKeyInitData, SystemProgram, Transaction, + TransactionInstruction, TransactionMessage, VersionedTransaction, - sendAndConfirmTransaction, - type Connection, - type TransactionInstruction, - type TransactionSignature, } from "@solana/web3.js"; import { - nativeTokenTransferLayout, - nttManagerMessageLayout, - type NttManagerMessage, -} from "@wormhole-foundation/sdk-definitions-ntt"; + Chain, + ChainId, + deserialize, + deserializeLayout, + encoding, + keccak256, + rpc, + toChainId, +} from "@wormhole-foundation/sdk-connect"; + +import { Ntt } from "@wormhole-foundation/sdk-definitions-ntt"; + +import { getAssociatedTokenAddressSync } from "@solana/spl-token"; +import { SolanaTransaction } from "@wormhole-foundation/sdk-solana"; import { utils } from "@wormhole-foundation/sdk-solana-core"; -import IDL from "../idl/2_0_0/json/example_native_token_transfers.json"; -import { type ExampleNativeTokenTransfers as RawExampleNativeTokenTransfers } from "../idl/2_0_0/ts/example_native_token_transfers.js"; +import { programVersionLayout } from "../sdk/utils.js"; import { - BPF_LOADER_UPGRADEABLE_PROGRAM_ID, - nttAddresses, - programDataAddress, -} from "./utils.js"; - -export * from "./utils/wormhole.js"; - -export const nttMessageLayout = nttManagerMessageLayout( - nativeTokenTransferLayout -); -export type NttMessage = NttManagerMessage; - -// This is a workaround for the fact that the anchor idl doesn't support generics -// yet. This type is used to remove the generics from the idl types. -type OmitGenerics = { - [P in keyof T]: T[P] extends Record<"generics", any> - ? never - : T[P] extends object - ? OmitGenerics - : T[P]; -}; - -export type ExampleNativeTokenTransfers = - OmitGenerics; - -export type Config = IdlAccounts["config"]; -export type InboxItem = IdlAccounts["inboxItem"]; + IdlVersion, + IdlVersions, + NttBindings, + getNttProgram, +} from "./bindings.js"; +import { chainToBytes, derivePda } from "./utils.js"; export interface TransferArgs { amount: BN; @@ -69,56 +45,84 @@ export interface TransferArgs { shouldQueue: boolean; } -export const NTT_PROGRAM_IDS = [ - "nttiK1SepaQt6sZ4WGW5whvc9tEnGXGxuKeptcQPCcS", - "NTTManager111111111111111111111111111111111", - "NTTManager222222222222222222222222222222222", -] as const; - -export const WORMHOLE_PROGRAM_IDS = [ - "worm2ZoG2kUd4vFXhvjh93UUH596ayRfgQ2MgjNMTth", // mainnet - "3u8hJUVTA4jH1wYAyUur7FFZVQ8H635K3tSHHF4ssjQ5", // testnet - "Bridge1p5gheXUvJ6jGWGeCsgPKgnE3YgdGKRVCMY9o", // tilt -] as const; - -export type NttProgramId = (typeof NTT_PROGRAM_IDS)[number]; -export type WormholeProgramId = (typeof WORMHOLE_PROGRAM_IDS)[number]; - -export class NTT { - readonly program: Program; - readonly wormholeId: PublicKey; - // mapping from error code to error message. Used for prettifying error messages - private readonly errors: Map; +export namespace NTT { + export type Pdas = ReturnType; + export const pdas = (programId: PublicKeyInitData) => { + const configAccount = (): PublicKey => derivePda("config", programId); + const emitterAccount = (): PublicKey => derivePda("emitter", programId); + const inboxRateLimitAccount = (chain: Chain): PublicKey => + derivePda(["inbox_rate_limit", chainToBytes(chain)], programId); + const inboxItemAccount = ( + chain: Chain, + nttMessage: Ntt.Message + ): PublicKey => + derivePda( + ["inbox_item", Ntt.messageDigest(chain, nttMessage)], + programId + ); + const outboxRateLimitAccount = (): PublicKey => + derivePda("outbox_rate_limit", programId); + const tokenAuthority = (): PublicKey => + derivePda("token_authority", programId); + const peerAccount = (chain: Chain): PublicKey => + derivePda(["peer", chainToBytes(chain)], programId); + const transceiverPeerAccount = (chain: Chain): PublicKey => + derivePda(["transceiver_peer", chainToBytes(chain)], programId); + const registeredTransceiver = (transceiver: PublicKey): PublicKey => + derivePda(["registered_transceiver", transceiver.toBytes()], programId); + const transceiverMessageAccount = ( + chain: Chain, + id: Uint8Array + ): PublicKey => + derivePda(["transceiver_message", chainToBytes(chain), id], programId); + const wormholeMessageAccount = (outboxItem: PublicKey): PublicKey => + derivePda(["message", outboxItem.toBytes()], programId); + const lutAccount = (): PublicKey => derivePda("lut", programId); + const lutAuthority = (): PublicKey => derivePda("lut_authority", programId); + const sessionAuthority = ( + sender: PublicKey, + args: TransferArgs + ): PublicKey => + derivePda( + [ + "session_authority", + sender.toBytes(), + keccak256( + encoding.bytes.concat( + encoding.bytes.zpad(new Uint8Array(args.amount.toBuffer()), 8), + chainToBytes(args.recipientChain.id), + new Uint8Array(args.recipientAddress), + new Uint8Array([args.shouldQueue ? 1 : 0]) + ) + ), + ], + programId + ); - pdas: ReturnType; - addressLookupTable: web3.AddressLookupTableAccount | null = null; + // TODO: memoize? + return { + configAccount, + outboxRateLimitAccount, + inboxRateLimitAccount, + inboxItemAccount, + sessionAuthority, + tokenAuthority, + emitterAccount, + wormholeMessageAccount, + peerAccount, + transceiverPeerAccount, + transceiverMessageAccount, + registeredTransceiver, + lutAccount, + lutAuthority, + }; + }; - constructor( + export async function getVersion( connection: Connection, - args: { nttId: NttProgramId; wormholeId: WormholeProgramId } - ) { - // TODO: initialise a new Program here with a passed in Connection - this.program = new Program(IDL as any, new PublicKey(args.nttId), { - connection, - }); - this.wormholeId = new PublicKey(args.wormholeId); - this.pdas = nttAddresses(this.program.programId); - this.errors = this.processErrors(); - } - - // The `translateError` function expects this format, but the idl gives us a - // different one, so we preprocess the idl and store the expected format. - // NOTE: I'm sure there's a function within anchor that does this, but I - // couldn't find it. - private processErrors(): Map { - const errors = this.program.idl.errors; - const result: Map = new Map(); - errors.forEach((entry) => result.set(entry.code, entry.msg)); - return result; - } - // View functions - - async version(pubkey: PublicKey): Promise { + programId: PublicKey, + sender?: PublicKey + ): Promise { // the anchor library has a built-in method to read view functions. However, // it requires a signer, which would trigger a wallet prompt on the frontend. // Instead, we manually construct a versioned transaction and call the @@ -129,307 +133,58 @@ export class NTT { // simulation checks if the account has enough money to pay for the transaction). // // It's a little unfortunate but it's the best we can do. - const ix = await this.program.methods - .version() - .accountsStrict({}) - .instruction(); - const latestBlockHash = - await this.program.provider.connection.getLatestBlockhash(); + if (!sender) { + const address = + connection.rpcEndpoint === rpc.rpcAddress("Devnet", "Solana") + ? "6sbzC1eH4FTujJXWj51eQe25cYvr4xfXbJ1vAj7j2k5J" // The CI pubkey, funded on local network + : "Hk3SdYTJFpawrvRz4qRztuEt2SqoCG7BGj2yJfDJSFbJ"; // The default pubkey is funded on mainnet and devnet we need a funded account to simulate the transaction below + sender = new PublicKey(address); + } + + const program = getNttProgram(connection, programId.toString(), "1.0.0"); + + const ix = await program.methods.version().accountsStrict({}).instruction(); + const latestBlockHash = + await program.provider.connection.getLatestBlockhash(); const msg = new TransactionMessage({ - payerKey: pubkey, + payerKey: sender, recentBlockhash: latestBlockHash.blockhash, instructions: [ix], }).compileToV0Message(); const tx = new VersionedTransaction(msg); - const txSimulation = - await this.program.provider.connection.simulateTransaction(tx, { - sigVerify: false, - }); - - // the return buffer is in base64 and it encodes the string with a 32 bit - // little endian length prefix. - const buffer = Buffer.from( - txSimulation.value.returnData?.data[0]!, - "base64" - ); - const len = buffer.readUInt32LE(0); - return buffer.subarray(4, len + 4).toString(); - } - - // Instructions - - async initialize(args: { - payer: Keypair; - owner: Keypair; - chain: Chain; - mint: PublicKey; - outboundLimit: BN; - mode: "burning" | "locking"; - }): Promise { - const mode: any = - args.mode === "burning" ? { burning: {} } : { locking: {} }; - const chainId = toChainId(args.chain); - const mintInfo = await this.program.provider.connection.getAccountInfo( - args.mint - ); - if (mintInfo === null) { - throw new Error( - "Couldn't determine token program. Mint account is null." - ); - } - const tokenProgram = mintInfo.owner; - const ix = await this.program.methods - .initialize({ chainId, limit: args.outboundLimit, mode }) - .accountsStrict({ - payer: args.payer.publicKey, - deployer: args.owner.publicKey, - programData: programDataAddress(this.program.programId), - config: this.pdas.configAccount(), - mint: args.mint, - rateLimit: this.pdas.outboxRateLimitAccount(), - tokenProgram, - tokenAuthority: this.pdas.tokenAuthority(), - custody: await this.custodyAccountAddress(args.mint, tokenProgram), - bpfLoaderUpgradeableProgram: BPF_LOADER_UPGRADEABLE_PROGRAM_ID, - associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID, - systemProgram: SystemProgram.programId, - }) - .instruction(); - await this.sendAndConfirmTransaction( - new Transaction().add(ix), - [args.payer, args.owner], - false - ); - await this.initializeOrUpdateLUT({ payer: args.payer }); - } - - // This function should be called after each upgrade. If there's nothing to - // do, it won't actually submit a transaction, so it's cheap to call. - async initializeOrUpdateLUT(args: { - payer: Keypair; - }): Promise { - // TODO: find a more robust way of fetching a recent slot - const slot = (await this.program.provider.connection.getSlot()) - 1; - - const [_, lutAddress] = web3.AddressLookupTableProgram.createLookupTable({ - authority: this.pdas.lutAuthority(), - payer: args.payer.publicKey, - recentSlot: slot, - }); - - const whAccs = utils.getWormholeDerivedAccounts( - this.program.programId, - this.wormholeId + const txSimulation = await program.provider.connection.simulateTransaction( + tx, + { sigVerify: false } ); - const config = await this.getConfig(); - - const entries = { - config: this.pdas.configAccount(), - custody: await this.custodyAccountAddress(config), - tokenProgram: await this.tokenProgram(config), - mint: await this.mintAccountAddress(config), - tokenAuthority: this.pdas.tokenAuthority(), - outboxRateLimit: this.pdas.outboxRateLimitAccount(), - wormhole: { - bridge: whAccs.wormholeBridge, - feeCollector: whAccs.wormholeFeeCollector, - sequence: whAccs.wormholeSequence, - program: this.wormholeId, - systemProgram: SystemProgram.programId, - clock: web3.SYSVAR_CLOCK_PUBKEY, - rent: web3.SYSVAR_RENT_PUBKEY, - }, - }; - - // collect all pubkeys in entries recursively - const collectPubkeys = (obj: any): Array => { - const pubkeys = new Array(); - for (const key in obj) { - const value = obj[key]; - if (value instanceof PublicKey) { - pubkeys.push(value); - } else if (typeof value === "object") { - pubkeys.push(...collectPubkeys(value)); - } - } - return pubkeys; - }; - const pubkeys = collectPubkeys(entries).map((pk) => pk.toBase58()); - - var existingLut: web3.AddressLookupTableAccount | null = null; - try { - existingLut = await this.getAddressLookupTable(false); - } catch { - // swallow errors here, it just means that lut doesn't exist - } - - if (existingLut !== null) { - const existingPubkeys = - existingLut.state.addresses?.map((a) => a.toBase58()) ?? []; - - // if pubkeys contains keys that are not in the existing LUT, we need to - // add them to the LUT - const missingPubkeys = pubkeys.filter( - (pk) => !existingPubkeys.includes(pk) - ); - - if (missingPubkeys.length === 0) { - return existingLut; - } - } - - const ix = await this.program.methods - .initializeLut(new BN(slot)) - .accountsStrict({ - payer: args.payer.publicKey, - authority: this.pdas.lutAuthority(), - lutAddress, - lut: this.pdas.lutAccount(), - lutProgram: AddressLookupTableProgram.programId, - systemProgram: SystemProgram.programId, - entries, - }) - .instruction(); - - const signers = [args.payer]; - await this.sendAndConfirmTransaction( - new Transaction().add(ix), - signers, - false - ); - - // NOTE: explicitly invalidate the cache. This is the only operation that - // modifies the LUT, so this is the only place we need to invalide. - return this.getAddressLookupTable(false); - } - - async transfer(args: { - payer: Keypair; - from: PublicKey; - fromAuthority: Keypair; - amount: BN; - recipientChain: Chain; - recipientAddress: ArrayLike; - shouldQueue: boolean; - outboxItem?: Keypair; - config?: Config; - }): Promise { - const config: Config = await this.getConfig(args.config); - - const outboxItem = args.outboxItem ?? Keypair.generate(); - - const txArgs = { - ...args, - payer: args.payer.publicKey, - fromAuthority: args.fromAuthority.publicKey, - outboxItem: outboxItem.publicKey, - config, - }; - - let transferIx: TransactionInstruction; - if (config.mode.locking != null) { - transferIx = await this.createTransferLockInstruction(txArgs); - } else if (config.mode.burning != null) { - transferIx = await this.createTransferBurnInstruction(txArgs); - } else { - // @ts-ignore - transferIx = exhaustive(config.mode); - } - const releaseIx: TransactionInstruction = - await this.createReleaseOutboundInstruction({ - payer: args.payer.publicKey, - outboxItem: outboxItem.publicKey, - revertOnDelay: !args.shouldQueue, - }); - - const signers = [args.payer, args.fromAuthority, outboxItem]; - - const transferArgs: TransferArgs = { - amount: args.amount, - recipientChain: { id: toChainId(args.recipientChain) }, - recipientAddress: Array.from(args.recipientAddress), - shouldQueue: args.shouldQueue, - }; - const approveIx = splToken.createApproveInstruction( - args.from, - this.pdas.sessionAuthority(args.fromAuthority.publicKey, transferArgs), - args.fromAuthority.publicKey, - BigInt(args.amount.toString()), - [], - config.tokenProgram - ); - const tx = new Transaction(); - tx.add(approveIx, transferIx, releaseIx); - await this.sendAndConfirmTransaction(tx, signers); - - return outboxItem.publicKey; - } - - /** - * Like `sendAndConfirmTransaction` but parses the anchor error code. - */ - private async sendAndConfirmTransaction( - tx: Transaction, - signers: Keypair[], - useLut = true - ): Promise { - const blockhash = - await this.program.provider.connection.getLatestBlockhash(); - const luts: AddressLookupTableAccount[] = []; - if (useLut) { - luts.push(await this.getAddressLookupTable()); - } - - try { - const messageV0 = new TransactionMessage({ - payerKey: signers[0]!.publicKey, - recentBlockhash: blockhash.blockhash, - instructions: tx.instructions, - }).compileToV0Message(luts); - - const transactionV0 = new VersionedTransaction(messageV0); - transactionV0.sign(signers); - - // The types for this function are wrong -- the type says it doesn't - // support version transactions, but it does 🤫 - // @ts-ignore - return await sendAndConfirmTransaction( - this.program.provider.connection, - transactionV0 - ); - } catch (err) { - throw translateError(err, this.errors); - } - } - - /** - * Creates a transfer_burn instruction. The `payer` and `fromAuthority` - * arguments must sign the transaction - */ - async createTransferBurnInstruction(args: { - payer: PublicKey; - from: PublicKey; - fromAuthority: PublicKey; - amount: BN; - recipientChain: Chain; - recipientAddress: ArrayLike; - outboxItem: PublicKey; - shouldQueue: boolean; - config?: Config; - }): Promise { - const config = await this.getConfig(args.config); - - if (await this.isPaused(config)) { - throw new Error("Contract is paused"); - } + const data = encoding.b64.decode(txSimulation.value.returnData?.data[0]!); + const parsed = deserializeLayout(programVersionLayout, data); + const version = encoding.bytes.decode(parsed.version); + if (version in IdlVersions) return version as IdlVersion; + else throw new Error("Unknown IDL version: " + version); + } + + export async function createTransferBurnInstruction( + program: Program>, + config: NttBindings.Config, + args: { + payer: PublicKey; + from: PublicKey; + fromAuthority: PublicKey; + amount: BN; + recipientChain: Chain; + recipientAddress: ArrayLike; + outboxItem: PublicKey; + shouldQueue: boolean; + }, + pdas?: Pdas + ): Promise { + if (config.paused) throw new Error("Contract is paused"); const chainId = toChainId(args.recipientChain); - const mint = await this.mintAccountAddress(config); - const transferArgs: TransferArgs = { amount: args.amount, recipientChain: { id: chainId }, @@ -437,32 +192,34 @@ export class NTT { shouldQueue: args.shouldQueue, }; - const transferIx = await this.program.methods + pdas = pdas ?? NTT.pdas(program.programId); + + const transferIx = await program.methods .transferBurn(transferArgs) .accountsStrict({ common: { payer: args.payer, - config: { config: this.pdas.configAccount() }, - mint, + config: { config: pdas.configAccount() }, + mint: config.mint, from: args.from, - tokenProgram: await this.tokenProgram(config), + tokenProgram: config.tokenProgram, outboxItem: args.outboxItem, - outboxRateLimit: this.pdas.outboxRateLimitAccount(), - custody: await this.custodyAccountAddress(config), + outboxRateLimit: pdas.outboxRateLimitAccount(), + custody: await custodyAccountAddress(pdas, config), systemProgram: SystemProgram.programId, }, - peer: this.pdas.peerAccount(args.recipientChain), - inboxRateLimit: this.pdas.inboxRateLimitAccount(args.recipientChain), - sessionAuthority: this.pdas.sessionAuthority( + peer: pdas.peerAccount(args.recipientChain), + inboxRateLimit: pdas.inboxRateLimitAccount(args.recipientChain), + sessionAuthority: pdas.sessionAuthority( args.fromAuthority, transferArgs ), - tokenAuthority: this.pdas.tokenAuthority(), + tokenAuthority: pdas.tokenAuthority(), }) .instruction(); const mintInfo = await splToken.getMint( - this.program.provider.connection, + program.provider.connection, config.mint, undefined, config.tokenProgram @@ -472,13 +229,10 @@ export class NTT { if (transferHook) { const source = args.from; const mint = config.mint; - const destination = await this.custodyAccountAddress(config); - const owner = this.pdas.sessionAuthority( - args.fromAuthority, - transferArgs - ); + const destination = await custodyAccountAddress(pdas, config); + const owner = pdas.sessionAuthority(args.fromAuthority, transferArgs); await addExtraAccountMetasForExecute( - this.program.provider.connection, + program.provider.connection, transferIx, transferHook.programId, source, @@ -501,25 +255,24 @@ export class NTT { * Creates a transfer_lock instruction. The `payer`, `fromAuthority`, and `outboxItem` * arguments must sign the transaction */ - async createTransferLockInstruction(args: { - payer: PublicKey; - from: PublicKey; - fromAuthority: PublicKey; - amount: BN; - recipientChain: Chain; - recipientAddress: ArrayLike; - shouldQueue: boolean; - outboxItem: PublicKey; - config?: Config; - }): Promise { - const config = await this.getConfig(args.config); - - if (await this.isPaused(config)) { - throw new Error("Contract is paused"); - } + export async function createTransferLockInstruction( + program: Program>, + config: NttBindings.Config, + args: { + payer: PublicKey; + from: PublicKey; + fromAuthority: PublicKey; + amount: BN; + recipientChain: Chain; + recipientAddress: ArrayLike; + shouldQueue: boolean; + outboxItem: PublicKey; + }, + pdas?: Pdas + ): Promise { + if (config.paused) throw new Error("Contract is paused"); const chainId = toChainId(args.recipientChain); - const mint = await this.mintAccountAddress(config); const transferArgs: TransferArgs = { amount: args.amount, @@ -528,22 +281,24 @@ export class NTT { shouldQueue: args.shouldQueue, }; - const transferIx = await this.program.methods + pdas = pdas ?? NTT.pdas(program.programId); + + const transferIx = await program.methods .transferLock(transferArgs) .accounts({ common: { payer: args.payer, - config: { config: this.pdas.configAccount() }, - mint, + config: { config: pdas.configAccount() }, + mint: config.mint, from: args.from, - tokenProgram: await this.tokenProgram(config), + tokenProgram: config.tokenProgram, outboxItem: args.outboxItem, - outboxRateLimit: this.pdas.outboxRateLimitAccount(), - custody: await this.custodyAccountAddress(config), + outboxRateLimit: pdas.outboxRateLimitAccount(), + custody: await custodyAccountAddress(pdas, config), }, - peer: this.pdas.peerAccount(args.recipientChain), - inboxRateLimit: this.pdas.inboxRateLimitAccount(args.recipientChain), - sessionAuthority: this.pdas.sessionAuthority( + peer: pdas.peerAccount(args.recipientChain), + inboxRateLimit: pdas.inboxRateLimitAccount(args.recipientChain), + sessionAuthority: pdas.sessionAuthority( args.fromAuthority, transferArgs ), @@ -551,7 +306,7 @@ export class NTT { .instruction(); const mintInfo = await splToken.getMint( - this.program.provider.connection, + program.provider.connection, config.mint, undefined, config.tokenProgram @@ -560,18 +315,14 @@ export class NTT { if (transferHook) { const source = args.from; - const mint = config.mint; - const destination = await this.custodyAccountAddress(config); - const owner = this.pdas.sessionAuthority( - args.fromAuthority, - transferArgs - ); + const destination = await custodyAccountAddress(pdas, config); + const owner = pdas.sessionAuthority(args.fromAuthority, transferArgs); await addExtraAccountMetasForExecute( - this.program.provider.connection, + program.provider.connection, transferIx, transferHook.programId, source, - mint, + config.mint, destination, owner, // TODO(csongor): compute the amount that's passed into transfer. @@ -589,106 +340,92 @@ export class NTT { /** * Creates a release_outbound instruction. The `payer` needs to sign the transaction. */ - async createReleaseOutboundInstruction(args: { - payer: PublicKey; - outboxItem: PublicKey; - revertOnDelay: boolean; - }): Promise { + export async function createReleaseOutboundInstruction( + program: Program>, + args: { + wormholeId: PublicKey; + payer: PublicKey; + outboxItem: PublicKey; + revertOnDelay: boolean; + }, + pdas?: Pdas + ): Promise { + pdas = pdas ?? NTT.pdas(program.programId); + const whAccs = utils.getWormholeDerivedAccounts( - this.program.programId, - this.wormholeId + program.programId, + args.wormholeId ); - return await this.program.methods + return await program.methods .releaseWormholeOutbound({ revertOnDelay: args.revertOnDelay, }) .accounts({ payer: args.payer, - config: { config: this.pdas.configAccount() }, + config: { config: pdas.configAccount() }, outboxItem: args.outboxItem, - wormholeMessage: this.pdas.wormholeMessageAccount(args.outboxItem), + wormholeMessage: pdas.wormholeMessageAccount(args.outboxItem), emitter: whAccs.wormholeEmitter, - transceiver: this.pdas.registeredTransceiver(this.program.programId), + transceiver: pdas.registeredTransceiver(program.programId), wormhole: { bridge: whAccs.wormholeBridge, feeCollector: whAccs.wormholeFeeCollector, sequence: whAccs.wormholeSequence, - program: this.wormholeId, + program: args.wormholeId, }, }) .instruction(); } - async releaseOutbound(args: { - payer: Keypair; - outboxItem: PublicKey; - revertOnDelay: boolean; - config?: Config; - }) { - if (await this.isPaused()) { - throw new Error("Contract is paused"); - } - - const txArgs = { - ...args, - payer: args.payer.publicKey, - }; - - const tx = new Transaction(); - tx.add(await this.createReleaseOutboundInstruction(txArgs)); - - const signers = [args.payer]; - return await this.sendAndConfirmTransaction(tx, signers); - } - // TODO: document that if recipient is provided, then the instruction can be // created before the inbox item is created (i.e. they can be put in the same tx) - async createReleaseInboundMintInstruction(args: { - payer: PublicKey; - chain: Chain; - nttMessage: NttMessage; - revertOnDelay: boolean; - recipient?: PublicKey; - config?: Config; - }): Promise { - const config = await this.getConfig(args.config); - - if (await this.isPaused(config)) { - throw new Error("Contract is paused"); - } + export async function createReleaseInboundMintInstruction( + program: Program>, + config: NttBindings.Config, + args: { + payer: PublicKey; + chain: Chain; + nttMessage: Ntt.Message; + revertOnDelay: boolean; + recipient?: PublicKey; + }, + pdas?: Pdas + ): Promise { + if (config.paused) throw new Error("Contract is paused"); + + pdas = pdas ?? NTT.pdas(program.programId); const recipientAddress = args.recipient ?? - (await this.getInboxItem(args.chain, args.nttMessage)).recipientAddress; + (await getInboxItem(program, args.chain, args.nttMessage)) + .recipientAddress; - const mint = await this.mintAccountAddress(config); - - const transferIx = await this.program.methods + const transferIx = await program.methods .releaseInboundMint({ revertOnDelay: args.revertOnDelay, }) .accountsStrict({ common: { payer: args.payer, - config: { config: this.pdas.configAccount() }, - inboxItem: this.pdas.inboxItemAccount(args.chain, args.nttMessage), + config: { config: pdas.configAccount() }, + inboxItem: pdas.inboxItemAccount(args.chain, args.nttMessage), recipient: getAssociatedTokenAddressSync( - mint, + config.mint, recipientAddress, true, config.tokenProgram ), - mint, - tokenAuthority: this.pdas.tokenAuthority(), + mint: config.mint, + tokenAuthority: pdas.tokenAuthority(), tokenProgram: config.tokenProgram, - custody: await this.custodyAccountAddress(config), + custody: await custodyAccountAddress(pdas, config), }, }) .instruction(); const mintInfo = await splToken.getMint( - this.program.provider.connection, + program.provider.connection, config.mint, undefined, config.tokenProgram @@ -696,7 +433,7 @@ export class NTT { const transferHook = splToken.getTransferHook(mintInfo); if (transferHook) { - const source = await this.custodyAccountAddress(config); + const source = await custodyAccountAddress(pdas, config); const mint = config.mint; const destination = getAssociatedTokenAddressSync( mint, @@ -704,9 +441,9 @@ export class NTT { true, config.tokenProgram ); - const owner = this.pdas.tokenAuthority(); + const owner = pdas.tokenAuthority(); await addExtraAccountMetasForExecute( - this.program.provider.connection, + program.provider.connection, transferIx, transferHook.programId, source, @@ -725,74 +462,53 @@ export class NTT { return transferIx; } - async releaseInboundMint(args: { - payer: Keypair; - chain: Chain; - nttMessage: NttMessage; - revertOnDelay: boolean; - config?: Config; - }): Promise { - if (await this.isPaused()) { - throw new Error("Contract is paused"); - } - - const txArgs = { - ...args, - payer: args.payer.publicKey, - }; - - const tx = new Transaction(); - tx.add(await this.createReleaseInboundMintInstruction(txArgs)); - - const signers = [args.payer]; - await this.sendAndConfirmTransaction(tx, signers); - } - - async createReleaseInboundUnlockInstruction(args: { - payer: PublicKey; - chain: Chain; - nttMessage: NttMessage; - revertOnDelay: boolean; - recipient?: PublicKey; - config?: Config; - }): Promise { - const config = await this.getConfig(args.config); - - if (await this.isPaused(config)) { - throw new Error("Contract is paused"); - } + export async function createReleaseInboundUnlockInstruction( + program: Program>, + config: NttBindings.Config, + args: { + payer: PublicKey; + chain: Chain; + nttMessage: Ntt.Message; + revertOnDelay: boolean; + recipient?: PublicKey; + }, + pdas?: Pdas + ) { + if (config.paused) throw new Error("Contract is paused"); const recipientAddress = args.recipient ?? - (await this.getInboxItem(args.chain, args.nttMessage)).recipientAddress; + (await NTT.getInboxItem(program, args.chain, args.nttMessage)) + .recipientAddress; - const mint = await this.mintAccountAddress(config); + pdas = pdas ?? NTT.pdas(program.programId); - const transferIx = await this.program.methods + const transferIx = await program.methods .releaseInboundUnlock({ revertOnDelay: args.revertOnDelay, }) .accountsStrict({ common: { payer: args.payer, - config: { config: this.pdas.configAccount() }, - inboxItem: this.pdas.inboxItemAccount(args.chain, args.nttMessage), + config: { config: pdas.configAccount() }, + inboxItem: pdas.inboxItemAccount(args.chain, args.nttMessage), recipient: getAssociatedTokenAddressSync( - mint, + config.mint, recipientAddress, true, config.tokenProgram ), - mint, - tokenAuthority: this.pdas.tokenAuthority(), + mint: config.mint, + tokenAuthority: pdas.tokenAuthority(), tokenProgram: config.tokenProgram, - custody: await this.custodyAccountAddress(config), + custody: await custodyAccountAddress(pdas, config), }, + custody: "", }) .instruction(); const mintInfo = await splToken.getMint( - this.program.provider.connection, + program.provider.connection, config.mint, undefined, config.tokenProgram @@ -800,7 +516,7 @@ export class NTT { const transferHook = splToken.getTransferHook(mintInfo); if (transferHook) { - const source = await this.custodyAccountAddress(config); + const source = await custodyAccountAddress(pdas, config); const mint = config.mint; const destination = getAssociatedTokenAddressSync( mint, @@ -808,9 +524,9 @@ export class NTT { true, config.tokenProgram ); - const owner = this.pdas.tokenAuthority(); + const owner = pdas.tokenAuthority(); await addExtraAccountMetasForExecute( - this.program.provider.connection, + program.provider.connection, transferIx, transferHook.programId, source, @@ -829,39 +545,20 @@ export class NTT { return transferIx; } - async releaseInboundUnlock(args: { - payer: Keypair; - chain: Chain; - nttMessage: NttMessage; - revertOnDelay: boolean; - config?: Config; - }): Promise { - if (await this.isPaused()) { - throw new Error("Contract is paused"); - } - - const txArgs = { - ...args, - payer: args.payer.publicKey, - }; - - const tx = new Transaction(); - tx.add(await this.createReleaseInboundUnlockInstruction(txArgs)); - - const signers = [args.payer]; - await this.sendAndConfirmTransaction(tx, signers); - } - - async setPeer(args: { - payer: Keypair; - owner: Keypair; - chain: Chain; - address: ArrayLike; - limit: BN; - tokenDecimals: number; - config?: Config; - }) { - const ix = await this.program.methods + export async function createSetPeerInstruction( + program: Program>, + args: { + payer: PublicKey; + owner: PublicKey; + chain: Chain; + address: ArrayLike; + limit: BN; + tokenDecimals: number; + }, + pdas?: Pdas + ) { + pdas = pdas ?? NTT.pdas(program.programId); + return await program.methods .setPeer({ chainId: { id: toChainId(args.chain) }, address: Array.from(args.address), @@ -869,290 +566,237 @@ export class NTT { tokenDecimals: args.tokenDecimals, }) .accounts({ - payer: args.payer.publicKey, - owner: args.owner.publicKey, - config: this.pdas.configAccount(), - peer: this.pdas.peerAccount(args.chain), - inboxRateLimit: this.pdas.inboxRateLimitAccount(args.chain), + payer: args.payer, + owner: args.owner, + config: pdas.configAccount(), + peer: pdas.peerAccount(args.chain), + inboxRateLimit: pdas.inboxRateLimitAccount(args.chain), }) .instruction(); - return await this.sendAndConfirmTransaction(new Transaction().add(ix), [ - args.payer, - args.owner, - ]); } - async setWormholeTransceiverPeer(args: { - payer: Keypair; - owner: Keypair; - chain: Chain; - address: ArrayLike; - config?: Config; - }) { - const ix = await this.program.methods + export async function setWormholeTransceiverPeer( + program: Program>, + args: { + wormholeId: PublicKey; + payer: PublicKey; + owner: PublicKey; + chain: Chain; + address: ArrayLike; + }, + pdas?: Pdas + ) { + pdas = pdas ?? NTT.pdas(program.programId); + const ix = await program.methods .setWormholePeer({ chainId: { id: toChainId(args.chain) }, address: Array.from(args.address), }) .accounts({ - payer: args.payer.publicKey, - owner: args.owner.publicKey, - config: this.pdas.configAccount(), - peer: this.pdas.transceiverPeerAccount(args.chain), + payer: args.payer, + owner: args.owner, + config: pdas.configAccount(), + peer: pdas.transceiverPeerAccount(args.chain), }) .instruction(); const wormholeMessage = Keypair.generate(); const whAccs = utils.getWormholeDerivedAccounts( - this.program.programId, - this.wormholeId + program.programId, + args.wormholeId ); - const broadcastIx = await this.program.methods + + const broadcastIx = await program.methods .broadcastWormholePeer({ chainId: toChainId(args.chain) }) .accounts({ - payer: args.payer.publicKey, - config: this.pdas.configAccount(), - peer: this.pdas.transceiverPeerAccount(args.chain), + payer: args.payer, + config: pdas.configAccount(), + peer: pdas.transceiverPeerAccount(args.chain), wormholeMessage: wormholeMessage.publicKey, - emitter: this.pdas.emitterAccount(), + emitter: pdas.emitterAccount(), wormhole: { bridge: whAccs.wormholeBridge, feeCollector: whAccs.wormholeFeeCollector, sequence: whAccs.wormholeSequence, - program: this.wormholeId, + program: args.wormholeId, }, }) .instruction(); - return await this.sendAndConfirmTransaction( - new Transaction().add(ix, broadcastIx), - [args.payer, args.owner, wormholeMessage] - ); - } - async registerTransceiver(args: { - payer: Keypair; - owner: Keypair; - transceiver: PublicKey; - }) { - const ix = await this.program.methods + return { + transaction: new Transaction().add(ix, broadcastIx), + signers: [args.payer, args.owner, wormholeMessage], + } as SolanaTransaction; + } + + export async function registerTransceiver( + program: Program>, + config: NttBindings.Config, + args: { + wormholeId: PublicKey; + payer: PublicKey; + owner: PublicKey; + transceiver: PublicKey; + }, + pdas?: Pdas + ) { + pdas = pdas ?? NTT.pdas(program.programId); + const ix = await program.methods .registerTransceiver() .accounts({ - payer: args.payer.publicKey, - owner: args.owner.publicKey, - config: this.pdas.configAccount(), + payer: args.payer, + owner: args.owner, + config: pdas.configAccount(), transceiver: args.transceiver, - registeredTransceiver: this.pdas.registeredTransceiver( - args.transceiver - ), + registeredTransceiver: pdas.registeredTransceiver(args.transceiver), }) .instruction(); const wormholeMessage = Keypair.generate(); const whAccs = utils.getWormholeDerivedAccounts( - this.program.programId, - this.wormholeId + program.programId, + args.wormholeId ); - const broadcastIx = await this.program.methods + const broadcastIx = await program.methods .broadcastWormholeId() .accounts({ - payer: args.payer.publicKey, - config: this.pdas.configAccount(), - mint: await this.mintAccountAddress(), + payer: args.payer, + config: pdas.configAccount(), + mint: config.mint, wormholeMessage: wormholeMessage.publicKey, - emitter: this.pdas.emitterAccount(), + emitter: pdas.emitterAccount(), wormhole: { bridge: whAccs.wormholeBridge, feeCollector: whAccs.wormholeFeeCollector, sequence: whAccs.wormholeSequence, - program: this.wormholeId, + program: args.wormholeId, }, }) .instruction(); - return await this.sendAndConfirmTransaction( - new Transaction().add(ix, broadcastIx), - [args.payer, args.owner, wormholeMessage] - ); + + return { + transaction: new Transaction().add(ix, broadcastIx), + signers: [args.payer, args.owner, wormholeMessage], + }; } - async setOutboundLimit(args: { owner: Keypair; chain: Chain; limit: BN }) { - const ix = await this.program.methods + export async function createSetOuboundLimitInstruction( + program: Program>, + args: { + owner: PublicKey; + chain: Chain; + limit: BN; + }, + pdas?: Pdas + ) { + pdas = pdas ?? NTT.pdas(program.programId); + return await program.methods .setOutboundLimit({ limit: args.limit, }) .accounts({ - owner: args.owner.publicKey, - config: this.pdas.configAccount(), - rateLimit: this.pdas.outboxRateLimitAccount(), + owner: args.owner, + config: pdas.configAccount(), + rateLimit: pdas.outboxRateLimitAccount(), }) .instruction(); - return this.sendAndConfirmTransaction(new Transaction().add(ix), [ - args.owner, - ]); } - async setInboundLimit(args: { owner: Keypair; chain: Chain; limit: BN }) { - const ix = await this.program.methods + export async function setInboundLimit( + program: Program>, + args: { + owner: PublicKey; + chain: Chain; + limit: BN; + }, + pdas?: Pdas + ) { + pdas = pdas ?? NTT.pdas(program.programId); + return await program.methods .setInboundLimit({ chainId: { id: toChainId(args.chain) }, limit: args.limit, }) .accounts({ - owner: args.owner.publicKey, - config: this.pdas.configAccount(), - rateLimit: this.pdas.inboxRateLimitAccount(args.chain), + owner: args.owner, + config: pdas.configAccount(), + rateLimit: pdas.inboxRateLimitAccount(args.chain), }) .instruction(); - return this.sendAndConfirmTransaction(new Transaction().add(ix), [ - args.owner, - ]); } - async createReceiveWormholeMessageInstruction(args: { - payer: PublicKey; - vaa: Uint8Array; - config?: Config; - }): Promise { - const config = await this.getConfig(args.config); - - if (await this.isPaused(config)) { - throw new Error("Contract is paused"); + export async function createReceiveWormholeMessageInstruction( + program: Program>, + config: NttBindings.Config, + args: { + wormholeId: PublicKey; + payer: PublicKey; + vaa: Uint8Array; } + ): Promise { + if (config.paused) throw new Error("Contract is paused"); + + const pdas = NTT.pdas(program.programId); const wormholeNTT = deserialize("Ntt:WormholeTransfer", args.vaa); const nttMessage = wormholeNTT.payload.nttManagerPayload; const chain = wormholeNTT.emitterChain; - const transceiverPeer = this.pdas.transceiverPeerAccount(chain); + const transceiverPeer = pdas.transceiverPeerAccount(chain); - return await this.program.methods + return await program.methods .receiveWormholeMessage() .accounts({ payer: args.payer, - config: { config: this.pdas.configAccount() }, + config: { config: pdas.configAccount() }, peer: transceiverPeer, vaa: utils.derivePostedVaaKey( - this.wormholeId, + args.wormholeId, Buffer.from(wormholeNTT.hash) ), - transceiverMessage: this.pdas.transceiverMessageAccount( + transceiverMessage: pdas.transceiverMessageAccount( chain, nttMessage.id ), }) .instruction(); } - - async createRedeemInstruction(args: { - payer: PublicKey; - vaa: Uint8Array; - config?: Config; - }): Promise { - const config = await this.getConfig(args.config); - - if (await this.isPaused(config)) { - throw new Error("Contract is paused"); + export async function createRedeemInstruction( + program: Program>, + config: NttBindings.Config, + args: { + payer: PublicKey; + vaa: Uint8Array; } + ): Promise { + if (config.paused) throw new Error("Contract is paused"); + + const pdas = NTT.pdas(program.programId); const wormholeNTT = deserialize("Ntt:WormholeTransfer", args.vaa); const nttMessage = wormholeNTT.payload.nttManagerPayload; - // NOTE: we do an 'as ChainId' cast here, which is generally unsafe. - // TODO: explain why this is fine here const chain = wormholeNTT.emitterChain; - const nttManagerPeer = this.pdas.peerAccount(chain); - const inboxRateLimit = this.pdas.inboxRateLimitAccount(chain); - - return await this.program.methods + return await program.methods .redeem({}) .accounts({ payer: args.payer, - config: this.pdas.configAccount(), - peer: nttManagerPeer, - transceiverMessage: this.pdas.transceiverMessageAccount( + config: pdas.configAccount(), + peer: pdas.peerAccount(chain), + transceiverMessage: pdas.transceiverMessageAccount( chain, nttMessage.id ), - transceiver: this.pdas.registeredTransceiver(this.program.programId), - mint: await this.mintAccountAddress(config), - inboxItem: this.pdas.inboxItemAccount(chain, nttMessage), - inboxRateLimit, - outboxRateLimit: this.pdas.outboxRateLimitAccount(), + transceiver: pdas.registeredTransceiver(program.programId), + mint: config.mint, + inboxItem: pdas.inboxItemAccount(chain, nttMessage), + inboxRateLimit: pdas.inboxRateLimitAccount(chain), + outboxRateLimit: pdas.outboxRateLimitAccount(), }) .instruction(); } - /** - * Redeems a VAA. - * - * @returns Whether the transfer was released. If the transfer was delayed, - * this will be false. In that case, a subsequent call to - * `releaseInboundMint` or `releaseInboundUnlock` will release the - * transfer after the delay (24h). - */ - async redeem(args: { - payer: Keypair; - vaa: Uint8Array; - config?: Config; - }): Promise { - const config = await this.getConfig(args.config); - - const redeemArgs = { - ...args, - payer: args.payer.publicKey, - }; - - const wormholeNTT = deserialize("Ntt:WormholeTransfer", args.vaa); - const nttMessage = wormholeNTT.payload.nttManagerPayload; - - const chain = wormholeNTT.emitterChain; - - // Here we create a transaction with three instructions: - // 1. receive wormhole messsage (vaa) - // 1. redeem - // 2. releaseInboundMint or releaseInboundUnlock (depending on mode) - // - // The first instruction verifies the VAA. - // The second instruction places the transfer in the inbox, then the third instruction - // releases it. - // - // In case the redeemed amount exceeds the remaining inbound rate limit capacity, - // the transaction gets delayed. If this happens, the second instruction will not actually - // be able to release the transfer yet. - // To make sure the transaction still succeeds, we set revertOnDelay to false, which will - // just make the second instruction a no-op in case the transfer is delayed. - - const tx = new Transaction(); - tx.add(await this.createReceiveWormholeMessageInstruction(redeemArgs)); - tx.add(await this.createRedeemInstruction(redeemArgs)); - - const releaseArgs = { - ...args, - payer: args.payer.publicKey, - nttMessage, - recipient: new PublicKey( - nttMessage.payload.recipientAddress.toUint8Array() - ), - chain: chain, - revertOnDelay: false, - config: config, - }; - - if (config.mode.locking != null) { - tx.add(await this.createReleaseInboundUnlockInstruction(releaseArgs)); - } else { - tx.add(await this.createReleaseInboundMintInstruction(releaseArgs)); - } - - const signers = [args.payer]; - await this.sendAndConfirmTransaction(tx, signers); - - // Let's check if the transfer was released - const inboxItem = await this.getInboxItem(chain, nttMessage); - return inboxItem.releaseStatus.released !== undefined; - } - // Account access - /** * Fetches the Config account from the contract. * @@ -1161,77 +805,44 @@ export class NTT { * accessor functions are used, the config can just be queried * once and passed around. */ - async getConfig(config?: Config): Promise { - return ( - config ?? - (await this.program.account.config.fetch(this.pdas.configAccount())) - ); - } - - async isPaused(config?: Config): Promise { - return (await this.getConfig(config)).paused; - } - - async mintAccountAddress(config?: Config): Promise { - return (await this.getConfig(config)).mint; - } - - async tokenProgram(config?: Config): Promise { - return (await this.getConfig(config)).tokenProgram; - } - - async getInboxItem(chain: Chain, nttMessage: NttMessage): Promise { - return await this.program.account.inboxItem.fetch( - this.pdas.inboxItemAccount(chain, nttMessage) + export async function getConfig( + program: Program>, + pdas: Pdas + ): Promise> { + return await program.account.config.fetch(pdas.configAccount()); + } + + export async function getInboxItem( + program: Program>, + fromChain: Chain, + nttMessage: Ntt.Message + ): Promise> { + return await program.account.inboxItem.fetch( + NTT.pdas(program.programId).inboxItemAccount(fromChain, nttMessage) ); } - async getAddressLookupTable( - useCache = true - ): Promise { - if (!useCache || !this.addressLookupTable) { - const lut = await this.program.account.lut.fetchNullable( - this.pdas.lutAccount() - ); - if (!lut) { - throw new Error( - "Address lookup table not found. Did you forget to call initializeLUT?" - ); - } - const response = - await this.program.provider.connection.getAddressLookupTable( - lut.address - ); - this.addressLookupTable = response.value; - } - if (!this.addressLookupTable) { - throw new Error( - "Address lookup table not found. Did you forget to call initializeLUT?" - ); - } - return this.addressLookupTable; - } - /** * Returns the address of the custody account. If the config is available * (i.e. the program is initialised), the mint is derived from the config. * Otherwise, the mint must be provided. */ - async custodyAccountAddress( - configOrMint: Config | PublicKey, + export async function custodyAccountAddress( + pdas: Pdas, + configOrMint: NttBindings.Config | PublicKey, tokenProgram = splToken.TOKEN_PROGRAM_ID ): Promise { if (configOrMint instanceof PublicKey) { return splToken.getAssociatedTokenAddress( configOrMint, - this.pdas.tokenAuthority(), + pdas.tokenAuthority(), true, tokenProgram ); } else { return splToken.getAssociatedTokenAddress( configOrMint.mint, - this.pdas.tokenAuthority(), + pdas.tokenAuthority(), true, configOrMint.tokenProgram ); @@ -1239,10 +850,6 @@ export class NTT { } } -function exhaustive(_: never): A { - throw new Error("Impossible"); -} - /** * TODO: this is copied from @solana/spl-token, because the most recent released * version (0.4.3) is broken (does object equality instead of structural on the pubkey) diff --git a/solana/ts/lib/utils.ts b/solana/ts/lib/utils.ts index 7f495da20..3d613b5c2 100644 --- a/solana/ts/lib/utils.ts +++ b/solana/ts/lib/utils.ts @@ -3,17 +3,9 @@ import { Layout, encoding, } from "@wormhole-foundation/sdk-base"; - import { BN } from "@coral-xyz/anchor"; import { PublicKey, PublicKeyInitData } from "@solana/web3.js"; -import { - Chain, - ChainId, - keccak256, - toChainId, -} from "@wormhole-foundation/sdk-connect"; -import { Ntt } from "@wormhole-foundation/sdk-definitions-ntt"; -import { TransferArgs } from "./ntt.js"; +import { Chain, ChainId, toChainId } from "@wormhole-foundation/sdk-connect"; export const BPF_LOADER_UPGRADEABLE_PROGRAM_ID = new PublicKey( "BPFLoaderUpgradeab1e11111111111111111111111" @@ -86,64 +78,6 @@ export function derivePda( export const chainToBytes = (chain: Chain | ChainId) => encoding.bignum.toBytes(toChainId(chain), 2); -export const nttAddresses = (programId: PublicKeyInitData) => { - const configAccount = (): PublicKey => derivePda("config", programId); - const emitterAccount = (): PublicKey => derivePda("emitter", programId); - const inboxRateLimitAccount = (chain: Chain): PublicKey => - derivePda(["inbox_rate_limit", chainToBytes(chain)], programId); - const inboxItemAccount = (chain: Chain, nttMessage: Ntt.Message): PublicKey => - derivePda(["inbox_item", Ntt.messageDigest(chain, nttMessage)], programId); - const outboxRateLimitAccount = (): PublicKey => - derivePda("outbox_rate_limit", programId); - const tokenAuthority = (): PublicKey => - derivePda("token_authority", programId); - const peerAccount = (chain: Chain): PublicKey => - derivePda(["peer", chainToBytes(chain)], programId); - const transceiverPeerAccount = (chain: Chain): PublicKey => - derivePda(["transceiver_peer", chainToBytes(chain)], programId); - const registeredTransceiver = (transceiver: PublicKey): PublicKey => - derivePda(["registered_transceiver", transceiver.toBytes()], programId); - const transceiverMessageAccount = (chain: Chain, id: Uint8Array): PublicKey => - derivePda(["transceiver_message", chainToBytes(chain), id], programId); - const wormholeMessageAccount = (outboxItem: PublicKey): PublicKey => - derivePda(["message", outboxItem.toBytes()], programId); - const lutAccount = (): PublicKey => derivePda("lut", programId); - const lutAuthority = (): PublicKey => derivePda("lut_authority", programId); - const sessionAuthority = (sender: PublicKey, args: TransferArgs): PublicKey => - derivePda( - [ - "session_authority", - sender.toBytes(), - keccak256( - encoding.bytes.concat( - encoding.bytes.zpad(new Uint8Array(args.amount.toBuffer()), 8), - chainToBytes(args.recipientChain.id), - new Uint8Array(args.recipientAddress), - new Uint8Array([args.shouldQueue ? 1 : 0]) - ) - ), - ], - programId - ); - - return { - configAccount, - outboxRateLimitAccount, - inboxRateLimitAccount, - inboxItemAccount, - sessionAuthority, - tokenAuthority, - emitterAccount, - wormholeMessageAccount, - peerAccount, - transceiverPeerAccount, - transceiverMessageAccount, - registeredTransceiver, - lutAccount, - lutAuthority, - }; -}; - export const quoterAddresses = (programId: PublicKeyInitData) => { const instanceAccount = () => derivePda("instance", programId); const registeredNttAccount = (nttProgramId: PublicKey) => @@ -159,3 +93,15 @@ export const quoterAddresses = (programId: PublicKeyInitData) => { registeredNttAccount, }; }; + +// // The `translateError` function expects this format, but the idl gives us a +// // different one, so we preprocess the idl and store the expected format. +// // NOTE: I'm sure there's a function within anchor that does this, but I +// // couldn't find it. +// private processErrors(): Map { +// const errors = this.program.idl.errors; +// const result: Map = new Map(); +// errors.forEach((entry) => result.set(entry.code, entry.msg)); +// return result; +// } +// // View functions diff --git a/solana/ts/sdk/index.ts b/solana/ts/sdk/index.ts index 62d737a9b..b34aa9a57 100644 --- a/solana/ts/sdk/index.ts +++ b/solana/ts/sdk/index.ts @@ -5,5 +5,5 @@ import "@wormhole-foundation/sdk-definitions-ntt"; registerProtocol(_platform, "Ntt", SolanaNtt); -export * as idl from "./anchor-idl/index.js"; +export * as idl from "../lib/anchor-idl/index.js"; export * from "./ntt.js"; diff --git a/solana/ts/sdk/ntt.ts b/solana/ts/sdk/ntt.ts index a08128f7c..97fcca5b4 100644 --- a/solana/ts/sdk/ntt.ts +++ b/solana/ts/sdk/ntt.ts @@ -23,9 +23,6 @@ import { Network, TokenAddress, UnsignedTransaction, - deserializeLayout, - encoding, - rpc, toChain, toChainId, } from "@wormhole-foundation/sdk-connect"; @@ -46,22 +43,16 @@ import { utils, } from "@wormhole-foundation/sdk-solana-core"; import BN from "bn.js"; -import { NttQuoter, WEI_PER_GWEI } from "../lib/index.js"; +import { NTT, NttQuoter, WEI_PER_GWEI } from "../lib/index.js"; import { BPF_LOADER_UPGRADEABLE_PROGRAM_ID, TransferArgs, addExtraAccountMetasForExecute, nttAddresses, programDataAddress, - programVersionLayout, } from "./utils.js"; -import { - IdlVersion, - IdlVersions, - NttBindings, - getNttProgram, -} from "./bindings.js"; +import { IdlVersion, NttBindings, getNttProgram } from "../lib/bindings.js"; export class SolanaNtt implements Ntt @@ -80,7 +71,7 @@ export class SolanaNtt readonly chain: C, readonly connection: Connection, readonly contracts: Contracts & { ntt?: Ntt.Contracts }, - readonly version: string = "default" + readonly version: string = "2.0.0" ) { if (!contracts.ntt) throw new Error("Ntt contracts not found"); @@ -153,7 +144,7 @@ export class SolanaNtt ); } - async getConfig(): Promise { + async getConfig(): Promise> { this.config = this.config ?? (await this.program.account.config.fetch(this.pdas.configAccount())); @@ -178,56 +169,16 @@ export class SolanaNtt contracts: Contracts & { ntt: Ntt.Contracts }, sender?: AccountAddress ): Promise { - // the anchor library has a built-in method to read view functions. However, - // it requires a signer, which would trigger a wallet prompt on the frontend. - // Instead, we manually construct a versioned transaction and call the - // simulate function with sigVerify: false below. - // - // This way, the simulation won't require a signer, but it still requires - // the pubkey of an account that has some lamports in it (since the - // simulation checks if the account has enough money to pay for the transaction). - // - // It's a little unfortunate but it's the best we can do. - - if (!sender) { - const address = - connection.rpcEndpoint === rpc.rpcAddress("Devnet", "Solana") - ? "6sbzC1eH4FTujJXWj51eQe25cYvr4xfXbJ1vAj7j2k5J" // The CI pubkey, funded on local network - : "Hk3SdYTJFpawrvRz4qRztuEt2SqoCG7BGj2yJfDJSFbJ"; // The default pubkey is funded on mainnet and devnet we need a funded account to simulate the transaction below - sender = new SolanaAddress(address); - } - - const senderAddress = new SolanaAddress(sender).unwrap(); - - const program = getNttProgram(connection, contracts.ntt.manager, "default"); - - const ix = await program.methods.version().accountsStrict({}).instruction(); - const latestBlockHash = - await program.provider.connection.getLatestBlockhash(); - - const msg = new TransactionMessage({ - payerKey: senderAddress, - recentBlockhash: latestBlockHash.blockhash, - instructions: [ix], - }).compileToV0Message(); - - const tx = new VersionedTransaction(msg); - - const txSimulation = await program.provider.connection.simulateTransaction( - tx, - { sigVerify: false } + return NTT.getVersion( + connection, + new PublicKey(contracts.ntt.manager!), + sender ? new SolanaAddress(sender).unwrap() : undefined ); - - const data = encoding.b64.decode(txSimulation.value.returnData?.data[0]!); - const parsed = deserializeLayout(programVersionLayout, data); - const version = encoding.bytes.decode(parsed.version); - if (version in IdlVersions) return version as IdlVersion; - else throw new Error("Unknown IDL version: " + version); } async *initialize(args: { - payer: Keypair; - owner: Keypair; + payer: PublicKey; + owner: PublicKey; chain: Chain; mint: PublicKey; outboundLimit: bigint; @@ -248,8 +199,8 @@ export class SolanaNtt const ix = await this.program.methods .initialize({ chainId, limit: limit, mode }) .accountsStrict({ - payer: args.payer.publicKey, - deployer: args.owner.publicKey, + payer: args.payer, + deployer: args.owner, programData: programDataAddress(this.program.programId), config: this.pdas.configAccount(), mint: args.mint, @@ -264,7 +215,7 @@ export class SolanaNtt .instruction(); const tx = new Transaction(); - tx.feePayer = args.payer.publicKey; + tx.feePayer = args.payer; tx.add(ix); yield this.createUnsignedTx( { transaction: tx, signers: [] }, @@ -276,7 +227,7 @@ export class SolanaNtt // This function should be called after each upgrade. If there's nothing to // do, it won't actually submit a transaction, so it's cheap to call. - async *initializeOrUpdateLUT(args: { payer: Keypair }) { + async *initializeOrUpdateLUT(args: { payer: PublicKey }) { if (this.version === "1.0.0") return; const program = this.program as Program< NttBindings.NativeTokenTransfer<"2.0.0"> @@ -287,7 +238,7 @@ export class SolanaNtt const [_, lutAddress] = web3.AddressLookupTableProgram.createLookupTable({ authority: this.pdas.lutAuthority(), - payer: args.payer.publicKey, + payer: args.payer, recentSlot: slot, }); @@ -355,7 +306,7 @@ export class SolanaNtt const ix = await program.methods .initializeLut(new BN(slot)) .accountsStrict({ - payer: args.payer.publicKey, + payer: args.payer, authority: this.pdas.lutAuthority(), lutAddress, lut: this.pdas.lutAccount(), @@ -366,7 +317,7 @@ export class SolanaNtt .instruction(); const tx = new Transaction().add(ix); - tx.feePayer = args.payer.publicKey; + tx.feePayer = args.payer; yield this.createUnsignedTx({ transaction: tx }, "Ntt.InitializeLUT"); } @@ -806,7 +757,7 @@ export class SolanaNtt from: PublicKey; fromAuthority: PublicKey; outboxItem: PublicKey; - config?: NttBindings.Config; + config?: NttBindings.Config; }): Promise { const config = await this.getConfig(); if (config.paused) throw new Error("Contract is paused"); @@ -1322,7 +1273,7 @@ export class SolanaNtt * Otherwise, the mint must be provided. */ async custodyAccountAddress( - configOrMint: NttBindings.Config | PublicKey, + configOrMint: NttBindings.Config | PublicKey, tokenProgram = splToken.TOKEN_PROGRAM_ID ): Promise { if (configOrMint instanceof PublicKey) { From 0260c342346c373ed1d4a16c10bd0312a6e5235e Mon Sep 17 00:00:00 2001 From: Ben Guidarelli Date: Fri, 3 May 2024 19:46:27 -0400 Subject: [PATCH 02/14] replace transfer instructions --- solana/ts/lib/ntt.ts | 103 +++++++------- solana/ts/sdk/ntt.ts | 330 +++++-------------------------------------- 2 files changed, 83 insertions(+), 350 deletions(-) diff --git a/solana/ts/lib/ntt.ts b/solana/ts/lib/ntt.ts index 01409ca0b..aa5bbdbde 100644 --- a/solana/ts/lib/ntt.ts +++ b/solana/ts/lib/ntt.ts @@ -15,12 +15,14 @@ import { } from "@solana/web3.js"; import { Chain, + ChainAddress, ChainId, deserialize, deserializeLayout, encoding, keccak256, rpc, + toChain, toChainId, } from "@wormhole-foundation/sdk-connect"; @@ -38,14 +40,29 @@ import { } from "./bindings.js"; import { chainToBytes, derivePda } from "./utils.js"; -export interface TransferArgs { - amount: BN; - recipientChain: { id: ChainId }; - recipientAddress: number[]; - shouldQueue: boolean; -} - export namespace NTT { + export interface TransferArgs { + amount: BN; + recipientChain: { id: ChainId }; + recipientAddress: number[]; + shouldQueue: boolean; + } + + export function transferArgs( + amount: bigint, + recipient: ChainAddress, + shouldQueue: boolean + ): TransferArgs { + return { + amount: new BN(amount.toString()), + recipientChain: { id: toChainId(recipient.chain) }, + recipientAddress: Array.from( + recipient.address.toUniversalAddress().toUint8Array() + ), + shouldQueue: shouldQueue, + }; + } + export type Pdas = ReturnType; export const pdas = (programId: PublicKeyInitData) => { const configAccount = (): PublicKey => derivePda("config", programId); @@ -174,28 +191,16 @@ export namespace NTT { payer: PublicKey; from: PublicKey; fromAuthority: PublicKey; - amount: BN; - recipientChain: Chain; - recipientAddress: ArrayLike; + transferArgs: TransferArgs; outboxItem: PublicKey; - shouldQueue: boolean; }, pdas?: Pdas ): Promise { - if (config.paused) throw new Error("Contract is paused"); - - const chainId = toChainId(args.recipientChain); - const transferArgs: TransferArgs = { - amount: args.amount, - recipientChain: { id: chainId }, - recipientAddress: Array.from(args.recipientAddress), - shouldQueue: args.shouldQueue, - }; - pdas = pdas ?? NTT.pdas(program.programId); + const recipientChain = toChain(args.transferArgs.recipientChain.id); const transferIx = await program.methods - .transferBurn(transferArgs) + .transferBurn(args.transferArgs) .accountsStrict({ common: { payer: args.payer, @@ -208,11 +213,11 @@ export namespace NTT { custody: await custodyAccountAddress(pdas, config), systemProgram: SystemProgram.programId, }, - peer: pdas.peerAccount(args.recipientChain), - inboxRateLimit: pdas.inboxRateLimitAccount(args.recipientChain), + peer: pdas.peerAccount(recipientChain), + inboxRateLimit: pdas.inboxRateLimitAccount(recipientChain), sessionAuthority: pdas.sessionAuthority( args.fromAuthority, - transferArgs + args.transferArgs ), tokenAuthority: pdas.tokenAuthority(), }) @@ -230,7 +235,10 @@ export namespace NTT { const source = args.from; const mint = config.mint; const destination = await custodyAccountAddress(pdas, config); - const owner = pdas.sessionAuthority(args.fromAuthority, transferArgs); + const owner = pdas.sessionAuthority( + args.fromAuthority, + args.transferArgs + ); await addExtraAccountMetasForExecute( program.provider.connection, transferIx, @@ -262,29 +270,19 @@ export namespace NTT { payer: PublicKey; from: PublicKey; fromAuthority: PublicKey; - amount: BN; - recipientChain: Chain; - recipientAddress: ArrayLike; - shouldQueue: boolean; + transferArgs: NTT.TransferArgs; outboxItem: PublicKey; }, pdas?: Pdas ): Promise { if (config.paused) throw new Error("Contract is paused"); - const chainId = toChainId(args.recipientChain); - - const transferArgs: TransferArgs = { - amount: args.amount, - recipientChain: { id: chainId }, - recipientAddress: Array.from(args.recipientAddress), - shouldQueue: args.shouldQueue, - }; - pdas = pdas ?? NTT.pdas(program.programId); + const chain = toChain(args.transferArgs.recipientChain.id); + const transferIx = await program.methods - .transferLock(transferArgs) + .transferLock(args.transferArgs) .accounts({ common: { payer: args.payer, @@ -296,11 +294,11 @@ export namespace NTT { outboxRateLimit: pdas.outboxRateLimitAccount(), custody: await custodyAccountAddress(pdas, config), }, - peer: pdas.peerAccount(args.recipientChain), - inboxRateLimit: pdas.inboxRateLimitAccount(args.recipientChain), + peer: pdas.peerAccount(chain), + inboxRateLimit: pdas.inboxRateLimitAccount(chain), sessionAuthority: pdas.sessionAuthority( args.fromAuthority, - transferArgs + args.transferArgs ), }) .instruction(); @@ -316,7 +314,10 @@ export namespace NTT { if (transferHook) { const source = args.from; const destination = await custodyAccountAddress(pdas, config); - const owner = pdas.sessionAuthority(args.fromAuthority, transferArgs); + const owner = pdas.sessionAuthority( + args.fromAuthority, + args.transferArgs + ); await addExtraAccountMetasForExecute( program.provider.connection, transferIx, @@ -392,8 +393,6 @@ export namespace NTT { }, pdas?: Pdas ): Promise { - if (config.paused) throw new Error("Contract is paused"); - pdas = pdas ?? NTT.pdas(program.programId); const recipientAddress = @@ -474,8 +473,6 @@ export namespace NTT { }, pdas?: Pdas ) { - if (config.paused) throw new Error("Contract is paused"); - const recipientAddress = args.recipient ?? (await NTT.getInboxItem(program, args.chain, args.nttMessage)) @@ -727,15 +724,12 @@ export namespace NTT { export async function createReceiveWormholeMessageInstruction( program: Program>, - config: NttBindings.Config, args: { wormholeId: PublicKey; payer: PublicKey; vaa: Uint8Array; } ): Promise { - if (config.paused) throw new Error("Contract is paused"); - const pdas = NTT.pdas(program.programId); const wormholeNTT = deserialize("Ntt:WormholeTransfer", args.vaa); @@ -767,11 +761,10 @@ export namespace NTT { args: { payer: PublicKey; vaa: Uint8Array; - } + }, + pdas?: Pdas ): Promise { - if (config.paused) throw new Error("Contract is paused"); - - const pdas = NTT.pdas(program.programId); + pdas = pdas ?? NTT.pdas(program.programId); const wormholeNTT = deserialize("Ntt:WormholeTransfer", args.vaa); const nttMessage = wormholeNTT.payload.nttManagerPayload; diff --git a/solana/ts/sdk/ntt.ts b/solana/ts/sdk/ntt.ts index 97fcca5b4..090dd9634 100644 --- a/solana/ts/sdk/ntt.ts +++ b/solana/ts/sdk/ntt.ts @@ -23,7 +23,6 @@ import { Network, TokenAddress, UnsignedTransaction, - toChain, toChainId, } from "@wormhole-foundation/sdk-connect"; import { @@ -46,9 +45,7 @@ import BN from "bn.js"; import { NTT, NttQuoter, WEI_PER_GWEI } from "../lib/index.js"; import { BPF_LOADER_UPGRADEABLE_PROGRAM_ID, - TransferArgs, addExtraAccountMetasForExecute, - nttAddresses, programDataAddress, } from "./utils.js"; @@ -58,7 +55,7 @@ export class SolanaNtt implements Ntt { core: SolanaWormholeCore; - pdas: ReturnType; + pdas: NTT.Pdas; program: Program>; @@ -94,7 +91,7 @@ export class SolanaNtt connection, contracts ); - this.pdas = nttAddresses(this.program.programId); + this.pdas = NTT.pdas(this.program.programId); } async isRelayingAvailable(destination: Chain): Promise { @@ -145,9 +142,7 @@ export class SolanaNtt } async getConfig(): Promise> { - this.config = - this.config ?? - (await this.program.account.config.fetch(this.pdas.configAccount())); + this.config = this.config ?? (await NTT.getConfig(this.program, this.pdas)); return this.config!; } @@ -484,11 +479,7 @@ export class SolanaNtt const fromAuthority = payerAddress; const from = await this.getTokenAccount(fromAuthority); - const transferArgs: TransferArgs = { - amount: amount, - recipient: destination, - shouldQueue: options.queue, - }; + const transferArgs = NTT.transferArgs(amount, destination, options.queue); const txArgs = { transferArgs, @@ -496,31 +487,46 @@ export class SolanaNtt from, fromAuthority, outboxItem: outboxItem.publicKey, - config, }; - const [approveIx, transferIx, releaseIx] = await Promise.all([ - splToken.createApproveInstruction( - from, - this.pdas.sessionAuthority(fromAuthority, transferArgs), - fromAuthority, - amount, - [], - config.tokenProgram - ), + const approveIx = splToken.createApproveInstruction( + from, + this.pdas.sessionAuthority(fromAuthority, transferArgs), + fromAuthority, + amount, + [], + config.tokenProgram + ); + + const transferIx = config.mode.locking != null - ? this.createTransferLockInstruction(txArgs) - : this.createTransferBurnInstruction(txArgs), - this.createReleaseOutboundInstruction({ + ? NTT.createTransferLockInstruction( + this.program, + config, + txArgs, + this.pdas + ) + : NTT.createTransferBurnInstruction( + this.program, + config, + txArgs, + this.pdas + ); + + const releaseIx = NTT.createReleaseOutboundInstruction( + this.program, + { payer: payerAddress, outboxItem: outboxItem.publicKey, revertOnDelay: !options.queue, - }), - ]); + wormholeId: new PublicKey(this.core.address), + }, + this.pdas + ); const tx = new Transaction(); tx.feePayer = payerAddress; - tx.add(approveIx, transferIx, releaseIx); + tx.add(approveIx, ...(await Promise.all([transferIx, releaseIx]))); if (options.automatic) { if (!this.quoter) @@ -751,272 +757,6 @@ export class SolanaNtt return xfer; } - async createTransferLockInstruction(args: { - transferArgs: TransferArgs; - payer: PublicKey; - from: PublicKey; - fromAuthority: PublicKey; - outboxItem: PublicKey; - config?: NttBindings.Config; - }): Promise { - const config = await this.getConfig(); - if (config.paused) throw new Error("Contract is paused"); - - const sessionAuthority = this.pdas.sessionAuthority( - args.fromAuthority, - args.transferArgs - ); - - const recipientChain = args.transferArgs.recipient.chain; - - let transferIx; - if (this.program.idl.version === "1.0.0") { - transferIx = await ( - this.program as Program> - ).methods - .transferLock({ - recipientChain: { id: toChainId(recipientChain) }, - amount: new BN(args.transferArgs.amount.toString()), - recipientAddress: Array.from( - args.transferArgs.recipient.address - .toUniversalAddress() - .toUint8Array() - ), - shouldQueue: args.transferArgs.shouldQueue, - }) - .accountsStrict({ - common: { - payer: args.payer, - config: { config: this.pdas.configAccount() }, - mint: config.mint, - from: args.from, - tokenProgram: config.tokenProgram, - outboxItem: args.outboxItem, - outboxRateLimit: this.pdas.outboxRateLimitAccount(), - systemProgram: SystemProgram.programId, - }, - peer: this.pdas.peerAccount(recipientChain), - inboxRateLimit: this.pdas.inboxRateLimitAccount(recipientChain), - sessionAuthority: sessionAuthority, - custody: config.custody, - }) - .instruction(); - } else { - transferIx = await ( - this.program as Program> - ).methods - .transferLock({ - recipientChain: { id: toChainId(recipientChain) }, - amount: new BN(args.transferArgs.amount.toString()), - recipientAddress: Array.from( - args.transferArgs.recipient.address - .toUniversalAddress() - .toUint8Array() - ), - shouldQueue: args.transferArgs.shouldQueue, - }) - .accountsStrict({ - common: { - payer: args.payer, - config: { config: this.pdas.configAccount() }, - mint: config.mint, - from: args.from, - tokenProgram: config.tokenProgram, - outboxItem: args.outboxItem, - outboxRateLimit: this.pdas.outboxRateLimitAccount(), - systemProgram: SystemProgram.programId, - custody: config.custody, - }, - peer: this.pdas.peerAccount(recipientChain), - inboxRateLimit: this.pdas.inboxRateLimitAccount(recipientChain), - sessionAuthority: sessionAuthority, - }) - .instruction(); - } - - const mintInfo = await splToken.getMint( - this.connection, - config.mint, - undefined, - config.tokenProgram - ); - const transferHook = splToken.getTransferHook(mintInfo); - - if (transferHook) { - const owner = this.pdas.sessionAuthority( - args.fromAuthority, - args.transferArgs - ); - await addExtraAccountMetasForExecute( - this.connection, - transferIx, - transferHook.programId, - args.from, - config.mint, - config.custody, - owner, - // TODO(csongor): compute the amount that's passed into transfer. - // Leaving this 0 is fine unless the transfer hook accounts addresses - // depend on the amount (which is unlikely). - // If this turns out to be the case, the amount to put here is the - // untrimmed amount after removing dust. - 0 - ); - } - return transferIx; - } - - async createTransferBurnInstruction(args: { - transferArgs: TransferArgs; - payer: PublicKey; - from: PublicKey; - fromAuthority: PublicKey; - outboxItem: PublicKey; - }): Promise { - const config = await this.getConfig(); - if (config.paused) throw new Error("Contract is paused"); - - const recipientChain = toChain(args.transferArgs.recipient.chain); - - let transferIx; - if (this.program.idl.version === "1.0.0") { - transferIx = await ( - this.program as Program> - ).methods - .transferBurn({ - recipientChain: { id: toChainId(recipientChain) }, - amount: new BN(args.transferArgs.amount.toString()), - recipientAddress: Array.from( - args.transferArgs.recipient.address - .toUniversalAddress() - .toUint8Array() - ), - shouldQueue: args.transferArgs.shouldQueue, - }) - .accountsStrict({ - common: { - payer: args.payer, - config: { config: this.pdas.configAccount() }, - mint: config.mint, - from: args.from, - outboxItem: args.outboxItem, - outboxRateLimit: this.pdas.outboxRateLimitAccount(), - tokenProgram: config.tokenProgram, - systemProgram: SystemProgram.programId, - }, - peer: this.pdas.peerAccount(recipientChain), - inboxRateLimit: this.pdas.inboxRateLimitAccount(recipientChain), - sessionAuthority: this.pdas.sessionAuthority( - args.fromAuthority, - args.transferArgs - ), - }) - .instruction(); - } else { - transferIx = await ( - this.program as Program> - ).methods - .transferBurn({ - recipientChain: { id: toChainId(recipientChain) }, - amount: new BN(args.transferArgs.amount.toString()), - recipientAddress: Array.from( - args.transferArgs.recipient.address - .toUniversalAddress() - .toUint8Array() - ), - shouldQueue: args.transferArgs.shouldQueue, - }) - .accountsStrict({ - common: { - payer: args.payer, - config: { config: this.pdas.configAccount() }, - mint: config.mint, - from: args.from, - outboxItem: args.outboxItem, - outboxRateLimit: this.pdas.outboxRateLimitAccount(), - tokenProgram: config.tokenProgram, - systemProgram: SystemProgram.programId, - custody: config.custody, - }, - peer: this.pdas.peerAccount(recipientChain), - inboxRateLimit: this.pdas.inboxRateLimitAccount(recipientChain), - sessionAuthority: this.pdas.sessionAuthority( - args.fromAuthority, - args.transferArgs - ), - tokenAuthority: this.pdas.tokenAuthority(), - }) - .instruction(); - } - - const mintInfo = await splToken.getMint( - this.connection, - config.mint, - undefined, - config.tokenProgram - ); - - const transferHook = splToken.getTransferHook(mintInfo); - - if (transferHook) { - const owner = this.pdas.sessionAuthority( - args.fromAuthority, - args.transferArgs - ); - await addExtraAccountMetasForExecute( - this.connection, - transferIx, - transferHook.programId, - args.from, - config.mint, - config.custody, - owner, - // TODO(csongor): compute the amount that's passed into transfer. - // Leaving this 0 is fine unless the transfer hook accounts addresses - // depend on the amount (which is unlikely). - // If this turns out to be the case, the amount to put here is the - // untrimmed amount after removing dust. - 0 - ); - } - - return transferIx; - } - - async createReleaseOutboundInstruction(args: { - payer: PublicKey; - outboxItem: PublicKey; - revertOnDelay: boolean; - }): Promise { - const whAccs = utils.getWormholeDerivedAccounts( - this.program.programId, - this.core.address - ); - - return await this.program.methods - .releaseWormholeOutbound({ - revertOnDelay: args.revertOnDelay, - }) - .accountsStrict({ - payer: args.payer, - config: { config: this.pdas.configAccount() }, - outboxItem: args.outboxItem, - wormholeMessage: this.pdas.wormholeMessageAccount(args.outboxItem), - emitter: whAccs.wormholeEmitter, - transceiver: this.pdas.registeredTransceiver(this.program.programId), - wormhole: { - bridge: whAccs.wormholeBridge, - feeCollector: whAccs.wormholeFeeCollector, - sequence: whAccs.wormholeSequence, - program: this.core.address, - systemProgram: SystemProgram.programId, - clock: web3.SYSVAR_CLOCK_PUBKEY, - rent: web3.SYSVAR_RENT_PUBKEY, - }, - }) - .instruction(); - } - async createReceiveWormholeMessageInstruction( payer: PublicKey, wormholeNTT: WormholeNttTransceiver.VAA From 937ba6f600f8843537754b3cf63f11baff7da6dc Mon Sep 17 00:00:00 2001 From: Ben Guidarelli Date: Fri, 3 May 2024 20:15:33 -0400 Subject: [PATCH 03/14] replace redeem instructions --- solana/ts/lib/ntt.ts | 16 ++++++----- solana/ts/sdk/ntt.ts | 66 +++++++++++++++++++------------------------- 2 files changed, 38 insertions(+), 44 deletions(-) diff --git a/solana/ts/lib/ntt.ts b/solana/ts/lib/ntt.ts index aa5bbdbde..5ff85fd48 100644 --- a/solana/ts/lib/ntt.ts +++ b/solana/ts/lib/ntt.ts @@ -17,7 +17,7 @@ import { Chain, ChainAddress, ChainId, - deserialize, + VAA, deserializeLayout, encoding, keccak256, @@ -727,12 +727,13 @@ export namespace NTT { args: { wormholeId: PublicKey; payer: PublicKey; - vaa: Uint8Array; - } + vaa: VAA<"Ntt:WormholeTransfer">; + }, + pdas?: Pdas ): Promise { - const pdas = NTT.pdas(program.programId); + pdas = pdas ?? NTT.pdas(program.programId); - const wormholeNTT = deserialize("Ntt:WormholeTransfer", args.vaa); + const wormholeNTT = args.vaa; const nttMessage = wormholeNTT.payload.nttManagerPayload; const chain = wormholeNTT.emitterChain; @@ -760,13 +761,13 @@ export namespace NTT { config: NttBindings.Config, args: { payer: PublicKey; - vaa: Uint8Array; + vaa: VAA<"Ntt:WormholeTransfer">; }, pdas?: Pdas ): Promise { pdas = pdas ?? NTT.pdas(program.programId); - const wormholeNTT = deserialize("Ntt:WormholeTransfer", args.vaa); + const wormholeNTT = args.vaa; const nttMessage = wormholeNTT.payload.nttManagerPayload; const chain = wormholeNTT.emitterChain; @@ -790,6 +791,7 @@ export namespace NTT { } // Account access + /** * Fetches the Config account from the contract. * diff --git a/solana/ts/sdk/ntt.ts b/solana/ts/sdk/ntt.ts index 090dd9634..db280349d 100644 --- a/solana/ts/sdk/ntt.ts +++ b/solana/ts/sdk/ntt.ts @@ -615,9 +615,19 @@ export class SolanaNtt yield* this.core.postVaa(payer, wormholeNTT); const senderAddress = new SolanaAddress(payer).unwrap(); - const nttMessage = wormholeNTT.payload["nttManagerPayload"]; - const emitterChain = wormholeNTT.emitterChain; + const receiveMessageIx = NTT.createReceiveWormholeMessageInstruction( + this.program, + { + wormholeId: new PublicKey(this.core.address), + payer: senderAddress, + vaa: wormholeNTT, + }, + this.pdas + ); + + const nttMessage = wormholeNTT.payload.nttManagerPayload; + const emitterChain = wormholeNTT.emitterChain; const releaseArgs = { payer: senderAddress, config, @@ -629,17 +639,27 @@ export class SolanaNtt revertOnDelay: false, }; - const [receiveMessageIx, redeemIx, releaseIx] = await Promise.all([ - this.createReceiveWormholeMessageInstruction(senderAddress, wormholeNTT), - this.createRedeemInstruction(senderAddress, wormholeNTT), + const redeemIx = NTT.createRedeemInstruction(this.program, config, { + payer: senderAddress, + vaa: wormholeNTT, + }); + + const releaseIx = config.mode.locking != null - ? this.createReleaseInboundUnlockInstruction(releaseArgs) - : this.createReleaseInboundMintInstruction(releaseArgs), - ]); + ? NTT.createReleaseInboundUnlockInstruction( + this.program, + config, + releaseArgs + ) + : NTT.createReleaseInboundMintInstruction( + this.program, + config, + releaseArgs + ); const tx = new Transaction(); tx.feePayer = senderAddress; - tx.add(receiveMessageIx, redeemIx, releaseIx); + tx.add(...(await Promise.all([receiveMessageIx, redeemIx, releaseIx]))); const luts: AddressLookupTableAccount[] = []; @@ -757,34 +777,6 @@ export class SolanaNtt return xfer; } - async createReceiveWormholeMessageInstruction( - payer: PublicKey, - wormholeNTT: WormholeNttTransceiver.VAA - ): Promise { - const config = await this.getConfig(); - if (config.paused) throw new Error("Contract is paused"); - - const nttMessage = wormholeNTT.payload["nttManagerPayload"]; - const emitterChain = wormholeNTT.emitterChain; - return await this.program.methods - .receiveWormholeMessage() - .accountsStrict({ - payer: payer, - config: { config: this.pdas.configAccount() }, - peer: this.pdas.transceiverPeerAccount(emitterChain), - vaa: utils.derivePostedVaaKey( - this.core.address, - Buffer.from(wormholeNTT.hash) - ), - transceiverMessage: this.pdas.transceiverMessageAccount( - emitterChain, - nttMessage.id - ), - systemProgram: SystemProgram.programId, - }) - .instruction(); - } - async createRedeemInstruction( payer: PublicKey, wormholeNTT: WormholeNttTransceiver.VAA From 5246cd5a969da924b0168241caa3cefb21c2cf2a Mon Sep 17 00:00:00 2001 From: Ben Guidarelli Date: Fri, 3 May 2024 20:23:46 -0400 Subject: [PATCH 04/14] :wave: more --- solana/ts/sdk/ntt.ts | 236 ++----------------------------------------- 1 file changed, 10 insertions(+), 226 deletions(-) diff --git a/solana/ts/sdk/ntt.ts b/solana/ts/sdk/ntt.ts index db280349d..14847de8c 100644 --- a/solana/ts/sdk/ntt.ts +++ b/solana/ts/sdk/ntt.ts @@ -9,7 +9,6 @@ import { PublicKey, SystemProgram, Transaction, - TransactionInstruction, TransactionMessage, VersionedTransaction, } from "@solana/web3.js"; @@ -45,7 +44,6 @@ import BN from "bn.js"; import { NTT, NttQuoter, WEI_PER_GWEI } from "../lib/index.js"; import { BPF_LOADER_UPGRADEABLE_PROGRAM_ID, - addExtraAccountMetasForExecute, programDataAddress, } from "./utils.js"; @@ -744,8 +742,16 @@ export class SolanaNtt tx.add( await (config.mode.locking != null - ? this.createReleaseInboundUnlockInstruction(releaseArgs) - : this.createReleaseInboundMintInstruction(releaseArgs)) + ? NTT.createReleaseInboundUnlockInstruction( + this.program, + config, + releaseArgs + ) + : NTT.createReleaseInboundMintInstruction( + this.program, + config, + releaseArgs + )) ); yield this.createUnsignedTx( @@ -777,228 +783,6 @@ export class SolanaNtt return xfer; } - async createRedeemInstruction( - payer: PublicKey, - wormholeNTT: WormholeNttTransceiver.VAA - ): Promise { - const config = await this.getConfig(); - if (config.paused) throw new Error("Contract is paused"); - - const nttMessage = wormholeNTT.payload["nttManagerPayload"]; - const emitterChain = wormholeNTT.emitterChain; - - const nttManagerPeer = this.pdas.peerAccount(emitterChain); - const inboxRateLimit = this.pdas.inboxRateLimitAccount(emitterChain); - const inboxItem = this.pdas.inboxItemAccount(emitterChain, nttMessage); - - return await this.program.methods - .redeem({}) - .accountsStrict({ - payer: payer, - config: this.pdas.configAccount(), - peer: nttManagerPeer, - transceiverMessage: this.pdas.transceiverMessageAccount( - emitterChain, - nttMessage.id - ), - transceiver: this.pdas.registeredTransceiver(this.program.programId), - mint: config.mint, - inboxItem, - inboxRateLimit, - outboxRateLimit: this.pdas.outboxRateLimitAccount(), - systemProgram: SystemProgram.programId, - }) - .instruction(); - } - - async createReleaseInboundMintInstruction(args: { - payer: PublicKey; - chain: Chain; - nttMessage: Ntt.Message; - revertOnDelay: boolean; - recipient?: PublicKey; - }): Promise { - const config = await this.getConfig(); - if (config.paused) throw new Error("Contract is paused"); - - const inboxItem = this.pdas.inboxItemAccount(args.chain, args.nttMessage); - - const recipientAddress = - args.recipient ?? - (await this.getInboundQueuedTransfer( - args.chain, - args.nttMessage - ))!.recipient - .toNative(this.chain) - .unwrap(); - - const tokenAddress = await this.getTokenAccount(recipientAddress); - - let transferIx; - if (this.program.idl.version === "1.0.0") { - transferIx = await ( - this.program as Program> - ).methods - .releaseInboundMint({ - revertOnDelay: args.revertOnDelay, - }) - .accountsStrict({ - common: { - payer: args.payer, - config: { config: this.pdas.configAccount() }, - inboxItem, - recipient: tokenAddress, - mint: config.mint, - tokenAuthority: this.pdas.tokenAuthority(), - tokenProgram: config.tokenProgram, - }, - }) - .instruction(); - } else { - transferIx = await ( - this.program as Program> - ).methods - .releaseInboundMint({ - revertOnDelay: args.revertOnDelay, - }) - .accountsStrict({ - common: { - payer: args.payer, - config: { config: this.pdas.configAccount() }, - inboxItem, - recipient: tokenAddress, - mint: config.mint, - tokenAuthority: this.pdas.tokenAuthority(), - tokenProgram: config.tokenProgram, - custody: config.custody, - }, - }) - .instruction(); - } - const mintInfo = await splToken.getMint( - this.connection, - config.mint, - undefined, - config.tokenProgram - ); - - const transferHook = splToken.getTransferHook(mintInfo); - - if (transferHook) { - await addExtraAccountMetasForExecute( - this.connection, - transferIx, - transferHook.programId, - config.custody, - config.mint, - tokenAddress, - this.pdas.tokenAuthority(), - // TODO(csongor): compute the amount that's passed into transfer. - // Leaving this 0 is fine unless the transfer hook accounts addresses - // depend on the amount (which is unlikely). - // If this turns out to be the case, the amount to put here is the - // untrimmed amount after removing dust. - 0 - ); - } - - return transferIx; - } - - async createReleaseInboundUnlockInstruction(args: { - payer: PublicKey; - chain: Chain; - nttMessage: Ntt.Message; - revertOnDelay: boolean; - recipient?: PublicKey; - }): Promise { - const config = await this.getConfig(); - if (config.paused) throw new Error("Contract is paused"); - - const recipientAddress = - args.recipient ?? - (await this.getInboundQueuedTransfer( - args.chain, - args.nttMessage - ))!.recipient - .toNative(this.chain) - .unwrap(); - - const inboxItem = this.pdas.inboxItemAccount(args.chain, args.nttMessage); - const tokenAddress = await this.getTokenAccount(recipientAddress); - - let transferIx; - if (this.program.idl.version === "1.0.0") { - transferIx = await ( - this.program as Program> - ).methods - .releaseInboundUnlock({ - revertOnDelay: args.revertOnDelay, - }) - .accountsStrict({ - common: { - payer: args.payer, - config: { config: this.pdas.configAccount() }, - inboxItem: inboxItem, - recipient: tokenAddress, - mint: config.mint, - tokenAuthority: this.pdas.tokenAuthority(), - tokenProgram: config.tokenProgram, - }, - custody: config.custody, - }) - .instruction(); - } else { - transferIx = await ( - this.program as Program> - ).methods - .releaseInboundUnlock({ - revertOnDelay: args.revertOnDelay, - }) - .accountsStrict({ - common: { - payer: args.payer, - config: { config: this.pdas.configAccount() }, - inboxItem: inboxItem, - recipient: tokenAddress, - mint: config.mint, - tokenAuthority: this.pdas.tokenAuthority(), - tokenProgram: config.tokenProgram, - custody: config.custody, - }, - }) - .instruction(); - } - - const mintInfo = await splToken.getMint( - this.connection, - config.mint, - undefined, - config.tokenProgram - ); - - const transferHook = splToken.getTransferHook(mintInfo); - - if (transferHook) { - await addExtraAccountMetasForExecute( - this.connection, - transferIx, - transferHook.programId, - config.custody, - config.mint, - tokenAddress, - this.pdas.tokenAuthority(), - // TODO(csongor): compute the amount that's passed into transfer. - // Leaving this 0 is fine unless the transfer hook accounts addresses - // depend on the amount (which is unlikely). - // If this turns out to be the case, the amount to put here is the - // untrimmed amount after removing dust. - 0 - ); - } - return transferIx; - } - /** * Returns the address of the custody account. If the config is available * (i.e. the program is initialised), the mint is derived from the config. From 441e5524da8d112e32eea733ea1af7c4ef4e3ca8 Mon Sep 17 00:00:00 2001 From: Ben Guidarelli Date: Fri, 3 May 2024 20:43:16 -0400 Subject: [PATCH 05/14] initialize ix --- solana/ts/lib/ntt.ts | 50 +++++++++++++++++++++++++++++++++++- solana/ts/sdk/ntt.ts | 60 +++++--------------------------------------- 2 files changed, 55 insertions(+), 55 deletions(-) diff --git a/solana/ts/lib/ntt.ts b/solana/ts/lib/ntt.ts index 5ff85fd48..d58298ab6 100644 --- a/solana/ts/lib/ntt.ts +++ b/solana/ts/lib/ntt.ts @@ -38,7 +38,12 @@ import { NttBindings, getNttProgram, } from "./bindings.js"; -import { chainToBytes, derivePda } from "./utils.js"; +import { + BPF_LOADER_UPGRADEABLE_PROGRAM_ID, + chainToBytes, + derivePda, + programDataAddress, +} from "./utils.js"; export namespace NTT { export interface TransferArgs { @@ -184,6 +189,49 @@ export namespace NTT { else throw new Error("Unknown IDL version: " + version); } + export async function createInitializeInstruction( + program: Program>, + args: { + payer: PublicKey; + owner: PublicKey; + chain: Chain; + mint: PublicKey; + outboundLimit: bigint; + tokenProgram: PublicKey; + mode: "burning" | "locking"; + }, + pdas?: Pdas + ) { + const mode: any = + args.mode === "burning" ? { burning: {} } : { locking: {} }; + const chainId = toChainId(args.chain); + + pdas = pdas ?? NTT.pdas(program.programId); + + const limit = new BN(args.outboundLimit.toString()); + return await program.methods + .initialize({ chainId, limit: limit, mode }) + .accountsStrict({ + payer: args.payer, + deployer: args.owner, + programData: programDataAddress(program.programId), + config: pdas.configAccount(), + mint: args.mint, + rateLimit: pdas.outboxRateLimitAccount(), + tokenProgram: args.tokenProgram, + tokenAuthority: pdas.tokenAuthority(), + custody: await NTT.custodyAccountAddress( + pdas, + args.mint, + args.tokenProgram + ), + bpfLoaderUpgradeableProgram: BPF_LOADER_UPGRADEABLE_PROGRAM_ID, + associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID, + systemProgram: SystemProgram.programId, + }) + .instruction(); + } + export async function createTransferBurnInstruction( program: Program>, config: NttBindings.Config, diff --git a/solana/ts/sdk/ntt.ts b/solana/ts/sdk/ntt.ts index 14847de8c..591d3af58 100644 --- a/solana/ts/sdk/ntt.ts +++ b/solana/ts/sdk/ntt.ts @@ -42,10 +42,6 @@ import { } from "@wormhole-foundation/sdk-solana-core"; import BN from "bn.js"; import { NTT, NttQuoter, WEI_PER_GWEI } from "../lib/index.js"; -import { - BPF_LOADER_UPGRADEABLE_PROGRAM_ID, - programDataAddress, -} from "./utils.js"; import { IdlVersion, NttBindings, getNttProgram } from "../lib/bindings.js"; @@ -177,35 +173,17 @@ export class SolanaNtt outboundLimit: bigint; mode: "burning" | "locking"; }) { - const mode: any = - args.mode === "burning" ? { burning: {} } : { locking: {} }; - const chainId = toChainId(args.chain); const mintInfo = await this.connection.getAccountInfo(args.mint); - if (mintInfo === null) { + if (mintInfo === null) throw new Error( "Couldn't determine token program. Mint account is null." ); - } - const tokenProgram = mintInfo.owner; - const limit = new BN(args.outboundLimit.toString()); - const ix = await this.program.methods - .initialize({ chainId, limit: limit, mode }) - .accountsStrict({ - payer: args.payer, - deployer: args.owner, - programData: programDataAddress(this.program.programId), - config: this.pdas.configAccount(), - mint: args.mint, - rateLimit: this.pdas.outboxRateLimitAccount(), - tokenProgram, - tokenAuthority: this.pdas.tokenAuthority(), - custody: await this.custodyAccountAddress(args.mint, tokenProgram), - bpfLoaderUpgradeableProgram: BPF_LOADER_UPGRADEABLE_PROGRAM_ID, - associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID, - systemProgram: SystemProgram.programId, - }) - .instruction(); + const ix = await NTT.createInitializeInstruction( + this.program, + { ...args, tokenProgram: mintInfo.owner }, + this.pdas + ); const tx = new Transaction(); tx.feePayer = args.payer; @@ -783,32 +761,6 @@ export class SolanaNtt return xfer; } - /** - * Returns the address of the custody account. If the config is available - * (i.e. the program is initialised), the mint is derived from the config. - * Otherwise, the mint must be provided. - */ - async custodyAccountAddress( - configOrMint: NttBindings.Config | PublicKey, - tokenProgram = splToken.TOKEN_PROGRAM_ID - ): Promise { - if (configOrMint instanceof PublicKey) { - return splToken.getAssociatedTokenAddress( - configOrMint, - this.pdas.tokenAuthority(), - true, - tokenProgram - ); - } else { - return splToken.getAssociatedTokenAddress( - configOrMint.mint, - this.pdas.tokenAuthority(), - true, - configOrMint.tokenProgram - ); - } - } - async getAddressLookupTable( useCache = true ): Promise { From c5fd66ea24f6434b89643780f25ccc9071efa585 Mon Sep 17 00:00:00 2001 From: Ben Guidarelli Date: Sat, 4 May 2024 08:12:58 -0400 Subject: [PATCH 06/14] remove sdk utils --- solana/ts/lib/ntt.ts | 2 +- solana/ts/lib/utils.ts | 4 + solana/ts/sdk/utils.ts | 284 ----------------------------------------- 3 files changed, 5 insertions(+), 285 deletions(-) delete mode 100644 solana/ts/sdk/utils.ts diff --git a/solana/ts/lib/ntt.ts b/solana/ts/lib/ntt.ts index d58298ab6..dd0f100a6 100644 --- a/solana/ts/lib/ntt.ts +++ b/solana/ts/lib/ntt.ts @@ -31,7 +31,6 @@ import { Ntt } from "@wormhole-foundation/sdk-definitions-ntt"; import { getAssociatedTokenAddressSync } from "@solana/spl-token"; import { SolanaTransaction } from "@wormhole-foundation/sdk-solana"; import { utils } from "@wormhole-foundation/sdk-solana-core"; -import { programVersionLayout } from "../sdk/utils.js"; import { IdlVersion, IdlVersions, @@ -43,6 +42,7 @@ import { chainToBytes, derivePda, programDataAddress, + programVersionLayout, } from "./utils.js"; export namespace NTT { diff --git a/solana/ts/lib/utils.ts b/solana/ts/lib/utils.ts index 3d613b5c2..68e71e745 100644 --- a/solana/ts/lib/utils.ts +++ b/solana/ts/lib/utils.ts @@ -47,6 +47,10 @@ export const programDataLayout = [ ], }, ] as const satisfies Layout; +export const programVersionLayout = [ + { name: "length", binary: "uint", endianness: "little", size: 4 }, + { name: "version", binary: "bytes" }, +] as const satisfies Layout; export const U64 = { MAX: new BN((2n ** 64n - 1n).toString()), diff --git a/solana/ts/sdk/utils.ts b/solana/ts/sdk/utils.ts deleted file mode 100644 index ecea6369a..000000000 --- a/solana/ts/sdk/utils.ts +++ /dev/null @@ -1,284 +0,0 @@ -import * as splToken from "@solana/spl-token"; -import { - AccountMeta, - Commitment, - Connection, - PublicKey, - PublicKeyInitData, - TransactionInstruction, -} from "@solana/web3.js"; -import { - Chain, - ChainId, - CustomConversion, - Layout, - encoding, - keccak256, - toChainId, - ChainAddress, -} from "@wormhole-foundation/sdk-connect"; -import { Ntt } from "@wormhole-foundation/sdk-definitions-ntt"; -import BN from "bn.js"; - -export const BPF_LOADER_UPGRADEABLE_PROGRAM_ID = new PublicKey( - "BPFLoaderUpgradeab1e11111111111111111111111" -); - -export function programDataAddress(programId: PublicKeyInitData) { - return PublicKey.findProgramAddressSync( - [new PublicKey(programId).toBytes()], - BPF_LOADER_UPGRADEABLE_PROGRAM_ID - )[0]; -} - -export const pubKeyConversion = { - to: (encoded: Uint8Array) => new PublicKey(encoded), - from: (decoded: PublicKey) => decoded.toBytes(), -} as const satisfies CustomConversion; - -//neither anchor nor solana web3 have a built-in way to parse this, because ofc they don't -export const programDataLayout = [ - { name: "slot", binary: "uint", endianness: "little", size: 8 }, - { - name: "upgradeAuthority", - binary: "switch", - idSize: 1, - idTag: "isSome", - layouts: [ - [[0, false], []], - [ - [1, true], - [ - { - name: "value", - binary: "bytes", - size: 32, - custom: pubKeyConversion, - }, - ], - ], - ], - }, -] as const satisfies Layout; - -export const programVersionLayout = [ - { name: "length", binary: "uint", endianness: "little", size: 4 }, - { name: "version", binary: "bytes" }, -] as const satisfies Layout; - -export const U64 = { - MAX: new BN((2n ** 64n - 1n).toString()), - to: (amount: number, unit: number) => { - const ret = new BN(Math.round(amount * unit)); - if (ret.isNeg()) throw new Error("Value negative"); - if (ret.bitLength() > 64) throw new Error("Value too large"); - return ret; - }, - from: (amount: BN, unit: number) => amount.toNumber() / unit, -}; - -export interface TransferArgs { - amount: bigint; - recipient: ChainAddress; - shouldQueue: boolean; -} - -type Seed = Uint8Array | string; -export function derivePda( - seeds: Seed | readonly Seed[], - programId: PublicKeyInitData -) { - const toBytes = (s: string | Uint8Array) => - typeof s === "string" ? encoding.bytes.encode(s) : s; - return PublicKey.findProgramAddressSync( - Array.isArray(seeds) ? seeds.map(toBytes) : [toBytes(seeds as Seed)], - new PublicKey(programId) - )[0]; -} - -const chainToBytes = (chain: Chain | ChainId) => - encoding.bignum.toBytes(toChainId(chain), 2); - -export const nttAddresses = (programId: PublicKeyInitData) => { - const configAccount = (): PublicKey => derivePda("config", programId); - const emitterAccount = (): PublicKey => derivePda("emitter", programId); - const inboxRateLimitAccount = (chain: Chain): PublicKey => - derivePda(["inbox_rate_limit", chainToBytes(chain)], programId); - const inboxItemAccount = (chain: Chain, nttMessage: Ntt.Message): PublicKey => - derivePda(["inbox_item", Ntt.messageDigest(chain, nttMessage)], programId); - const outboxRateLimitAccount = (): PublicKey => - derivePda("outbox_rate_limit", programId); - const tokenAuthority = (): PublicKey => - derivePda("token_authority", programId); - const peerAccount = (chain: Chain): PublicKey => - derivePda(["peer", chainToBytes(chain)], programId); - const transceiverPeerAccount = (chain: Chain): PublicKey => - derivePda(["transceiver_peer", chainToBytes(chain)], programId); - const registeredTransceiver = (transceiver: PublicKey): PublicKey => - derivePda(["registered_transceiver", transceiver.toBytes()], programId); - const transceiverMessageAccount = (chain: Chain, id: Uint8Array): PublicKey => - derivePda(["transceiver_message", chainToBytes(chain), id], programId); - const wormholeMessageAccount = (outboxItem: PublicKey): PublicKey => - derivePda(["message", outboxItem.toBytes()], programId); - const lutAccount = (): PublicKey => derivePda("lut", programId); - const lutAuthority = (): PublicKey => derivePda("lut_authority", programId); - const sessionAuthority = (sender: PublicKey, args: TransferArgs): PublicKey => - derivePda( - [ - "session_authority", - sender.toBytes(), - keccak256( - encoding.bytes.concat( - encoding.bignum.toBytes(args.amount, 8), - chainToBytes(args.recipient.chain), - args.recipient.address.toUniversalAddress().toUint8Array(), - new Uint8Array([args.shouldQueue ? 1 : 0]) - ) - ), - ], - programId - ); - - return { - configAccount, - outboxRateLimitAccount, - inboxRateLimitAccount, - inboxItemAccount, - sessionAuthority, - tokenAuthority, - emitterAccount, - wormholeMessageAccount, - peerAccount, - transceiverPeerAccount, - transceiverMessageAccount, - registeredTransceiver, - lutAccount, - lutAuthority, - }; -}; - -export const quoterAddresses = (programId: PublicKeyInitData) => { - const instanceAccount = () => derivePda("instance", programId); - const registeredNttAccount = (nttProgramId: PublicKey) => - derivePda(["registered_ntt", nttProgramId.toBytes()], programId); - const relayRequestAccount = (outboxItem: PublicKey) => - derivePda(["relay_request", outboxItem.toBytes()], programId); - const registeredChainAccount = (chain: Chain) => - derivePda(["registered_chain", chainToBytes(chain)], programId); - return { - relayRequestAccount, - instanceAccount, - registeredChainAccount, - registeredNttAccount, - }; -}; - -/** - * TODO: this is copied from @solana/spl-token, because the most recent released - * version (0.4.3) is broken (does object equality instead of structural on the pubkey) - * - * this version fixes that error, looks like it's also fixed on main: - * https://github.com/solana-labs/solana-program-library/blob/ad4eb6914c5e4288ad845f29f0003cd3b16243e7/token/js/src/extensions/transferHook/instructions.ts#L208 - */ -export async function addExtraAccountMetasForExecute( - connection: Connection, - instruction: TransactionInstruction, - programId: PublicKey, - source: PublicKey, - mint: PublicKey, - destination: PublicKey, - owner: PublicKey, - amount: number | bigint, - commitment?: Commitment -) { - const validateStatePubkey = splToken.getExtraAccountMetaAddress( - mint, - programId - ); - const validateStateAccount = await connection.getAccountInfo( - validateStatePubkey, - commitment - ); - if (validateStateAccount == null) { - return instruction; - } - const validateStateData = splToken.getExtraAccountMetas(validateStateAccount); - - // Check to make sure the provided keys are in the instruction - if ( - ![source, mint, destination, owner].every((key) => - instruction.keys.some((meta) => meta.pubkey.equals(key)) - ) - ) { - throw new Error("Missing required account in instruction"); - } - - const executeInstruction = splToken.createExecuteInstruction( - programId, - source, - mint, - destination, - owner, - validateStatePubkey, - BigInt(amount) - ); - - for (const extraAccountMeta of validateStateData) { - executeInstruction.keys.push( - deEscalateAccountMeta( - await splToken.resolveExtraAccountMeta( - connection, - extraAccountMeta, - executeInstruction.keys, - executeInstruction.data, - executeInstruction.programId - ), - executeInstruction.keys - ) - ); - } - - // Add only the extra accounts resolved from the validation state - instruction.keys.push(...executeInstruction.keys.slice(5)); - - // Add the transfer hook program ID and the validation state account - instruction.keys.push({ - pubkey: programId, - isSigner: false, - isWritable: false, - }); - instruction.keys.push({ - pubkey: validateStatePubkey, - isSigner: false, - isWritable: false, - }); -} - -// TODO: delete (see above) -function deEscalateAccountMeta( - accountMeta: AccountMeta, - accountMetas: AccountMeta[] -): AccountMeta { - const maybeHighestPrivileges = accountMetas - .filter((x) => x.pubkey.equals(accountMeta.pubkey)) - .reduce<{ isSigner: boolean; isWritable: boolean } | undefined>( - (acc, x) => { - if (!acc) return { isSigner: x.isSigner, isWritable: x.isWritable }; - return { - isSigner: acc.isSigner || x.isSigner, - isWritable: acc.isWritable || x.isWritable, - }; - }, - undefined - ); - if (maybeHighestPrivileges) { - const { isSigner, isWritable } = maybeHighestPrivileges; - if (!isSigner && isSigner !== accountMeta.isSigner) { - accountMeta.isSigner = false; - } - if (!isWritable && isWritable !== accountMeta.isWritable) { - accountMeta.isWritable = false; - } - } - return accountMeta; -} From f88b1eac6625321a78c4541ddb648f6a2ba5c45b Mon Sep 17 00:00:00 2001 From: Ben Guidarelli Date: Sat, 4 May 2024 12:53:23 -0400 Subject: [PATCH 07/14] tweak args for init, remove utils file --- sdk/__tests__/utils.ts | 8 +++----- solana/tests/anchor.test.ts | 5 +---- solana/ts/lib/index.ts | 1 + solana/ts/lib/ntt.ts | 6 +++++- solana/ts/lib/utils/wormhole.ts | 30 ------------------------------ solana/ts/sdk/index.ts | 1 - solana/ts/sdk/ntt.ts | 30 +++++++++++++++++++----------- 7 files changed, 29 insertions(+), 52 deletions(-) delete mode 100644 solana/ts/lib/utils/wormhole.ts diff --git a/sdk/__tests__/utils.ts b/sdk/__tests__/utils.ts index 8e7064804..e067401fd 100644 --- a/sdk/__tests__/utils.ts +++ b/sdk/__tests__/utils.ts @@ -481,7 +481,8 @@ async function deployEvm(ctx: Ctx): Promise { async function deploySolana(ctx: Ctx): Promise { const { signer, nativeSigner: keypair } = ctx.signers as Signers<"Solana">; const connection = (await ctx.context.getRpc()) as Connection; - const address = new PublicKey(signer.address()); + const sender = Wormhole.chainAddress("Solana", signer.address()); + const address = sender.address.toNative("Solana").unwrap(); console.log(`Using public key: ${address}`); const mint = await spl.createMint(connection, keypair, address, null, 9); @@ -534,10 +535,7 @@ async function deploySolana(ctx: Ctx): Promise { manager.pdas.tokenAuthority().toString() ); - const initTxs = manager.initialize({ - payer: keypair.publicKey, - owner: keypair.publicKey, - chain: "Solana", + const initTxs = manager.initialize(sender.address, { mint, outboundLimit: 1000000000n, mode: ctx.mode, diff --git a/solana/tests/anchor.test.ts b/solana/tests/anchor.test.ts index a075181eb..c737273e2 100644 --- a/solana/tests/anchor.test.ts +++ b/solana/tests/anchor.test.ts @@ -222,10 +222,7 @@ describe("example-native-token-transfers", () => { ); // init - const initTxs = ntt.initialize({ - payer: payer.publicKey, - owner: payer.publicKey, - chain: "Solana", + const initTxs = ntt.initialize(sender, { mint: mint.publicKey, outboundLimit: 1000000n, mode: "burning", diff --git a/solana/ts/lib/index.ts b/solana/ts/lib/index.ts index 417017f8d..660973924 100644 --- a/solana/ts/lib/index.ts +++ b/solana/ts/lib/index.ts @@ -1,3 +1,4 @@ export * from "./ntt.js"; export * from "./quoter.js"; export * from "./bindings.js"; +export * from "./anchor-idl/index.js"; diff --git a/solana/ts/lib/ntt.ts b/solana/ts/lib/ntt.ts index dd0f100a6..aa1ca8112 100644 --- a/solana/ts/lib/ntt.ts +++ b/solana/ts/lib/ntt.ts @@ -46,6 +46,7 @@ import { } from "./utils.js"; export namespace NTT { + /** Arguments for transfer instruction */ export interface TransferArgs { amount: BN; recipientChain: { id: ChainId }; @@ -53,6 +54,7 @@ export namespace NTT { shouldQueue: boolean; } + /** utility to create TransferArgs from SDK types */ export function transferArgs( amount: bigint, recipient: ChainAddress, @@ -68,7 +70,9 @@ export namespace NTT { }; } + /** Type of object containing methods to compute program addresses */ export type Pdas = ReturnType; + /** pdas returns an object containing all functions to compute program addresses */ export const pdas = (programId: PublicKeyInitData) => { const configAccount = (): PublicKey => derivePda("config", programId); const emitterAccount = (): PublicKey => derivePda("emitter", programId); @@ -111,7 +115,7 @@ export namespace NTT { sender.toBytes(), keccak256( encoding.bytes.concat( - encoding.bytes.zpad(new Uint8Array(args.amount.toBuffer()), 8), + encoding.bytes.zpad(new Uint8Array(args.amount.toArray()), 8), chainToBytes(args.recipientChain.id), new Uint8Array(args.recipientAddress), new Uint8Array([args.shouldQueue ? 1 : 0]) diff --git a/solana/ts/lib/utils/wormhole.ts b/solana/ts/lib/utils/wormhole.ts deleted file mode 100644 index 754dde907..000000000 --- a/solana/ts/lib/utils/wormhole.ts +++ /dev/null @@ -1,30 +0,0 @@ -import * as anchor from "@coral-xyz/anchor"; -import { - SignAndSendSigner, - VAA, - Wormhole, - signAndSendWait, -} from "@wormhole-foundation/sdk-connect"; -import { getSolanaSignAndSendSigner } from "@wormhole-foundation/sdk-solana"; -import { SolanaWormholeCore } from "@wormhole-foundation/sdk-solana-core"; - -export async function postVaa( - connection: anchor.web3.Connection, - payer: anchor.web3.Keypair, - vaa: VAA, - coreBridgeAddress: anchor.web3.PublicKey -) { - const core = new SolanaWormholeCore("Devnet", "Solana", connection, { - coreBridge: coreBridgeAddress.toBase58(), - }); - - const signer = (await getSolanaSignAndSendSigner( - connection, - payer - )) as SignAndSendSigner<"Devnet", "Solana">; - - const sender = Wormhole.parseAddress(signer.chain(), signer.address()); - - const txs = core.postVaa(sender, vaa); - return await signAndSendWait(txs, signer); -} diff --git a/solana/ts/sdk/index.ts b/solana/ts/sdk/index.ts index b34aa9a57..3622eb720 100644 --- a/solana/ts/sdk/index.ts +++ b/solana/ts/sdk/index.ts @@ -5,5 +5,4 @@ import "@wormhole-foundation/sdk-definitions-ntt"; registerProtocol(_platform, "Ntt", SolanaNtt); -export * as idl from "../lib/anchor-idl/index.js"; export * from "./ntt.js"; diff --git a/solana/ts/sdk/ntt.ts b/solana/ts/sdk/ntt.ts index 591d3af58..8dbba0569 100644 --- a/solana/ts/sdk/ntt.ts +++ b/solana/ts/sdk/ntt.ts @@ -165,35 +165,43 @@ export class SolanaNtt ); } - async *initialize(args: { - payer: PublicKey; - owner: PublicKey; - chain: Chain; - mint: PublicKey; - outboundLimit: bigint; - mode: "burning" | "locking"; - }) { + async *initialize( + sender: AccountAddress, + args: { + mint: PublicKey; + mode: Ntt.Mode; + outboundLimit: bigint; + } + ) { const mintInfo = await this.connection.getAccountInfo(args.mint); if (mintInfo === null) throw new Error( "Couldn't determine token program. Mint account is null." ); + const payer = new SolanaAddress(sender).unwrap(); + const ix = await NTT.createInitializeInstruction( this.program, - { ...args, tokenProgram: mintInfo.owner }, + { + ...args, + payer, + owner: payer, + chain: this.chain, + tokenProgram: mintInfo.owner, + }, this.pdas ); const tx = new Transaction(); - tx.feePayer = args.payer; + tx.feePayer = payer; tx.add(ix); yield this.createUnsignedTx( { transaction: tx, signers: [] }, "Ntt.Initialize" ); - yield* this.initializeOrUpdateLUT({ payer: args.payer }); + yield* this.initializeOrUpdateLUT({ payer }); } // This function should be called after each upgrade. If there's nothing to From 27e45081fc7766600b7c64cba99f53916b8e7486 Mon Sep 17 00:00:00 2001 From: Ben Guidarelli Date: Sat, 4 May 2024 13:25:18 -0400 Subject: [PATCH 08/14] remove old test, add couterValue check --- solana/tests/anchor.test.ts | 17 +- solana/tests/example-native-token-transfer.ts | 299 ------------------ solana/ts/lib/ntt.ts | 134 +++++++- solana/ts/sdk/ntt.ts | 192 ++--------- 4 files changed, 154 insertions(+), 488 deletions(-) delete mode 100644 solana/tests/example-native-token-transfer.ts diff --git a/solana/tests/anchor.test.ts b/solana/tests/anchor.test.ts index c737273e2..385ea1974 100644 --- a/solana/tests/anchor.test.ts +++ b/solana/tests/anchor.test.ts @@ -319,20 +319,6 @@ describe("example-native-token-transfers", () => { // get from balance const balance = await connection.getTokenAccountBalance(tokenAccount); expect(balance.value.amount).toBe("9900000"); - - // grab logs - //await connection.confirmTransaction(redeemTx, "confirmed"); - //const tx = await anchor - // .getProvider() - // .connection.getParsedTransaction(redeemTx, { - // commitment: "confirmed", - // }); - // console.log(tx); - // const log = tx.meta.logMessages[1]; - // const message = log.substring(log.indexOf(':') + 1); - // console.log(message); - // TODO: assert other stuff in the message - // console.log(nttManagerMessage); }); it("Can receive tokens", async () => { @@ -382,7 +368,8 @@ describe("example-native-token-transfers", () => { throw e; } - // expect(released).to.equal(true); + // expect(released).toEqual(true); + expect((await counterValue()).toString()).toEqual("2"); }); }); diff --git a/solana/tests/example-native-token-transfer.ts b/solana/tests/example-native-token-transfer.ts deleted file mode 100644 index eb2948100..000000000 --- a/solana/tests/example-native-token-transfer.ts +++ /dev/null @@ -1,299 +0,0 @@ -import * as anchor from "@coral-xyz/anchor"; -import { BN } from "@coral-xyz/anchor"; -import * as spl from "@solana/spl-token"; -import * as fs from "fs"; - -import { encoding } from "@wormhole-foundation/sdk-base"; -import { - UniversalAddress, - deserializePayload, - serializePayload, -} from "@wormhole-foundation/sdk-definitions"; -import { NTT, postVaa } from "../ts/lib/index.js"; - -import { - PublicKey, - SystemProgram, - Transaction, - sendAndConfirmTransaction, -} from "@solana/web3.js"; - -import { serialize } from "@wormhole-foundation/sdk-connect"; -import * as testing from "@wormhole-foundation/sdk-definitions/testing"; -import { deserializePostMessage } from "@wormhole-foundation/sdk-solana-core"; -import { DummyTransferHook } from "../target/types/dummy_transfer_hook.js"; - -export const GUARDIAN_KEY = - "cfb12303a19cde580bb4dd771639b0d26bc68353645571a8cff516ab2ee113a0"; - -describe("example-native-token-transfers", () => { - const payerSecretKey = Uint8Array.from( - JSON.parse( - fs.readFileSync(`${__dirname}/../keys/test.json`, { encoding: "utf-8" }) - ) - ); - const payer = anchor.web3.Keypair.fromSecretKey(payerSecretKey); - - const owner = anchor.web3.Keypair.generate(); - const connection = new anchor.web3.Connection( - "http://localhost:8899", - "confirmed" - ); - const ntt = new NTT(connection, { - nttId: "nttiK1SepaQt6sZ4WGW5whvc9tEnGXGxuKeptcQPCcS", - wormholeId: "worm2ZoG2kUd4vFXhvjh93UUH596ayRfgQ2MgjNMTth", - }); - const user = anchor.web3.Keypair.generate(); - let tokenAccount: anchor.web3.PublicKey; - - const mint = anchor.web3.Keypair.generate(); - - const dummyTransferHook = anchor.workspace - .DummyTransferHook as anchor.Program; - - const [extraAccountMetaListPDA] = PublicKey.findProgramAddressSync( - [Buffer.from("extra-account-metas"), mint.publicKey.toBuffer()], - dummyTransferHook.programId - ); - - const [counterPDA] = PublicKey.findProgramAddressSync( - [Buffer.from("counter")], - dummyTransferHook.programId - ); - - async function counterValue(): Promise { - const counter = await dummyTransferHook.account.counter.fetch(counterPDA); - return counter.count; - } - - it("Initialize mint", async () => { - const extensions = [spl.ExtensionType.TransferHook]; - const mintLen = spl.getMintLen(extensions); - const lamports = await connection.getMinimumBalanceForRentExemption( - mintLen - ); - - const transaction = new Transaction().add( - SystemProgram.createAccount({ - fromPubkey: payer.publicKey, - newAccountPubkey: mint.publicKey, - space: mintLen, - lamports, - programId: spl.TOKEN_2022_PROGRAM_ID, - }), - spl.createInitializeTransferHookInstruction( - mint.publicKey, - owner.publicKey, - dummyTransferHook.programId, - spl.TOKEN_2022_PROGRAM_ID - ), - spl.createInitializeMintInstruction( - mint.publicKey, - 9, - owner.publicKey, - null, - spl.TOKEN_2022_PROGRAM_ID - ) - ); - - await sendAndConfirmTransaction(connection, transaction, [payer, mint]); - - tokenAccount = await spl.createAssociatedTokenAccount( - connection, - payer, - mint.publicKey, - user.publicKey, - undefined, - spl.TOKEN_2022_PROGRAM_ID, - spl.ASSOCIATED_TOKEN_PROGRAM_ID - ); - - await spl.mintTo( - connection, - payer, - mint.publicKey, - tokenAccount, - owner, - BigInt(10000000), - undefined, - undefined, - spl.TOKEN_2022_PROGRAM_ID - ); - }); - - it("Can check version", async () => { - const version = await ntt.version(payer.publicKey); - expect(version).toEqual("1.0.0"); - }); - - it("Create ExtraAccountMetaList Account", async () => { - const initializeExtraAccountMetaListInstruction = - await dummyTransferHook.methods - .initializeExtraAccountMetaList() - .accountsStrict({ - payer: payer.publicKey, - mint: mint.publicKey, - counter: counterPDA, - extraAccountMetaList: extraAccountMetaListPDA, - tokenProgram: spl.TOKEN_2022_PROGRAM_ID, - associatedTokenProgram: spl.ASSOCIATED_TOKEN_PROGRAM_ID, - systemProgram: SystemProgram.programId, - }) - .instruction(); - - const transaction = new Transaction().add( - initializeExtraAccountMetaListInstruction - ); - - await sendAndConfirmTransaction(connection, transaction, [payer]); - }); - - describe("Burning", () => { - beforeAll(async () => { - await spl.setAuthority( - connection, - payer, - mint.publicKey, - owner, - spl.AuthorityType.MintTokens, - ntt.pdas.tokenAuthority(), - [], - undefined, - spl.TOKEN_2022_PROGRAM_ID - ); - - await ntt.initialize({ - payer, - owner: payer, - chain: "Solana", - mint: mint.publicKey, - outboundLimit: new BN(1000000), - mode: "burning", - }); - - // NOTE: this is a hack. The next instruction will fail if we don't wait - // here, because the address lookup table is not yet available, despite - // the transaction having been confirmed. - // Looks like a bug, but I haven't investigated further. In practice, this - // won't be an issue, becase the address lookup table will have been - // created well before anyone is trying to use it, but we might want to be - // mindful in the deploy script too. - await new Promise((resolve) => setTimeout(resolve, 200)); - - await ntt.registerTransceiver({ - payer, - owner: payer, - transceiver: ntt.program.programId, - }); - - await ntt.setWormholeTransceiverPeer({ - payer, - owner: payer, - chain: "Ethereum", - address: Buffer.from("transceiver".padStart(32, "\0")), - }); - - await ntt.setPeer({ - payer, - owner: payer, - chain: "Ethereum", - address: Buffer.from("nttManager".padStart(32, "\0")), - limit: new BN(1000000), - tokenDecimals: 18, - }); - }); - - it("Can send tokens", async () => { - // TODO: factor out this test so it can be reused for burn&mint - - // transfer some tokens - - const amount = new BN(100000); - - const outboxItem = await ntt.transfer({ - payer, - from: tokenAccount, - fromAuthority: user, - amount, - recipientChain: "Ethereum", - recipientAddress: Array.from(user.publicKey.toBuffer()), // TODO: dummy - shouldQueue: false, - }); - - const wormholeMessage = ntt.pdas.wormholeMessageAccount(outboxItem); - - const wormholeMessageAccount = await connection.getAccountInfo( - wormholeMessage - ); - if (wormholeMessageAccount === null) { - throw new Error("wormhole message account not found"); - } - - const messageData = deserializePostMessage(wormholeMessageAccount.data); - const transceiverMessage = deserializePayload( - "Ntt:WormholeTransfer", - messageData.payload - ); - - // assert theat amount is what we expect - expect( - transceiverMessage.nttManagerPayload.payload.trimmedAmount - ).toEqual({ amount: 10000n, decimals: 8 }); - // get from balance - const balance = await connection.getTokenAccountBalance(tokenAccount); - expect(balance.value.amount).toEqual("9900000"); - - expect((await counterValue()).toString()).toEqual("1"); - }); - - it("Can receive tokens", async () => { - const emitter = new testing.mocks.MockEmitter( - new UniversalAddress( - encoding.bytes.zpad(encoding.bytes.encode("transceiver"), 32) - ), - "Ethereum" - ); - - const guardians = new testing.mocks.MockGuardians(0, [GUARDIAN_KEY]); - - const sendingTransceiverMessage = { - sourceNttManager: new UniversalAddress( - encoding.bytes.encode("nttManager".padStart(32, "\0")) - ), - recipientNttManager: new UniversalAddress( - ntt.program.programId.toBytes() - ), - nttManagerPayload: { - id: encoding.bytes.encode("sequence1".padEnd(32, "0")), - sender: new UniversalAddress("FACE".padStart(64, "0")), - payload: { - trimmedAmount: { - amount: 10000n, - decimals: 8, - }, - sourceToken: new UniversalAddress("FAFA".padStart(64, "0")), - recipientAddress: new UniversalAddress(user.publicKey.toBytes()), - recipientChain: "Solana", - }, - }, - transceiverPayload: new Uint8Array(), - } as const; - - const serialized = serializePayload( - "Ntt:WormholeTransfer", - sendingTransceiverMessage - ); - - const published = emitter.publishMessage(0, serialized, 0); - - const vaa = guardians.addSignatures(published, [0]); - - await postVaa(connection, payer, vaa, ntt.wormholeId); - - const released = await ntt.redeem({ payer, vaa: serialize(vaa) }); - expect(released).toEqual(true); - - expect((await counterValue()).toString()).toEqual("2"); - }); - }); -}); diff --git a/solana/ts/lib/ntt.ts b/solana/ts/lib/ntt.ts index aa1ca8112..d1b8e7224 100644 --- a/solana/ts/lib/ntt.ts +++ b/solana/ts/lib/ntt.ts @@ -1,7 +1,9 @@ -import { BN, Program } from "@coral-xyz/anchor"; +import { BN, Program, web3 } from "@coral-xyz/anchor"; import * as splToken from "@solana/spl-token"; import { AccountMeta, + AddressLookupTableAccount, + AddressLookupTableProgram, Commitment, Connection, Keypair, @@ -236,6 +238,103 @@ export namespace NTT { .instruction(); } + // This function should be called after each upgrade. If there's nothing to + // do, it won't actually submit a transaction, so it's cheap to call. + export async function initializeOrUpdateLUT( + program: Program>, + config: NttBindings.Config, + args: { + payer: PublicKey; + wormholeId: PublicKey; + }, + pdas?: Pdas + ) { + // if the program is at version 1.0.0, we don't need to initialize the LUT + if (program.idl.version === "1.0.0") return; + + pdas = pdas ?? NTT.pdas(program.programId); + + // TODO: find a more robust way of fetching a recent slot + const slot = (await program.provider.connection.getSlot()) - 1; + + const [_, lutAddress] = web3.AddressLookupTableProgram.createLookupTable({ + authority: pdas.lutAuthority(), + payer: args.payer, + recentSlot: slot, + }); + + const whAccs = utils.getWormholeDerivedAccounts( + program.programId, + args.wormholeId.toString() + ); + + const entries = { + config: pdas.configAccount(), + custody: config.custody, + tokenProgram: config.tokenProgram, + mint: config.mint, + tokenAuthority: pdas.tokenAuthority(), + outboxRateLimit: pdas.outboxRateLimitAccount(), + wormhole: { + bridge: whAccs.wormholeBridge, + feeCollector: whAccs.wormholeFeeCollector, + sequence: whAccs.wormholeSequence, + program: args.wormholeId, + systemProgram: SystemProgram.programId, + clock: web3.SYSVAR_CLOCK_PUBKEY, + rent: web3.SYSVAR_RENT_PUBKEY, + }, + }; + + // collect all pubkeys in entries recursively + const collectPubkeys = (obj: any): Array => { + const pubkeys = new Array(); + for (const key in obj) { + const value = obj[key]; + if (value instanceof PublicKey) { + pubkeys.push(value); + } else if (typeof value === "object") { + pubkeys.push(...collectPubkeys(value)); + } + } + return pubkeys; + }; + const pubkeys = collectPubkeys(entries).map((pk) => pk.toBase58()); + + let existingLut: web3.AddressLookupTableAccount | null = null; + try { + existingLut = await getAddressLookupTable(program, pdas); + } catch {} + + if (existingLut !== null) { + const existingPubkeys = + existingLut.state.addresses?.map((a) => a.toBase58()) ?? []; + + // if pubkeys contains keys that are not in the existing LUT, we need to + // add them to the LUT + const missingPubkeys = pubkeys.filter( + (pk) => !existingPubkeys.includes(pk) + ); + + if (missingPubkeys.length === 0) { + return null; + } + } + + return await program.methods + .initializeLut(new BN(slot)) + .accountsStrict({ + payer: args.payer, + authority: pdas.lutAuthority(), + lutAddress, + lut: pdas.lutAccount(), + lutProgram: AddressLookupTableProgram.programId, + systemProgram: SystemProgram.programId, + entries, + }) + .instruction(); + } + export async function createTransferBurnInstruction( program: Program>, config: NttBindings.Config, @@ -672,9 +771,11 @@ export namespace NTT { }) .instruction(); + const transaction = new Transaction().add(ix, broadcastIx); + transaction.feePayer = args.payer; return { - transaction: new Transaction().add(ix, broadcastIx), - signers: [args.payer, args.owner, wormholeMessage], + transaction, + signers: [wormholeMessage], } as SolanaTransaction; } @@ -723,9 +824,11 @@ export namespace NTT { }) .instruction(); + const transaction = new Transaction().add(ix, broadcastIx); + transaction.feePayer = args.payer; return { - transaction: new Transaction().add(ix, broadcastIx), - signers: [args.payer, args.owner, wormholeMessage], + transaction, + signers: [wormholeMessage], }; } @@ -869,6 +972,27 @@ export namespace NTT { ); } + export async function getAddressLookupTable( + program: Program>, + pdas?: Pdas + ): Promise { + if (program.idl.version === "1.0.0") + throw new Error("Lookup tables not supported for this version"); + + pdas = pdas ?? NTT.pdas(program.programId); + const lut = await program.account.lut.fetchNullable(pdas.lutAccount()); + if (!lut) + throw new Error( + "Address lookup table not found. Did you forget to call initializeLUT?" + ); + + const response = await program.provider.connection.getAddressLookupTable( + lut.address + ); + if (response.value === null) throw new Error("Could not fetch LUT"); + return response.value; + } + /** * Returns the address of the custody account. If the config is available * (i.e. the program is initialised), the mint is derived from the config. diff --git a/solana/ts/sdk/ntt.ts b/solana/ts/sdk/ntt.ts index 8dbba0569..d10d857da 100644 --- a/solana/ts/sdk/ntt.ts +++ b/solana/ts/sdk/ntt.ts @@ -3,7 +3,6 @@ import * as splToken from "@solana/spl-token"; import { createAssociatedTokenAccountInstruction } from "@solana/spl-token"; import { AddressLookupTableAccount, - AddressLookupTableProgram, Connection, Keypair, PublicKey, @@ -22,7 +21,6 @@ import { Network, TokenAddress, UnsignedTransaction, - toChainId, } from "@wormhole-foundation/sdk-connect"; import { Ntt, @@ -204,96 +202,15 @@ export class SolanaNtt yield* this.initializeOrUpdateLUT({ payer }); } - // This function should be called after each upgrade. If there's nothing to - // do, it won't actually submit a transaction, so it's cheap to call. async *initializeOrUpdateLUT(args: { payer: PublicKey }) { - if (this.version === "1.0.0") return; - const program = this.program as Program< - NttBindings.NativeTokenTransfer<"2.0.0"> - >; - - // TODO: find a more robust way of fetching a recent slot - const slot = (await this.connection.getSlot()) - 1; + const config = await this.getConfig(); - const [_, lutAddress] = web3.AddressLookupTableProgram.createLookupTable({ - authority: this.pdas.lutAuthority(), + const ix = await NTT.initializeOrUpdateLUT(this.program, config, { payer: args.payer, - recentSlot: slot, + wormholeId: new PublicKey(this.core.address), }); - - const whAccs = utils.getWormholeDerivedAccounts( - program.programId, - this.core.address - ); - const config = await this.getConfig(); - - const entries = { - config: this.pdas.configAccount(), - custody: config.custody, - tokenProgram: config.tokenProgram, - mint: config.mint, - tokenAuthority: this.pdas.tokenAuthority(), - outboxRateLimit: this.pdas.outboxRateLimitAccount(), - wormhole: { - bridge: whAccs.wormholeBridge, - feeCollector: whAccs.wormholeFeeCollector, - sequence: whAccs.wormholeSequence, - program: this.core.address, - systemProgram: SystemProgram.programId, - clock: web3.SYSVAR_CLOCK_PUBKEY, - rent: web3.SYSVAR_RENT_PUBKEY, - }, - }; - - // collect all pubkeys in entries recursively - const collectPubkeys = (obj: any): Array => { - const pubkeys = new Array(); - for (const key in obj) { - const value = obj[key]; - if (value instanceof PublicKey) { - pubkeys.push(value); - } else if (typeof value === "object") { - pubkeys.push(...collectPubkeys(value)); - } - } - return pubkeys; - }; - const pubkeys = collectPubkeys(entries).map((pk) => pk.toBase58()); - - var existingLut: web3.AddressLookupTableAccount | null = null; - try { - existingLut = await this.getAddressLookupTable(false); - } catch { - // swallow errors here, it just means that lut doesn't exist - } - - if (existingLut !== null) { - const existingPubkeys = - existingLut.state.addresses?.map((a) => a.toBase58()) ?? []; - - // if pubkeys contains keys that are not in the existing LUT, we need to - // add them to the LUT - const missingPubkeys = pubkeys.filter( - (pk) => !existingPubkeys.includes(pk) - ); - - if (missingPubkeys.length === 0) { - return existingLut; - } - } - - const ix = await program.methods - .initializeLut(new BN(slot)) - .accountsStrict({ - payer: args.payer, - authority: this.pdas.lutAuthority(), - lutAddress, - lut: this.pdas.lutAccount(), - lutProgram: AddressLookupTableProgram.programId, - systemProgram: SystemProgram.programId, - entries, - }) - .instruction(); + // Already up to date + if (!ix) return; const tx = new Transaction().add(ix); tx.feePayer = args.payer; @@ -362,56 +279,14 @@ export class SolanaNtt payer: AccountAddress ) { const sender = new SolanaAddress(payer).unwrap(); - const wormholeMessage = Keypair.generate(); - const whAccs = utils.getWormholeDerivedAccounts( - this.program.programId, - this.core.address - ); - - const [setPeerIx, broadcastIx] = await Promise.all([ - this.program.methods - .setWormholePeer({ - chainId: { id: toChainId(peer.chain) }, - address: Array.from(peer.address.toUniversalAddress().toUint8Array()), - }) - .accountsStrict({ - payer: sender, - owner: sender, - config: this.pdas.configAccount(), - peer: this.pdas.transceiverPeerAccount(peer.chain), - systemProgram: SystemProgram.programId, - }) - .instruction(), - this.program.methods - .broadcastWormholePeer({ chainId: toChainId(peer.chain) }) - .accountsStrict({ - payer: sender, - config: this.pdas.configAccount(), - peer: this.pdas.transceiverPeerAccount(peer.chain), - wormholeMessage: wormholeMessage.publicKey, - emitter: this.pdas.emitterAccount(), - wormhole: { - bridge: whAccs.wormholeBridge, - feeCollector: whAccs.wormholeFeeCollector, - sequence: whAccs.wormholeSequence, - program: this.core.address, - clock: web3.SYSVAR_CLOCK_PUBKEY, - rent: web3.SYSVAR_RENT_PUBKEY, - systemProgram: SystemProgram.programId, - }, - }) - .instruction(), - ]); - - const tx = new Transaction(); - tx.feePayer = sender; - tx.add(setPeerIx, broadcastIx); - yield this.createUnsignedTx( - { - transaction: tx, - signers: [wormholeMessage], - }, + await NTT.setWormholeTransceiverPeer(this.program, { + wormholeId: new PublicKey(this.core.address), + payer: sender, + owner: sender, + chain: peer.chain, + address: peer.address.toUniversalAddress().toUint8Array(), + }), "Ntt.SetWormholeTransceiverPeer" ); } @@ -424,22 +299,14 @@ export class SolanaNtt ) { const sender = new SolanaAddress(payer).unwrap(); - const ix = await this.program.methods - .setPeer({ - chainId: { id: toChainId(peer.chain) }, - address: Array.from(peer.address.toUniversalAddress().toUint8Array()), - limit: new BN(inboundLimit.toString()), - tokenDecimals: tokenDecimals, - }) - .accountsStrict({ - payer: sender, - owner: sender, - config: this.pdas.configAccount(), - peer: this.pdas.peerAccount(peer.chain), - inboxRateLimit: this.pdas.inboxRateLimitAccount(peer.chain), - systemProgram: SystemProgram.programId, - }) - .instruction(); + const ix = await NTT.createSetPeerInstruction(this.program, { + payer: sender, + owner: sender, + chain: peer.chain, + address: peer.address.toUniversalAddress().toUint8Array(), + limit: new BN(inboundLimit.toString()), + tokenDecimals, + }); const tx = new Transaction(); tx.feePayer = sender; @@ -646,7 +513,6 @@ export class SolanaNtt tx.add(...(await Promise.all([receiveMessageIx, redeemIx, releaseIx]))); const luts: AddressLookupTableAccount[] = []; - try { luts.push(await this.getAddressLookupTable()); } catch {} @@ -772,23 +638,11 @@ export class SolanaNtt async getAddressLookupTable( useCache = true ): Promise { - if (this.version === "1.0.0") - throw new Error("Lookup tables not supported for this version"); - if (!useCache || !this.addressLookupTable) { - // @ts-ignore - const lut = await this.program.account.lut.fetchNullable( - this.pdas.lutAccount() + this.addressLookupTable = await NTT.getAddressLookupTable( + this.program, + this.pdas ); - if (!lut) - throw new Error( - "Address lookup table not found. Did you forget to call initializeLUT?" - ); - - const response = await this.connection.getAddressLookupTable(lut.address); - if (response.value === null) throw new Error("Could not fetch LUT"); - - this.addressLookupTable = response.value; } if (!this.addressLookupTable) From c3b3c7bced462041e92c75862ed9adf903f10ab8 Mon Sep 17 00:00:00 2001 From: Ben Guidarelli Date: Mon, 6 May 2024 11:33:06 -0400 Subject: [PATCH 09/14] use local anchor network instead of public testnet --- solana/tests/anchor.test.ts | 31 ++++++++++++++----------------- solana/ts/lib/ntt.ts | 25 +++++++++++++++++++++---- 2 files changed, 35 insertions(+), 21 deletions(-) diff --git a/solana/tests/anchor.test.ts b/solana/tests/anchor.test.ts index 385ea1974..eab8663c7 100644 --- a/solana/tests/anchor.test.ts +++ b/solana/tests/anchor.test.ts @@ -122,6 +122,7 @@ describe("example-native-token-transfers", () => { let ntt: SolanaNtt<"Devnet", "Solana">; let signer: Signer; let sender: AccountAddress<"Solana">; + let tokenAddress: string; beforeAll(async () => { try { @@ -189,15 +190,14 @@ describe("example-native-token-transfers", () => { TOKEN_PROGRAM ); + tokenAddress = mint.publicKey.toBase58(); // Create our contract client ntt = new SolanaNtt("Devnet", "Solana", connection, { ...ctx.config.contracts, ntt: { - token: mint.publicKey.toBase58(), + token: tokenAddress, manager: NTT_ADDRESS, - transceiver: { - wormhole: NTT_ADDRESS, - }, + transceiver: { wormhole: NTT_ADDRESS }, }, }); } catch (e) { @@ -374,27 +374,24 @@ describe("example-native-token-transfers", () => { }); describe("Static Checks", () => { - const wh = new Wormhole("Testnet", [SolanaPlatform]); - + const wh = new Wormhole("Devnet", [SolanaPlatform]); + const ctx = wh.getChain("Solana"); const overrides = { Solana: { - token: "EetppHswYvV1jjRWoQKC1hejdeBDHR9NNzNtCyRQfrrQ", - manager: "NTtAaoDJhkeHeaVUHnyhwbPNAN6WgBpHkHBTc6d7vLK", - transceiver: { - wormhole: "ExVbjD8inGXkt7Cx8jVr4GF175sQy1MeqgfaY53Ah8as", - }, + token: tokenAddress, + manager: NTT_ADDRESS, + transceiver: { wormhole: NTT_ADDRESS }, }, }; describe("ABI Versions Test", function () { - const ctx = wh.getChain("Solana"); test("It initializes from Rpc", async function () { - const ntt = await SolanaNtt.fromRpc(await ctx.getRpc(), { + const ntt = await SolanaNtt.fromRpc(connection, { Solana: { ...ctx.config, contracts: { ...ctx.config.contracts, - ...{ ntt: overrides["Solana"] }, + ntt: overrides["Solana"], }, }, }); @@ -402,7 +399,7 @@ describe("example-native-token-transfers", () => { }); test("It initializes from constructor", async function () { - const ntt = new SolanaNtt("Testnet", "Solana", await ctx.getRpc(), { + const ntt = new SolanaNtt("Devnet", "Solana", connection, { ...ctx.config.contracts, ...{ ntt: overrides["Solana"] }, }); @@ -411,11 +408,11 @@ describe("example-native-token-transfers", () => { test("It gets the correct version", async function () { const version = await SolanaNtt.getVersion( - await ctx.getRpc(), + connection, { ntt: overrides["Solana"] }, new SolanaAddress(payer.publicKey.toBase58()) ); - expect(version).toBe("1.0.0"); + expect(version).toBe("2.0.0"); }); }); }); diff --git a/solana/ts/lib/ntt.ts b/solana/ts/lib/ntt.ts index d1b8e7224..b6fd316df 100644 --- a/solana/ts/lib/ntt.ts +++ b/solana/ts/lib/ntt.ts @@ -1,4 +1,10 @@ -import { BN, Program, web3 } from "@coral-xyz/anchor"; +import { + BN, + Program, + parseIdlErrors, + translateError, + web3, +} from "@coral-xyz/anchor"; import * as splToken from "@solana/spl-token"; import { AccountMeta, @@ -165,7 +171,9 @@ export namespace NTT { if (!sender) { const address = connection.rpcEndpoint === rpc.rpcAddress("Devnet", "Solana") - ? "6sbzC1eH4FTujJXWj51eQe25cYvr4xfXbJ1vAj7j2k5J" // The CI pubkey, funded on local network + ? "6sbzC1eH4FTujJXWj51eQe25cYvr4xfXbJ1vAj7j2k5J" // The CI pubkey, funded on ci network + : connection.rpcEndpoint.startsWith("http://localhost") + ? "98evdAiWr7ey9MAQzoQQMwFQkTsSR6KkWQuFqKrgwNwb" // the anchor pubkey, funded on local network : "Hk3SdYTJFpawrvRz4qRztuEt2SqoCG7BGj2yJfDJSFbJ"; // The default pubkey is funded on mainnet and devnet we need a funded account to simulate the transaction below sender = new PublicKey(address); } @@ -173,11 +181,11 @@ export namespace NTT { const program = getNttProgram(connection, programId.toString(), "1.0.0"); const ix = await program.methods.version().accountsStrict({}).instruction(); - const latestBlockHash = + const { blockhash } = await program.provider.connection.getLatestBlockhash(); const msg = new TransactionMessage({ payerKey: sender, - recentBlockhash: latestBlockHash.blockhash, + recentBlockhash: blockhash, instructions: [ix], }).compileToV0Message(); @@ -188,6 +196,15 @@ export namespace NTT { { sigVerify: false } ); + if (!txSimulation.value.returnData || txSimulation.value.err) { + throw new Error( + "Could not fetch IDL version: " + + JSON.stringify( + translateError(txSimulation.value.err, parseIdlErrors(program.idl)) + ) + ); + } + const data = encoding.b64.decode(txSimulation.value.returnData?.data[0]!); const parsed = deserializeLayout(programVersionLayout, data); const version = encoding.bytes.decode(parsed.version); From ef90fee36db537c058ddbd376dc5315ded7c8402 Mon Sep 17 00:00:00 2001 From: Ben Guidarelli Date: Mon, 6 May 2024 16:16:34 -0400 Subject: [PATCH 10/14] add custody addresses where necessary --- sdk/examples/src/index.ts | 23 +++++++++++++++++++---- solana/ts/lib/ntt.ts | 16 ++++++++++------ 2 files changed, 29 insertions(+), 10 deletions(-) diff --git a/sdk/examples/src/index.ts b/sdk/examples/src/index.ts index 68be759b8..2808ed999 100644 --- a/sdk/examples/src/index.ts +++ b/sdk/examples/src/index.ts @@ -1,6 +1,7 @@ import { TransactionId, Wormhole, + amount, signSendWait, } from "@wormhole-foundation/sdk"; import evm from "@wormhole-foundation/sdk/platforms/evm"; @@ -13,9 +14,15 @@ import "@wormhole-foundation/sdk-solana-ntt"; import { TEST_NTT_SPL22_TOKENS, TEST_NTT_TOKENS } from "./consts.js"; import { getSigner } from "./helpers.js"; +const TOKEN_CONTRACTS = TEST_NTT_TOKENS; +//const TOKEN_CONTRACTS = TEST_NTT_SPL22_TOKENS; + // Recover an in-flight transfer by setting txids here from output of previous run const recoverTxids: TransactionId[] = [ //{ chain: "Solana", txid: "hZXRs9TEvMWnSAzcgmrEuHsq1C5rbcompy63vkJ2SrXv4a7u6ZBEaJAkBMXKAfScCooDNhN36Jt4PMcDhN8yGjP", }, + // Unused adn staged + // {chain "Sepolia", txid: "0x9f2b1a8124f8377d77deb5c85f165c290669587b494c598beacea60a4d9a00fd"} + // {chain "Sepolia", txid: "0x1aff02ed4bf9d51a424626187e3e331304229fc0d422b7abfe8025452b166180"} ]; (async function () { @@ -27,14 +34,18 @@ const recoverTxids: TransactionId[] = [ const dstSigner = await getSigner(dst); const srcNtt = await src.getProtocol("Ntt", { - ntt: TEST_NTT_SPL22_TOKENS[src.chain], + ntt: TOKEN_CONTRACTS[src.chain], }); const dstNtt = await dst.getProtocol("Ntt", { - ntt: TEST_NTT_SPL22_TOKENS[dst.chain], + ntt: TOKEN_CONTRACTS[dst.chain], }); + const amt = amount.units( + amount.parse("0.01", await srcNtt.getTokenDecimals()) + ); + const xfer = () => - srcNtt.transfer(srcSigner.address.address, 1_000n, dstSigner.address, { + srcNtt.transfer(srcSigner.address.address, amt, dstSigner.address, { queue: false, automatic: false, gasDropoff: 0n, @@ -47,7 +58,11 @@ const recoverTxids: TransactionId[] = [ : recoverTxids; console.log("Source txs", txids); - const vaa = await wh.getVaa(txids[0]!.txid, "Ntt:WormholeTransfer"); + const vaa = await wh.getVaa( + txids[0]!.txid, + "Ntt:WormholeTransfer", + 25 * 60 * 1000 + ); console.log(vaa); const dstTxids = await signSendWait( diff --git a/solana/ts/lib/ntt.ts b/solana/ts/lib/ntt.ts index b6fd316df..2a40d4927 100644 --- a/solana/ts/lib/ntt.ts +++ b/solana/ts/lib/ntt.ts @@ -366,6 +366,7 @@ export namespace NTT { ): Promise { pdas = pdas ?? NTT.pdas(program.programId); + const custody = await custodyAccountAddress(pdas, config); const recipientChain = toChain(args.transferArgs.recipientChain.id); const transferIx = await program.methods .transferBurn(args.transferArgs) @@ -378,8 +379,8 @@ export namespace NTT { tokenProgram: config.tokenProgram, outboxItem: args.outboxItem, outboxRateLimit: pdas.outboxRateLimitAccount(), - custody: await custodyAccountAddress(pdas, config), systemProgram: SystemProgram.programId, + custody, }, peer: pdas.peerAccount(recipientChain), inboxRateLimit: pdas.inboxRateLimitAccount(recipientChain), @@ -448,10 +449,10 @@ export namespace NTT { pdas = pdas ?? NTT.pdas(program.programId); const chain = toChain(args.transferArgs.recipientChain.id); - + const custody = await custodyAccountAddress(pdas, config); const transferIx = await program.methods .transferLock(args.transferArgs) - .accounts({ + .accountsStrict({ common: { payer: args.payer, config: { config: pdas.configAccount() }, @@ -460,7 +461,8 @@ export namespace NTT { tokenProgram: config.tokenProgram, outboxItem: args.outboxItem, outboxRateLimit: pdas.outboxRateLimitAccount(), - custody: await custodyAccountAddress(pdas, config), + custody, + systemProgram: SystemProgram.programId, }, peer: pdas.peerAccount(chain), inboxRateLimit: pdas.inboxRateLimitAccount(chain), @@ -468,6 +470,7 @@ export namespace NTT { args.fromAuthority, args.transferArgs ), + custody, }) .instruction(); @@ -647,6 +650,7 @@ export namespace NTT { .recipientAddress; pdas = pdas ?? NTT.pdas(program.programId); + const custody = await custodyAccountAddress(pdas, config); const transferIx = await program.methods .releaseInboundUnlock({ @@ -666,9 +670,9 @@ export namespace NTT { mint: config.mint, tokenAuthority: pdas.tokenAuthority(), tokenProgram: config.tokenProgram, - custody: await custodyAccountAddress(pdas, config), + custody, }, - custody: "", + custody, }) .instruction(); From 6ce56f84f685a7f6fac333a5f4f67e0fdd885201 Mon Sep 17 00:00:00 2001 From: Ben Guidarelli Date: Mon, 6 May 2024 17:03:14 -0400 Subject: [PATCH 11/14] add peer dependency for sdk --- sdk/examples/src/index.ts | 15 +++++++++------ sdk/route/package.json | 3 +++ 2 files changed, 12 insertions(+), 6 deletions(-) diff --git a/sdk/examples/src/index.ts b/sdk/examples/src/index.ts index 2808ed999..ac76789f0 100644 --- a/sdk/examples/src/index.ts +++ b/sdk/examples/src/index.ts @@ -14,21 +14,24 @@ import "@wormhole-foundation/sdk-solana-ntt"; import { TEST_NTT_SPL22_TOKENS, TEST_NTT_TOKENS } from "./consts.js"; import { getSigner } from "./helpers.js"; +// EVM 1.0.0, Solana 1.0.0 const TOKEN_CONTRACTS = TEST_NTT_TOKENS; -//const TOKEN_CONTRACTS = TEST_NTT_SPL22_TOKENS; +// EVM 1.0.0 Solana 2.0.0 +// const TOKEN_CONTRACTS = TEST_NTT_SPL22_TOKENS; // Recover an in-flight transfer by setting txids here from output of previous run const recoverTxids: TransactionId[] = [ //{ chain: "Solana", txid: "hZXRs9TEvMWnSAzcgmrEuHsq1C5rbcompy63vkJ2SrXv4a7u6ZBEaJAkBMXKAfScCooDNhN36Jt4PMcDhN8yGjP", }, - // Unused adn staged - // {chain "Sepolia", txid: "0x9f2b1a8124f8377d77deb5c85f165c290669587b494c598beacea60a4d9a00fd"} - // {chain "Sepolia", txid: "0x1aff02ed4bf9d51a424626187e3e331304229fc0d422b7abfe8025452b166180"} + //{ chain: "Sepolia", txid: "0x9f2b1a8124f8377d77deb5c85f165c290669587b494c598beacea60a4d9a00fd", }, + //{ chain: "Sepolia", txid: "0x7c60e520f807593d27702427666e5c72aa282a3f14fe59ec934c5f9de9558609", }, + // Unused and staged + //{chain: "Sepolia", txid: "0x1aff02ed4bf9d51a424626187e3e331304229fc0d422b7abfe8025452b166180"} ]; (async function () { const wh = new Wormhole("Testnet", [solana.Platform, evm.Platform]); - const src = wh.getChain("Solana"); - const dst = wh.getChain("Sepolia"); + const src = wh.getChain("Sepolia"); + const dst = wh.getChain("Solana"); const srcSigner = await getSigner(src); const dstSigner = await getSigner(dst); diff --git a/sdk/route/package.json b/sdk/route/package.json index febf88baf..cef2aeccf 100644 --- a/sdk/route/package.json +++ b/sdk/route/package.json @@ -51,6 +51,9 @@ "@wormhole-foundation/sdk-evm-ntt": "0.0.1-beta.1", "@wormhole-foundation/sdk-connect": "0.6.5" }, + "peerDependencies": { + "@wormhole-foundation/sdk-connect": "^0.6" + }, "type": "module", "exports": { ".": { From 8ddc0bae35980a3409083513523a44297c9ecf92 Mon Sep 17 00:00:00 2001 From: Ben Guidarelli Date: Wed, 8 May 2024 10:21:31 -0400 Subject: [PATCH 12/14] add fn to parse version string, check major version as numeric, remove commented out code --- solana/ts/lib/ntt.ts | 18 +++++++++--------- solana/ts/lib/utils.ts | 18 ++++++------------ 2 files changed, 15 insertions(+), 21 deletions(-) diff --git a/solana/ts/lib/ntt.ts b/solana/ts/lib/ntt.ts index 2a40d4927..4d747376c 100644 --- a/solana/ts/lib/ntt.ts +++ b/solana/ts/lib/ntt.ts @@ -49,6 +49,7 @@ import { BPF_LOADER_UPGRADEABLE_PROGRAM_ID, chainToBytes, derivePda, + parseVersion, programDataAddress, programVersionLayout, } from "./utils.js"; @@ -266,8 +267,9 @@ export namespace NTT { }, pdas?: Pdas ) { - // if the program is at version 1.0.0, we don't need to initialize the LUT - if (program.idl.version === "1.0.0") return; + // if the program is < major version 2.x.x, we don't need to initialize the LUT + const [major, ,] = parseVersion(program.idl.version); + if (major < 2) return; pdas = pdas ?? NTT.pdas(program.programId); @@ -318,10 +320,8 @@ export namespace NTT { }; const pubkeys = collectPubkeys(entries).map((pk) => pk.toBase58()); - let existingLut: web3.AddressLookupTableAccount | null = null; - try { - existingLut = await getAddressLookupTable(program, pdas); - } catch {} + let existingLut: web3.AddressLookupTableAccount | null = + await getAddressLookupTable(program, pdas); if (existingLut !== null) { const existingPubkeys = @@ -996,9 +996,9 @@ export namespace NTT { export async function getAddressLookupTable( program: Program>, pdas?: Pdas - ): Promise { - if (program.idl.version === "1.0.0") - throw new Error("Lookup tables not supported for this version"); + ): Promise { + const [major, ,] = parseVersion(program.idl.version); + if (major < 2) return null; pdas = pdas ?? NTT.pdas(program.programId); const lut = await program.account.lut.fetchNullable(pdas.lutAccount()); diff --git a/solana/ts/lib/utils.ts b/solana/ts/lib/utils.ts index 68e71e745..0038e10e0 100644 --- a/solana/ts/lib/utils.ts +++ b/solana/ts/lib/utils.ts @@ -18,6 +18,12 @@ export function programDataAddress(programId: PublicKeyInitData) { )[0]; } +export function parseVersion(version: string): [number, number, number] { + const components = version.split("."); + if (components.length !== 3) throw new Error("Invalid version string"); + return [Number(components[0]), Number(components[1]), Number(components[2])]; +} + export const pubKeyConversion = { to: (encoded: Uint8Array) => new PublicKey(encoded), from: (decoded: PublicKey) => decoded.toBytes(), @@ -97,15 +103,3 @@ export const quoterAddresses = (programId: PublicKeyInitData) => { registeredNttAccount, }; }; - -// // The `translateError` function expects this format, but the idl gives us a -// // different one, so we preprocess the idl and store the expected format. -// // NOTE: I'm sure there's a function within anchor that does this, but I -// // couldn't find it. -// private processErrors(): Map { -// const errors = this.program.idl.errors; -// const result: Map = new Map(); -// errors.forEach((entry) => result.set(entry.code, entry.msg)); -// return result; -// } -// // View functions From 994300d435b9255ff0e4b6c2a45d612b43f86706 Mon Sep 17 00:00:00 2001 From: Ben Guidarelli Date: Wed, 8 May 2024 10:31:16 -0400 Subject: [PATCH 13/14] account for patch versions --- solana/ts/lib/ntt.ts | 4 ++-- solana/ts/lib/utils.ts | 16 +++++++++++++--- solana/ts/sdk/ntt.ts | 6 ++---- 3 files changed, 17 insertions(+), 9 deletions(-) diff --git a/solana/ts/lib/ntt.ts b/solana/ts/lib/ntt.ts index 4d747376c..89fff9be4 100644 --- a/solana/ts/lib/ntt.ts +++ b/solana/ts/lib/ntt.ts @@ -268,7 +268,7 @@ export namespace NTT { pdas?: Pdas ) { // if the program is < major version 2.x.x, we don't need to initialize the LUT - const [major, ,] = parseVersion(program.idl.version); + const [major, , ,] = parseVersion(program.idl.version); if (major < 2) return; pdas = pdas ?? NTT.pdas(program.programId); @@ -997,7 +997,7 @@ export namespace NTT { program: Program>, pdas?: Pdas ): Promise { - const [major, ,] = parseVersion(program.idl.version); + const [major, , ,] = parseVersion(program.idl.version); if (major < 2) return null; pdas = pdas ?? NTT.pdas(program.programId); diff --git a/solana/ts/lib/utils.ts b/solana/ts/lib/utils.ts index 0038e10e0..3d20847bd 100644 --- a/solana/ts/lib/utils.ts +++ b/solana/ts/lib/utils.ts @@ -18,10 +18,20 @@ export function programDataAddress(programId: PublicKeyInitData) { )[0]; } -export function parseVersion(version: string): [number, number, number] { +export function parseVersion( + version: string +): [number, number, number, string] { const components = version.split("."); - if (components.length !== 3) throw new Error("Invalid version string"); - return [Number(components[0]), Number(components[1]), Number(components[2])]; + if (components.length < 3) throw new Error("Invalid version string"); + const patchVersion = components[2]!; + const patchNumber = patchVersion.split(/[^0-9]/)[0]!; + const patchLabel = patchVersion.slice(patchNumber.length); + return [ + Number(components[0]), + Number(components[1]), + Number(patchNumber), + patchLabel, + ]; } export const pubKeyConversion = { diff --git a/solana/ts/sdk/ntt.ts b/solana/ts/sdk/ntt.ts index d10d857da..524531c2f 100644 --- a/solana/ts/sdk/ntt.ts +++ b/solana/ts/sdk/ntt.ts @@ -639,10 +639,8 @@ export class SolanaNtt useCache = true ): Promise { if (!useCache || !this.addressLookupTable) { - this.addressLookupTable = await NTT.getAddressLookupTable( - this.program, - this.pdas - ); + const alut = await NTT.getAddressLookupTable(this.program, this.pdas); + if (alut) this.addressLookupTable = alut; } if (!this.addressLookupTable) From 3ead245c3fc2430ca6ad9577816a0aadea77dc62 Mon Sep 17 00:00:00 2001 From: Ben Guidarelli Date: Wed, 8 May 2024 11:31:51 -0400 Subject: [PATCH 14/14] Return null instead of throwing error --- solana/ts/lib/ntt.ts | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/solana/ts/lib/ntt.ts b/solana/ts/lib/ntt.ts index 89fff9be4..c4740df7f 100644 --- a/solana/ts/lib/ntt.ts +++ b/solana/ts/lib/ntt.ts @@ -320,7 +320,7 @@ export namespace NTT { }; const pubkeys = collectPubkeys(entries).map((pk) => pk.toBase58()); - let existingLut: web3.AddressLookupTableAccount | null = + const existingLut: web3.AddressLookupTableAccount | null = await getAddressLookupTable(program, pdas); if (existingLut !== null) { @@ -1002,10 +1002,7 @@ export namespace NTT { pdas = pdas ?? NTT.pdas(program.programId); const lut = await program.account.lut.fetchNullable(pdas.lutAccount()); - if (!lut) - throw new Error( - "Address lookup table not found. Did you forget to call initializeLUT?" - ); + if (!lut) return null; const response = await program.provider.connection.getAddressLookupTable( lut.address