@layerzerolabs/lz-solana-sdk-v2 3.0.53 → 3.0.54

package/src/utility.ts

@@ -1,30 +1,7 @@
-import crypto from 'crypto'
-
-import * as beet from '@metaplex-foundation/beet'
-import {
-    AddressLookupTableProgram,
-    Blockhash,
-    CloseLookupTableParams,
-    Commitment,
-    Connection,
-    DeactivateLookupTableParams,
-    Finality,
-    GetAccountInfoConfig,
-    GetVersionedTransactionConfig,
-    Keypair,
-    MessageV0,
-    NONCE_ACCOUNT_LENGTH,
-    NonceAccount,
-    PartiallyDecodedInstruction,
-    PublicKey,
-    SystemProgram,
-    Transaction,
-    TransactionInstruction,
-    TransactionMessage,
-    TransactionSignature,
-    VersionedTransaction,
-} from '@solana/web3.js'
-import base58 from 'bs58'
+import { Instruction, PublicKey, RpcInterface, WrappedInstruction, isPublicKey } from '@metaplex-foundation/umi'
+import { Serializer, base58 } from '@metaplex-foundation/umi/serializers'
+import { toWeb3JsInstruction, toWeb3JsPublicKey } from '@metaplex-foundation/umi-web3js-adapters'
+import * as web3 from '@solana/web3.js'
 
 import { sha2_256 } from '@layerzerolabs/lz-foundation'
 
@@ -35,13 +12,13 @@ import {
     PacketDeliveredEvent,
     PacketSentEvent,
     PacketVerifiedEvent,
-    composeDeliveredEventBeet,
-    composeSentEventBeet,
-    packetDeliveredEventBeet,
-    packetSentEventBeet,
-    packetVerifiedEventBeet,
-} from './generated/endpoint/events'
-import { FeesPaidEvent, feesPaidEventBeet } from './generated/uln/events'
+    getComposeDeliveredEventSerializer,
+    getComposeSentEventSerializer,
+    getPacketDeliveredEventSerializer,
+    getPacketSentEventSerializer,
+    getPacketVerifiedEventSerializer,
+} from './generated/kinobi/endpoint/events'
+import { FeesPaidEvent, getFeesPaidEventSerializer } from './generated/kinobi/uln/events'
 
 /**
  * Gets the event discriminator for a given event.
@@ -50,38 +27,37 @@ import { FeesPaidEvent, feesPaidEventBeet } from './generated/uln/events'
  * @returns {string} The event discriminator.
  */
 function getEventDiscriminator(event: string): string {
-    const hash = crypto.createHash('sha256')
     /*
         https://book.anchor-lang.com/anchor_bts/discriminator.html
         sha256(namespace:eventName) namespace of cpi event is 'event'
     */
-    hash.update(`event:${event}`)
-    const sha256 = hash.digest('hex')
-    return sha256.slice(0, 16) // first 8 bytes
+    return Buffer.from(sha2_256(`event:${event}`))
+        .subarray(0, 8)
+        .toString('hex')
 }
 
 /**
  * Extracts the sent packet event by transaction hash.
  *
- * @param {Connection} connection - The connection to the Solana cluster.
- * @param {PublicKey} program - The program public key.
- * @param {TransactionSignature | Awaited<ReturnType<typeof connection.getParsedTransaction>>} signature - The transaction signature or parsed transaction.
- * @param {Finality | GetVersionedTransactionConfig} [commitment] - The commitment level.
+ * @param {web3.Connection | RpcInterface} connection - The connection to the Solana cluster.
+ * @param {PublicKey | web3.PublicKey} program - The program public key.
+ * @param {web3.TransactionSignature | web3.ParsedTransactionWithMeta | null} signature - The transaction signature or parsed transaction.
+ * @param {web3.Finality | web3.GetVersionedTransactionConfig} [commitment] - The commitment level.
  * @param {boolean} [unsafeParseErr=false] - Whether to parse the event even if the transaction failed.
  * @returns {Promise<PacketSentEvent[] | null>} A promise that resolves to an array of sent packet events or null if not found.
  */
-export async function extractSentPacketEventByTxHash(
-    connection: Connection,
-    program: PublicKey,
-    signature: TransactionSignature | Awaited<ReturnType<typeof connection.getParsedTransaction>>,
-    commitment?: Finality | GetVersionedTransactionConfig,
+export async function extractPacketSentEventByTxHash(
+    connection: web3.Connection | RpcInterface,
+    program: PublicKey | web3.PublicKey,
+    signature: web3.TransactionSignature | web3.ParsedTransactionWithMeta | null,
+    commitment?: web3.Finality | web3.GetVersionedTransactionConfig,
     unsafeParseErr = false
 ): Promise<PacketSentEvent[] | null> {
-    const events = await extractEventFromTransactionSignature<PacketSentEvent>(
+    const events = await extractEventFromTransactionSignature(
         connection,
         program,
         signature,
-        packetSentEventBeet,
+        getPacketSentEventSerializer(),
         commitment,
         unsafeParseErr
     )
@@ -100,17 +76,17 @@ export async function extractSentPacketEventByTxHash(
  * @returns {Promise<PacketVerifiedEvent[] | null>} A promise that resolves to an array of verified packet events or null if not found.
  */
 export async function extractVerifiedPacketEventByTxHash(
-    connection: Connection,
-    program: PublicKey,
-    signature: TransactionSignature | Awaited<ReturnType<typeof connection.getParsedTransaction>>,
-    commitment?: Finality | GetVersionedTransactionConfig,
+    connection: web3.Connection | RpcInterface,
+    program: PublicKey | web3.PublicKey,
+    signature: web3.TransactionSignature | web3.ParsedTransactionWithMeta | null,
+    commitment?: web3.Finality | web3.GetVersionedTransactionConfig,
     unsafeParseErr = false
 ): Promise<PacketVerifiedEvent[] | null> {
-    const events = await extractEventFromTransactionSignature<PacketVerifiedEvent>(
+    const events = await extractEventFromTransactionSignature(
         connection,
         program,
         signature,
-        packetVerifiedEventBeet,
+        getPacketVerifiedEventSerializer(),
         commitment,
         unsafeParseErr
     )
@@ -129,17 +105,17 @@ export async function extractVerifiedPacketEventByTxHash(
  * @returns {Promise<PacketDeliveredEvent[] | null>} A promise that resolves to an array of received packet events or null if not found.
  */
 export async function extractReceivedPacketEventByTxHash(
-    connection: Connection,
-    program: PublicKey,
-    signature: TransactionSignature | Awaited<ReturnType<typeof connection.getParsedTransaction>>,
-    commitment?: Finality | GetVersionedTransactionConfig,
+    connection: web3.Connection | RpcInterface,
+    program: PublicKey | web3.PublicKey,
+    signature: web3.TransactionSignature | web3.ParsedTransactionWithMeta | null,
+    commitment?: web3.Finality | web3.GetVersionedTransactionConfig,
     unsafeParseErr = false
 ): Promise<PacketDeliveredEvent[] | null> {
-    const events = await extractEventFromTransactionSignature<PacketDeliveredEvent>(
+    const events = await extractEventFromTransactionSignature(
         connection,
         program,
         signature,
-        packetDeliveredEventBeet,
+        getPacketDeliveredEventSerializer(),
         commitment,
         unsafeParseErr
     )
@@ -158,17 +134,17 @@ export async function extractReceivedPacketEventByTxHash(
  * @returns {Promise<ComposeSentEvent[] | null>} A promise that resolves to an array of compose sent events or null if not found.
  */
 export async function extractComposeSentEventByTxHash(
-    connection: Connection,
-    program: PublicKey,
-    signature: TransactionSignature | Awaited<ReturnType<typeof connection.getParsedTransaction>>,
-    commitment?: Finality | GetVersionedTransactionConfig,
+    connection: web3.Connection | RpcInterface,
+    program: PublicKey | web3.PublicKey,
+    signature: web3.TransactionSignature | web3.ParsedTransactionWithMeta | null,
+    commitment?: web3.Finality | web3.GetVersionedTransactionConfig,
     unsafeParseErr = false
 ): Promise<ComposeSentEvent[] | null> {
-    const events = await extractEventFromTransactionSignature<ComposeSentEvent>(
+    const events = await extractEventFromTransactionSignature(
         connection,
         program,
         signature,
-        composeSentEventBeet,
+        getComposeSentEventSerializer(),
         commitment,
         unsafeParseErr
     )
@@ -187,17 +163,17 @@ export async function extractComposeSentEventByTxHash(
  * @returns {Promise<ComposeDeliveredEvent[] | null>} A promise that resolves to an array of compose delivered events or null if not found.
  */
 export async function extractComposeDeliveredEventByTxHash(
-    connection: Connection,
-    program: PublicKey,
-    signature: TransactionSignature | Awaited<ReturnType<typeof connection.getParsedTransaction>>,
-    commitment?: Finality | GetVersionedTransactionConfig,
+    connection: web3.Connection | RpcInterface,
+    program: PublicKey | web3.PublicKey,
+    signature: web3.TransactionSignature | web3.ParsedTransactionWithMeta | null,
+    commitment?: web3.Finality | web3.GetVersionedTransactionConfig,
     unsafeParseErr = false
 ): Promise<ComposeDeliveredEvent[] | null> {
-    const events = await extractEventFromTransactionSignature<ComposeDeliveredEvent>(
+    const events = await extractEventFromTransactionSignature(
         connection,
         program,
         signature,
-        composeDeliveredEventBeet,
+        getComposeDeliveredEventSerializer(),
         commitment,
         unsafeParseErr
     )
@@ -216,17 +192,17 @@ export async function extractComposeDeliveredEventByTxHash(
  * @returns {Promise<FeesPaidEvent[] | null>} A promise that resolves to an array of worker fee paid events or null if not found.
  */
 export async function extractWorkerFeePaidEventByTxHash(
-    connection: Connection,
-    program: PublicKey,
-    signature: TransactionSignature | Awaited<ReturnType<typeof connection.getParsedTransaction>>,
-    commitment?: Finality | GetVersionedTransactionConfig,
+    connection: web3.Connection | RpcInterface,
+    program: PublicKey | web3.PublicKey,
+    signature: web3.TransactionSignature | web3.ParsedTransactionWithMeta | null,
+    commitment?: web3.Finality | web3.GetVersionedTransactionConfig,
     unsafeParseErr = false
 ): Promise<FeesPaidEvent[] | null> {
-    const events = await extractEventFromTransactionSignature<FeesPaidEvent>(
+    const events = await extractEventFromTransactionSignature(
         connection,
         program,
         signature,
-        feesPaidEventBeet,
+        getFeesPaidEventSerializer(),
         commitment,
         unsafeParseErr
     )
@@ -245,17 +221,34 @@ export async function extractWorkerFeePaidEventByTxHash(
  * @param {boolean} [unsafeParseErr=false] - Whether to parse the event even if the transaction failed. Default is false, only parse event if transaction succeeded. if true, will parse event even if transaction failed. Please set this to false if you want to ignore failed transaction and set `true` with caution as it may lead to unexpected behavior.
  * @returns {Promise<E[] | null>} A promise that resolves to an array of events or null if not found.
  */
-export async function extractEventFromTransactionSignature<E>(
-    connection: Connection,
-    program: PublicKey,
-    signature: TransactionSignature | Awaited<ReturnType<typeof connection.getParsedTransaction>>,
-    eventBeet: beet.FixableBeetArgsStruct<E> | beet.BeetArgsStruct<E>,
-    commitment?: Finality | GetVersionedTransactionConfig,
+export async function extractEventFromTransactionSignature<From, To extends From = From>(
+    connection: web3.Connection | RpcInterface,
+    _program: PublicKey | web3.PublicKey,
+    signature: web3.TransactionSignature | web3.ParsedTransactionWithMeta | null,
+    serializer: Serializer<From, To>,
+    commitment?: web3.Finality | web3.GetVersionedTransactionConfig,
     unsafeParseErr = false
-): Promise<E[] | null> {
-    const tx = typeof signature === 'string' ? await connection.getParsedTransaction(signature, commitment) : signature
+): Promise<To[] | null> {
+    let program: web3.PublicKey
+    if (typeof _program === 'string' && isPublicKey(_program)) {
+        program = toWeb3JsPublicKey(_program)
+    } else {
+        program = _program
+    }
+    let tx: web3.ParsedTransactionWithMeta | null
+    if (typeof signature === 'string') {
+        if (connection instanceof web3.Connection) {
+            tx = await connection.getParsedTransaction(signature, commitment)
+        } else if ('connection' in connection && connection.connection instanceof web3.Connection) {
+            tx = await connection.connection.getParsedTransaction(signature, commitment)
+        } else {
+            throw new Error('Invalid connection')
+        }
+    } else {
+        tx = signature
+    }
     if (tx == null) return null
-    const events = new Array<E>()
+    const events = new Array<To>()
     // refer: https://solana.com/docs/rpc/http/gettransaction
     // tx.meta.err: Error if transaction failed, null if transaction succeeded
     if (tx.meta?.err !== null && !unsafeParseErr) {
@@ -263,27 +256,28 @@ export async function extractEventFromTransactionSignature<E>(
     }
     for (const instruction of tx.meta?.innerInstructions ?? []) {
         for (const innerInstruction of instruction.instructions) {
-            const inst = innerInstruction as PartiallyDecodedInstruction
+            const inst = innerInstruction as web3.PartiallyDecodedInstruction
             if (!inst.programId.equals(program)) {
                 continue
             }
-            const decoded = base58.decode(inst.data)
+            const decoded = base58.serialize(inst.data)
             const discriminator = Buffer.from(decoded.subarray(0, 8)).toString('hex')
             if (discriminator !== EventEmitDiscriminator) {
                 continue
             }
             // get second 8 bits, filter event here
             const eventDiscriminator = Buffer.from(decoded.subarray(8, 16)).toString('hex')
-            if (eventDiscriminator !== getEventDiscriminator(eventBeet.description)) {
+            if (eventDiscriminator !== getEventDiscriminator(serializer.description)) {
                 continue
             }
-            const dataBuffer = Buffer.from(decoded.subarray(16, decoded.length))
-            if (eventBeet instanceof beet.FixableBeetArgsStruct) {
-                const beet = eventBeet.toFixedFromData(dataBuffer, 0)
-                events.push(beet.read(dataBuffer, 0))
-            } else {
-                events.push(eventBeet.read(dataBuffer, 0))
-            }
+            events.push(serializer.deserialize(decoded, 16)[0])
+            // const dataBuffer = Buffer.from(decoded.subarray(16, decoded.length))
+            // if (eventBeet instanceof beet.FixableBeetArgsStruct) {
+            //     const beet = eventBeet.toFixedFromData(dataBuffer, 0)
+            //     events.push(beet.read(dataBuffer, 0))
+            // } else {
+            //     events.push(eventBeet.read(dataBuffer, 0))
+            // }
         }
     }
     return events.length > 0 ? events : null
@@ -299,18 +293,18 @@ export async function extractEventFromTransactionSignature<E>(
  * @returns {Promise<{ instructions: TransactionInstruction[]; address: PublicKey }>} A promise that resolves to the instructions and lookup table address.
  */
 export async function generateAddressLookupTable(
-    connection: Connection,
-    payer: PublicKey,
-    authority: PublicKey,
-    addresses: PublicKey[]
-): Promise<{ instructions: TransactionInstruction[]; address: PublicKey }> {
+    connection: web3.Connection,
+    payer: web3.PublicKey,
+    authority: web3.PublicKey,
+    addresses: web3.PublicKey[]
+): Promise<{ instructions: web3.TransactionInstruction[]; address: web3.PublicKey }> {
     const slot = await connection.getSlot('finalized')
-    const [createInstruction, lookupTableAddress] = AddressLookupTableProgram.createLookupTable({
+    const [createInstruction, lookupTableAddress] = web3.AddressLookupTableProgram.createLookupTable({
         payer,
         authority,
         recentSlot: slot,
     })
-    const extendInstruction = AddressLookupTableProgram.extendLookupTable({
+    const extendInstruction = web3.AddressLookupTableProgram.extendLookupTable({
         payer,
         authority,
         lookupTable: lookupTableAddress,
@@ -328,15 +322,18 @@ export async function generateAddressLookupTable(
  * To properly terminate the lookup table, it is advisable to initially invoke `deactivateLookupTable`,
  * pause for a duration of 500 blocks, and subsequently invoke `closeLookupTable`.
  *
- * @param {PublicKey} authority - The authority public key.
- * @param {PublicKey} lookupTable - The lookup table public key.
- * @returns {TransactionInstruction} The transaction instruction.
+ * @param {web3.PublicKey} authority - The authority public key.
+ * @param {web3.PublicKey} lookupTable - The lookup table public key.
+ * @returns {web3.TransactionInstruction} The transaction instruction.
  */
-export function deactivateLookupTable(authority: PublicKey, lookupTable: PublicKey): TransactionInstruction {
-    return AddressLookupTableProgram.deactivateLookupTable({
+export function deactivateLookupTable(
+    authority: web3.PublicKey,
+    lookupTable: web3.PublicKey
+): web3.TransactionInstruction {
+    return web3.AddressLookupTableProgram.deactivateLookupTable({
         authority,
         lookupTable,
-    } satisfies DeactivateLookupTableParams)
+    } satisfies web3.DeactivateLookupTableParams)
 }
 
 /**
@@ -350,15 +347,15 @@ export function deactivateLookupTable(authority: PublicKey, lookupTable: PublicK
  * @returns {TransactionInstruction} The transaction instruction.
  */
 export function closeLookupTable(
-    recipient: PublicKey,
-    authority: PublicKey,
-    lookupTable: PublicKey
-): TransactionInstruction {
-    return AddressLookupTableProgram.closeLookupTable({
+    recipient: web3.PublicKey,
+    authority: web3.PublicKey,
+    lookupTable: web3.PublicKey
+): web3.TransactionInstruction {
+    return web3.AddressLookupTableProgram.closeLookupTable({
         authority,
         recipient,
         lookupTable,
-    } satisfies CloseLookupTableParams)
+    } satisfies web3.CloseLookupTableParams)
 }
 
 /**
@@ -372,16 +369,16 @@ export function closeLookupTable(
  * @returns {Promise<VersionedTransaction>} A promise that resolves to the versioned transaction.
  */
 export async function txWithAddressLookupTable(
-    connection: Connection,
-    payer: PublicKey,
-    instructions: TransactionInstruction[],
-    recentBlockHash?: Blockhash,
-    tableAddr?: PublicKey
-): Promise<VersionedTransaction> {
+    connection: web3.Connection,
+    payer: web3.PublicKey,
+    instructions: web3.TransactionInstruction[],
+    recentBlockHash?: web3.Blockhash,
+    tableAddr?: web3.PublicKey
+): Promise<web3.VersionedTransaction> {
     recentBlockHash = recentBlockHash ?? (await connection.getLatestBlockhash()).blockhash
     if (!tableAddr) {
-        return new VersionedTransaction(
-            new TransactionMessage({
+        return new web3.VersionedTransaction(
+            new web3.TransactionMessage({
                 instructions,
                 payerKey: payer,
                 recentBlockhash: recentBlockHash,
@@ -389,8 +386,8 @@ export async function txWithAddressLookupTable(
         )
     }
     const { value: lookupTableAccount } = await connection.getAddressLookupTable(tableAddr)
-    return new VersionedTransaction(
-        new TransactionMessage({
+    return new web3.VersionedTransaction(
+        new web3.TransactionMessage({
             instructions,
             payerKey: payer,
             recentBlockhash: recentBlockHash,
@@ -407,26 +404,26 @@ export async function txWithAddressLookupTable(
  * @returns {Promise<{ tx: Transaction; nonceAccount: Keypair }>} A promise that resolves to the transaction and nonce account.
  */
 export async function createNonceAccountTX(
-    connection: Connection,
-    auth: PublicKey,
+    connection: web3.Connection,
+    auth: web3.PublicKey,
     lamportsForRent?: number
-): Promise<{ tx: Transaction; nonceAccount: Keypair }> {
-    const nonceAccount = Keypair.generate()
+): Promise<{ tx: web3.Transaction; nonceAccount: web3.Keypair }> {
+    const nonceAccount = web3.Keypair.generate()
 
-    const lamports = lamportsForRent ?? (await connection.getMinimumBalanceForRentExemption(NONCE_ACCOUNT_LENGTH))
+    const lamports = lamportsForRent ?? (await connection.getMinimumBalanceForRentExemption(web3.NONCE_ACCOUNT_LENGTH))
 
-    const tx = new Transaction()
+    const tx = new web3.Transaction()
     tx.add(
         // create nonce account
-        SystemProgram.createAccount({
+        web3.SystemProgram.createAccount({
             fromPubkey: auth,
             newAccountPubkey: nonceAccount.publicKey,
             lamports,
-            space: NONCE_ACCOUNT_LENGTH,
-            programId: SystemProgram.programId,
+            space: web3.NONCE_ACCOUNT_LENGTH,
+            programId: web3.SystemProgram.programId,
         }),
         // init nonce account
-        SystemProgram.nonceInitialize({
+        web3.SystemProgram.nonceInitialize({
             noncePubkey: nonceAccount.publicKey, // nonce account pubkey
             authorizedPubkey: auth, // nonce account auth
         })
@@ -444,17 +441,17 @@ export async function createNonceAccountTX(
  * @returns {Promise<Transaction | null>} A promise that resolves to the transaction or null if not found.
  */
 export async function txWithNonce(
-    connection: Connection,
-    noncePubkey: PublicKey,
-    instructions: TransactionInstruction[],
-    nonceInfo?: NonceAccount
-): Promise<Transaction | null> {
-    const tx = new Transaction()
+    connection: web3.Connection,
+    noncePubkey: web3.PublicKey,
+    instructions: web3.TransactionInstruction[],
+    nonceInfo?: web3.NonceAccount
+): Promise<web3.Transaction | null> {
+    const tx = new web3.Transaction()
 
     if (!nonceInfo) {
         const accountInfo = await connection.getAccountInfo(noncePubkey)
         if (accountInfo) {
-            nonceInfo = NonceAccount.fromAccountData(accountInfo.data)
+            nonceInfo = web3.NonceAccount.fromAccountData(accountInfo.data)
         } else {
             return null
         }
@@ -462,7 +459,7 @@ export async function txWithNonce(
 
     tx.add(
         // nonce advance must be the first insturction
-        SystemProgram.nonceAdvance({
+        web3.SystemProgram.nonceAdvance({
             noncePubkey: noncePubkey,
             authorizedPubkey: nonceInfo.authorizedPubkey,
         })
@@ -481,9 +478,9 @@ export async function txWithNonce(
  * @returns {Promise<boolean>} A promise that resolves to true if the account is initialized, false otherwise.
  */
 export async function isAccountInitialized(
-    connection: Connection,
-    account: PublicKey,
-    commitmentOrConfig?: Commitment | GetAccountInfoConfig
+    connection: web3.Connection,
+    account: web3.PublicKey,
+    commitmentOrConfig?: web3.Commitment | web3.GetAccountInfoConfig
 ): Promise<boolean> {
     return connection.getAccountInfo(account, commitmentOrConfig).then((res) => {
         return res !== null
@@ -501,13 +498,13 @@ export async function isAccountInitialized(
  * @returns {Promise<MessageV0>} A promise that resolves to the version 0 message.
  */
 export async function buildMessageV0(
-    connection: Connection,
-    payerKey: PublicKey,
-    instructions: TransactionInstruction[],
-    commitmentOrConfig: Commitment | GetAccountInfoConfig = 'confirmed',
-    blockhash?: Blockhash
-): Promise<MessageV0> {
-    return new TransactionMessage({
+    connection: web3.Connection,
+    payerKey: web3.PublicKey,
+    instructions: web3.TransactionInstruction[],
+    commitmentOrConfig: web3.Commitment | web3.GetAccountInfoConfig = 'confirmed',
+    blockhash?: web3.Blockhash
+): Promise<web3.MessageV0> {
+    return new web3.TransactionMessage({
         payerKey: payerKey,
         recentBlockhash: blockhash ?? (await connection.getLatestBlockhash(commitmentOrConfig)).blockhash,
         instructions: instructions,
@@ -526,17 +523,17 @@ export async function buildMessageV0(
  * @returns {Promise<VersionedTransaction>} A promise that resolves to the versioned transaction.
  */
 export async function buildVersionedTransaction(
-    connection: Connection,
-    payerKey: PublicKey,
-    instructions: TransactionInstruction[],
-    commitmentOrConfig: Commitment | GetAccountInfoConfig = 'confirmed',
-    blockhash?: Blockhash,
-    lookupTableAddress?: PublicKey
-): Promise<VersionedTransaction> {
+    connection: web3.Connection,
+    payerKey: web3.PublicKey,
+    instructions: web3.TransactionInstruction[],
+    commitmentOrConfig: web3.Commitment | web3.GetAccountInfoConfig = 'confirmed',
+    blockhash?: web3.Blockhash,
+    lookupTableAddress?: web3.PublicKey
+): Promise<web3.VersionedTransaction> {
     if (lookupTableAddress) {
         return txWithAddressLookupTable(connection, payerKey, instructions, blockhash, lookupTableAddress)
     }
-    return new VersionedTransaction(
+    return new web3.VersionedTransaction(
         await buildMessageV0(connection, payerKey, instructions, commitmentOrConfig, blockhash)
     )
 }
@@ -554,25 +551,73 @@ export function instructionDiscriminator(method: string): Buffer {
 /**
  * Simulates a transaction.
  *
- * @param {Connection} connection - The connection to the Solana cluster.
- * @param {TransactionInstruction[]} instructions - The transaction instructions.
- * @param {PublicKey} programId - The program public key.
- * @param {PublicKey} payer - The payer public key.
- * @param {Commitment} [commitment='confirmed'] - The commitment level.
- * @param {Blockhash} [blockhash] - The blockhash.
- * @param {PublicKey} [lookupTableAddress] - The lookup table address.
+ * @param {string | web3.Connection | RpcInterface} _connection - The connection to the Solana cluster.
+ * @param {web3.TransactionInstruction[] | WrappedInstruction[] | Instruction[]} _instructions - The transaction instructions.
+ * @param {web3.PublicKey | PublicKey} _programId - The program public key.
+ * @param {web3.PublicKey | PublicKey} _payer - The payer public key.
+ * @param {Serializer<From, To>} serializer - The serializer.
+ * @param {web3.Commitment} [commitment='confirmed'] - The commitment level.
+ * @param {web3.Blockhash} [blockhash] - The blockhash.
+ * @param {web3.PublicKey | PublicKey} [_lookupTableAddress] - The lookup table address.
  * @returns {Promise<Buffer>} A promise that resolves to the simulation result.
  * @throws {Error} If the simulation fails.
  */
-export async function simulateTransaction(
-    connection: Connection,
-    instructions: TransactionInstruction[],
-    programId: PublicKey,
-    payer: PublicKey,
-    commitment: Commitment = 'confirmed',
-    blockhash?: Blockhash,
-    lookupTableAddress?: PublicKey
-): Promise<Buffer> {
+export async function simulateWeb3JsTransaction<From, To extends From = From>(
+    _connection: string | web3.Connection | RpcInterface,
+    _instructions: web3.TransactionInstruction[] | WrappedInstruction[] | Instruction[],
+    _programId: web3.PublicKey | PublicKey,
+    _payer: web3.PublicKey | PublicKey,
+    serializer: Serializer<From, To>,
+    commitment: web3.Commitment = 'confirmed',
+    blockhash?: web3.Blockhash,
+    _lookupTableAddress?: web3.PublicKey | PublicKey
+): Promise<To> {
+    let connection: web3.Connection
+    if (typeof _connection === 'string') {
+        connection = new web3.Connection(_connection, commitment)
+    } else if (_connection instanceof web3.Connection) {
+        connection = _connection
+    } else if ('connection' in _connection && _connection.connection instanceof web3.Connection) {
+        ;({ connection } = _connection)
+    } else {
+        throw new Error('Invalid connection')
+    }
+
+    let instructions: web3.TransactionInstruction[]
+    if (_instructions.length === 0) {
+        throw new Error('Instructions cannot be empty')
+    }
+    if (_instructions[0] instanceof web3.TransactionInstruction) {
+        instructions = _instructions as web3.TransactionInstruction[]
+    } else if ('bytesCreatedOnChain' in _instructions[0]) {
+        instructions = (_instructions as WrappedInstruction[]).map((i) => toWeb3JsInstruction(i.instruction))
+    } else {
+        instructions = (_instructions as Instruction[]).map((i) => toWeb3JsInstruction(i))
+    }
+
+    let programId: web3.PublicKey
+    if (_programId instanceof web3.PublicKey) {
+        programId = _programId
+    } else {
+        programId = toWeb3JsPublicKey(_programId)
+    }
+
+    let payer: web3.PublicKey
+    if (_payer instanceof web3.PublicKey) {
+        payer = _payer
+    } else {
+        payer = toWeb3JsPublicKey(_payer)
+    }
+
+    let lookupTableAddress: web3.PublicKey | undefined
+    if (_lookupTableAddress) {
+        if (_lookupTableAddress instanceof web3.PublicKey) {
+            lookupTableAddress = _lookupTableAddress
+        } else {
+            lookupTableAddress = toWeb3JsPublicKey(_lookupTableAddress)
+        }
+    }
+
     const tx = await buildVersionedTransaction(
         connection,
         payer,
@@ -587,6 +632,7 @@ export async function simulateTransaction(
     if (returnLog === undefined || simulateResp.value.returnData?.programId !== programId.toBase58()) {
         throw new Error(`Simulate Fail: ${JSON.stringify(simulateResp)}`)
     } else {
-        return Buffer.from(returnLog.slice(returnPrefix.length), 'base64')
+        const resp = Buffer.from(returnLog.slice(returnPrefix.length), 'base64')
+        return serializer.deserialize(resp, 0)[0]
     }
 }