@layerzerolabs/lz-solana-sdk-v2 3.0.103 → 3.0.105-mpt.0

package/src/generated/kinobi/executor/instructions/preExecute.ts

@@ -0,0 +1,164 @@
+/**
+ * This code was AUTOGENERATED using the kinobi library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun kinobi to update it.
+ *
+ * @see https://github.com/kinobi-so/kinobi
+ */
+
+import {
+  Context,
+  Pda,
+  PublicKey,
+  Signer,
+  TransactionBuilder,
+  publicKey,
+  transactionBuilder,
+} from '@metaplex-foundation/umi';
+import {
+  Serializer,
+  bytes,
+  mapSerializer,
+  struct,
+  u64,
+  u8,
+} from '@metaplex-foundation/umi/serializers';
+import {
+  ResolvedAccount,
+  ResolvedAccountsWithIndices,
+  getAccountMetasAndSigners,
+} from '../shared';
+
+// Accounts.
+export type PreExecuteInstructionAccounts = {
+  executor: Signer;
+  /**
+   * Execution context account that stores state between pre and post execution.
+   * This account is versioned to support future protocol upgrades.
+   */
+
+  context: PublicKey | Pda;
+  systemProgram?: PublicKey | Pda;
+  /** Instruction sysvar account for introspection */
+  instructionSysvar?: PublicKey | Pda;
+};
+
+// Data.
+export type PreExecuteInstructionData = {
+  discriminator: Uint8Array;
+  /** Version of the execution context to use */
+  contextVersion: number;
+  /** Maximum fee that can be charged for execution */
+  feeLimit: bigint;
+};
+
+export type PreExecuteInstructionDataArgs = {
+  /** Version of the execution context to use */
+  contextVersion: number;
+  /** Maximum fee that can be charged for execution */
+  feeLimit: number | bigint;
+};
+
+export function getPreExecuteInstructionDataSerializer(): Serializer<
+  PreExecuteInstructionDataArgs,
+  PreExecuteInstructionData
+> {
+  return mapSerializer<
+    PreExecuteInstructionDataArgs,
+    any,
+    PreExecuteInstructionData
+  >(
+    struct<PreExecuteInstructionData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['contextVersion', u8()],
+        ['feeLimit', u64()],
+      ],
+      { description: 'PreExecuteInstructionData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([207, 125, 18, 148, 72, 192, 198, 83]),
+    })
+  ) as Serializer<PreExecuteInstructionDataArgs, PreExecuteInstructionData>;
+}
+
+// Args.
+export type PreExecuteInstructionArgs = PreExecuteInstructionDataArgs;
+
+// Instruction.
+export function preExecute(
+  context: Pick<Context, 'programs'>,
+  input: PreExecuteInstructionAccounts & PreExecuteInstructionArgs
+): TransactionBuilder {
+  // Program ID.
+  const programId = context.programs.getPublicKey(
+    'executor',
+    '6doghB248px58JSSwG4qejQ46kFMW4AMj7vzJnWZHNZn'
+  );
+
+  // Accounts.
+  const resolvedAccounts = {
+    executor: {
+      index: 0,
+      isWritable: true as boolean,
+      value: input.executor ?? null,
+    },
+    context: {
+      index: 1,
+      isWritable: true as boolean,
+      value: input.context ?? null,
+    },
+    systemProgram: {
+      index: 2,
+      isWritable: false as boolean,
+      value: input.systemProgram ?? null,
+    },
+    instructionSysvar: {
+      index: 3,
+      isWritable: false as boolean,
+      value: input.instructionSysvar ?? null,
+    },
+  } satisfies ResolvedAccountsWithIndices;
+
+  // Arguments.
+  const resolvedArgs: PreExecuteInstructionArgs = { ...input };
+
+  // Default values.
+  if (!resolvedAccounts.systemProgram.value) {
+    resolvedAccounts.systemProgram.value = context.programs.getPublicKey(
+      'splSystem',
+      '11111111111111111111111111111111'
+    );
+    resolvedAccounts.systemProgram.isWritable = false;
+  }
+  if (!resolvedAccounts.instructionSysvar.value) {
+    resolvedAccounts.instructionSysvar.value = publicKey(
+      'Sysvar1nstructions1111111111111111111111111'
+    );
+  }
+
+  // Accounts in order.
+  const orderedAccounts: ResolvedAccount[] = Object.values(
+    resolvedAccounts
+  ).sort((a, b) => a.index - b.index);
+
+  // Keys and Signers.
+  const [keys, signers] = getAccountMetasAndSigners(
+    orderedAccounts,
+    'programId',
+    programId
+  );
+
+  // Data.
+  const data = getPreExecuteInstructionDataSerializer().serialize(
+    resolvedArgs as PreExecuteInstructionDataArgs
+  );
+
+  // Bytes Created On Chain.
+  const bytesCreatedOnChain = 0;
+
+  return transactionBuilder([
+    { instruction: { keys, programId, data }, signers, bytesCreatedOnChain },
+  ]);
+}

package/src/generated/kinobi/executor/types/index.ts

@@ -12,6 +12,5 @@ export * from './dstConfig';
 export * from './executionState';
 export * from './lzComposeParams';
 export * from './lzOption';
-export * from './lzReceiveParams';
 export * from './nativeDropRequest';
 export * from './ownerSetConfigParams';

package/src/index.ts

@@ -11,6 +11,8 @@ export * as DVNProgram from './dvn'
 export * from './utility'
 export * from './config'
 export * from './receive'
+export * from './receive-types-v1'
+export * from './receive-types-v2'
 export * from './types'
 export * from './deployment'
 export * from './next_nonce'

package/src/pda.ts

@@ -1,5 +1,5 @@
 import { Pda, PublicKey, defaultPublicKey, publicKeyBytes } from '@metaplex-foundation/umi'
-import { Endian, u16, u32, u64 } from '@metaplex-foundation/umi/serializers'
+import { Endian, u16, u32, u64, u8 } from '@metaplex-foundation/umi/serializers'
 import { createWeb3JsEddsa } from '@metaplex-foundation/umi-eddsa-web3js'
 
 export const PEER_SEED = 'Peer'
@@ -309,12 +309,21 @@ export class EventPDA {
 
 export class ExecutorPDA {
     static EXECUTOR_CONFIG_SEED = 'ExecutorConfig'
+    static EXECUTION_CONTEXT_SEED = 'ExecutionContext'
 
     constructor(public program: PublicKey) {}
 
     config(): Pda {
         return EDDSA.findPda(this.program, [Buffer.from(ExecutorPDA.EXECUTOR_CONFIG_SEED, 'utf8')])
     }
+
+    context(executor: PublicKey, version: number): Pda {
+        return EDDSA.findPda(this.program, [
+            Buffer.from(ExecutorPDA.EXECUTION_CONTEXT_SEED, 'utf8'),
+            publicKeyBytes(executor),
+            u8().serialize(version),
+        ])
+    }
 }
 
 export class PriceFeedPDA {

package/src/receive-types-v1.ts

@@ -0,0 +1,85 @@
+import {
+    AccountMeta,
+    Commitment,
+    Instruction,
+    PublicKey,
+    RpcInterface,
+    defaultPublicKey,
+} from '@metaplex-foundation/umi'
+import { array, publicKey as publicKeySerializer } from '@metaplex-foundation/umi/serializers'
+import { toWeb3JsInstruction, toWeb3JsPublicKey } from '@metaplex-foundation/umi-web3js-adapters'
+
+import { OmniAppPDA } from '.'
+import { LzReceiveParams, getLzReceiveAccountSerializer, getLzReceiveParamsSerializer } from './types'
+import { instructionDiscriminator, simulateWeb3JsTransaction } from './utility'
+
+/**
+ * Get the accounts required for lz_receive by querying lz_receive_types_v1.
+ */
+export async function getLzReceiveAccountsFromTypesV1(
+    rpc: RpcInterface,
+    payer: PublicKey,
+    receiver: PublicKey,
+    receiverProgram: PublicKey,
+    params: LzReceiveParams,
+    commitment: Commitment = 'confirmed'
+): Promise<AccountMeta[]> {
+    // Derive the PDA for the lz_receive_types_accounts
+    const oappPDA = new OmniAppPDA(receiverProgram)
+    const [lzReceiveTypesAccountsPDA] = oappPDA.lzReceiveTypesAccounts(receiver)
+    // Fetch the PDA account and parse the static account list
+    const info = await rpc.getAccount(lzReceiveTypesAccountsPDA, { commitment })
+    const accounts: AccountMeta[] = []
+    if (info.exists) {
+        const buffer = Buffer.from(info.data)
+        const len = buffer.length - 8
+        if (len % 32 !== 0) {
+            throw new Error(
+                `Invalid length of AccountInfo.data. The length must be a multiple of 32 plus 8.(n*32+8). Current length is ${buffer.length}`
+            )
+        }
+        for (let i = 8; i < len; i += 32) {
+            const [address] = publicKeySerializer().deserialize(buffer, i)
+            accounts.push({
+                pubkey: address,
+                isSigner: false,
+                isWritable: false,
+            })
+        }
+    }
+    // Simulate the lz_receive_types instruction to get the dynamic account metas
+    const data = getLzReceiveParamsSerializer().serialize(params)
+    const lzReceiveTypesIx: Instruction = {
+        programId: receiverProgram,
+        keys: accounts,
+        data: Buffer.concat([instructionDiscriminator('lz_receive_types'), data]),
+    }
+    const keys = await simulateWeb3JsTransaction(
+        rpc.getEndpoint(),
+        [toWeb3JsInstruction(lzReceiveTypesIx)],
+        toWeb3JsPublicKey(receiverProgram),
+        toWeb3JsPublicKey(payer),
+        array(getLzReceiveAccountSerializer()),
+        commitment
+    )
+    return updateAccountFromSimulatedResp(keys, payer)
+}
+
+function updateAccountFromSimulatedResp(accounts: AccountMeta[], payer?: PublicKey): AccountMeta[] {
+    return accounts.map((r) => {
+        if (r.pubkey == defaultPublicKey() && r.isSigner) {
+            if (!payer) throw new Error('payer is required')
+            return {
+                pubkey: payer,
+                isSigner: true,
+                isWritable: r.isWritable,
+            } satisfies AccountMeta
+        } else {
+            return {
+                pubkey: r.pubkey,
+                isSigner: r.isSigner,
+                isWritable: r.isWritable,
+            } satisfies AccountMeta
+        }
+    })
+}

package/src/receive-types-v2.ts

@@ -0,0 +1,217 @@
+import { AddressLookupTable, fetchAllAddressLookupTable } from '@metaplex-foundation/mpl-toolbox'
+import {
+    AccountMeta,
+    Commitment,
+    Context,
+    Instruction,
+    KeypairSigner,
+    PublicKey,
+    RpcInterface,
+    generateSigner,
+} from '@metaplex-foundation/umi'
+import { bytes as bytesSerializer } from '@metaplex-foundation/umi/serializers'
+import { toWeb3JsInstruction, toWeb3JsPublicKey } from '@metaplex-foundation/umi-web3js-adapters'
+
+import { EDDSA, ExecutorPDA, OmniAppPDA } from '.'
+import {
+    AccountMetaRef,
+    AddressLocator,
+    LzReceiveParams,
+    LzReceiveTypesV2Accounts,
+    getLzReceiveParamsSerializer,
+    getLzReceiveTypesV2AccountsSerializer,
+    getLzReceiveTypesV2ResultSerializer,
+} from './types'
+import { instructionDiscriminator, simulateWeb3JsTransaction } from './utility'
+
+/**
+ * Retrieves the instructions and signers required for the LzReceive instruction (V2).
+ * This is used for lz_receive_types version 2.
+ */
+export async function buildLzReceiveExecutionPlan(
+    rpc: RpcInterface,
+    executorProgram: PublicKey,
+    payer: PublicKey,
+    receiver: PublicKey,
+    receiverProgram: PublicKey,
+    params: LzReceiveParams,
+    receiveTypesAccounts?: LzReceiveTypesV2Accounts,
+    commitment: Commitment = 'confirmed'
+): Promise<{ contextVersion: number; signers: KeypairSigner[]; instructions: Instruction[] }> {
+    receiveTypesAccounts =
+        receiveTypesAccounts ?? (await getLzReceiveTypesInfo(rpc, payer, receiver, receiverProgram, params, commitment))
+
+    const data = getLzReceiveParamsSerializer().serialize(params)
+    const lzReceiveTypesIx: Instruction = {
+        programId: receiverProgram,
+        keys: receiveTypesAccounts.accounts.map((pubkey) => {
+            return {
+                pubkey,
+                isSigner: false,
+                isWritable: false,
+            }
+        }),
+        data: Buffer.concat([instructionDiscriminator('lz_receive_types_v2'), data]),
+    }
+    // Simulate the V2 instruction to get the result (instructions, ALTs, etc)
+    const resp = await simulateWeb3JsTransaction(
+        rpc.getEndpoint(),
+        [toWeb3JsInstruction(lzReceiveTypesIx)],
+        toWeb3JsPublicKey(receiverProgram),
+        toWeb3JsPublicKey(payer),
+        getLzReceiveTypesV2ResultSerializer(),
+        commitment
+    )
+    const tables = await fetchAllAddressLookupTable({ rpc }, resp.alts)
+    const signers: { [key: number]: KeypairSigner | undefined } = {}
+
+    const lzReceiveDiscriminator = instructionDiscriminator('lz_receive').toString('hex')
+    const instructionTracker: { [key: string]: boolean } = {}
+
+    for (const ix of resp.instructions) {
+        let programId = receiverProgram
+        let instructionType = 'lz_receive'
+        if (ix.__kind === 'Standard') {
+            const { programId: stdProgramId, data } = ix
+            programId = stdProgramId
+            const discriminator = Buffer.from(data.slice(0, 8)).toString('hex')
+            instructionType = discriminator === lzReceiveDiscriminator ? 'lz_receive' : discriminator
+        }
+        const key = `${programId}-${instructionType}`
+        if (instructionTracker[key]) {
+            throw new Error(`Duplicate instruction found: ${instructionType} for program ${programId}`)
+        }
+        instructionTracker[key] = true
+    }
+    const { contextVersion } = resp
+    const instructions: Instruction[] = resp.instructions.map((ix) => {
+        if (ix.__kind === 'LzReceive') {
+            return {
+                programId: receiverProgram,
+                keys: ix.accounts.map((account) =>
+                    accountMetaRefToAccountMeta(
+                        { eddsa: EDDSA },
+                        executorProgram,
+                        tables,
+                        signers,
+                        account,
+                        payer,
+                        contextVersion
+                    )
+                ),
+                data: Buffer.concat([instructionDiscriminator('lz_receive'), data]),
+            }
+        } else {
+            return {
+                programId: ix.programId,
+                keys: ix.accounts.map((account) =>
+                    accountMetaRefToAccountMeta(
+                        { eddsa: EDDSA },
+                        executorProgram,
+                        tables,
+                        signers,
+                        account,
+                        payer,
+                        contextVersion
+                    )
+                ),
+                data: ix.data,
+            }
+        }
+    })
+    return {
+        contextVersion,
+        signers: Object.values(signers).filter((signer) => signer !== undefined) as KeypairSigner[],
+        instructions,
+    }
+}
+
+/**
+ * Fetches the metadata for lz_receive_types (versioned, V2).
+ * This reads the PDA account and deserializes the version, alts, and accounts.
+ */
+export async function getLzReceiveTypesInfo(
+    rpc: RpcInterface,
+    payer: PublicKey,
+    receiver: PublicKey,
+    receiverProgram: PublicKey,
+    params: LzReceiveParams,
+    commitment: Commitment = 'confirmed'
+): Promise<LzReceiveTypesV2Accounts> {
+    const oappPDA = new OmniAppPDA(receiverProgram)
+    const [lzReceiveTypesAccountsPDA] = oappPDA.lzReceiveTypesAccounts(receiver)
+    const lzReceiveTypesIx: Instruction = {
+        programId: receiverProgram,
+        keys: [
+            {
+                pubkey: receiver,
+                isSigner: false,
+                isWritable: false,
+            },
+            {
+                pubkey: lzReceiveTypesAccountsPDA,
+                isSigner: false,
+                isWritable: false,
+            },
+        ],
+        data: Buffer.concat([instructionDiscriminator('lz_receive_types_info')]),
+    }
+
+    const resp = await simulateWeb3JsTransaction(
+        rpc.getEndpoint(),
+        [toWeb3JsInstruction(lzReceiveTypesIx)],
+        toWeb3JsPublicKey(receiverProgram),
+        toWeb3JsPublicKey(payer),
+        bytesSerializer(),
+        commitment
+    )
+    const version = resp.at(0)
+    if (version !== 2) {
+        throw new Error(`Invalid version ${version}. Expected version 2.`)
+    }
+    return getLzReceiveTypesV2AccountsSerializer().deserialize(resp, 1)[0]
+}
+
+function accountMetaRefToAccountMeta(
+    umi: Pick<Context, 'eddsa'>,
+    executorProgram: PublicKey,
+    tables: AddressLookupTable[],
+    signers: { [key: number]: KeypairSigner | undefined },
+    accountMetaRef: AccountMetaRef,
+    payer: PublicKey,
+    contextVersion: number
+): AccountMeta {
+    const { isWritable, pubkey: locator } = accountMetaRef
+    const pubkey = addressLocatorToPublicKey(umi, executorProgram, tables, signers, locator, payer, contextVersion)
+    return { pubkey, isSigner: locator.__kind === 'Signer' || locator.__kind === 'Payer', isWritable }
+}
+
+function addressLocatorToPublicKey(
+    umi: Pick<Context, 'eddsa'>,
+    executorProgram: PublicKey,
+    tables: AddressLookupTable[],
+    signers: { [key: number]: KeypairSigner | undefined },
+    locator: AddressLocator,
+    payer: PublicKey,
+    contextVersion: number
+): PublicKey {
+    if (locator.__kind === 'Payer') {
+        return payer
+    } else if (locator.__kind === 'Signer') {
+        const index = locator.fields[0]
+        let signer = signers[index]
+        if (signer === undefined) {
+            signer = generateSigner(umi)
+            signers[index] = signer
+        }
+        return signer.publicKey
+    } else if (locator.__kind === 'Address') {
+        return locator.fields[0]
+    } else if (locator.__kind === 'Context') {
+        const pda = new ExecutorPDA(executorProgram)
+        return pda.context(payer, contextVersion)[0]
+    } else {
+        const table = tables[locator.fields[0]]
+        return table.addresses[locator.fields[1]]
+    }
+}