@layerzerolabs/oft-v2-solana-sdk 3.0.46 → 3.0.48

package/src/generated/oft302/instructions/setPause.ts

@@ -0,0 +1,119 @@
+/**
+ * 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,
+  transactionBuilder,
+} from '@metaplex-foundation/umi';
+import {
+  Serializer,
+  bool,
+  bytes,
+  mapSerializer,
+  struct,
+} from '@metaplex-foundation/umi/serializers';
+import {
+  ResolvedAccount,
+  ResolvedAccountsWithIndices,
+  getAccountMetasAndSigners,
+} from '../shared';
+
+// Accounts.
+export type SetPauseInstructionAccounts = {
+  /** pauser or unpauser */
+  signer: Signer;
+  oftStore: PublicKey | Pda;
+};
+
+// Data.
+export type SetPauseInstructionData = {
+  discriminator: Uint8Array;
+  paused: boolean;
+};
+
+export type SetPauseInstructionDataArgs = { paused: boolean };
+
+export function getSetPauseInstructionDataSerializer(): Serializer<
+  SetPauseInstructionDataArgs,
+  SetPauseInstructionData
+> {
+  return mapSerializer<
+    SetPauseInstructionDataArgs,
+    any,
+    SetPauseInstructionData
+  >(
+    struct<SetPauseInstructionData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['paused', bool()],
+      ],
+      { description: 'SetPauseInstructionData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([63, 32, 154, 2, 56, 103, 79, 45]),
+    })
+  ) as Serializer<SetPauseInstructionDataArgs, SetPauseInstructionData>;
+}
+
+// Args.
+export type SetPauseInstructionArgs = SetPauseInstructionDataArgs;
+
+// Instruction.
+export function setPause(
+  context: Pick<Context, 'programs'>,
+  input: SetPauseInstructionAccounts & SetPauseInstructionArgs
+): TransactionBuilder {
+  // Program ID.
+  const programId = context.programs.getPublicKey('oft', '');
+
+  // Accounts.
+  const resolvedAccounts = {
+    signer: {
+      index: 0,
+      isWritable: false as boolean,
+      value: input.signer ?? null,
+    },
+    oftStore: {
+      index: 1,
+      isWritable: true as boolean,
+      value: input.oftStore ?? null,
+    },
+  } satisfies ResolvedAccountsWithIndices;
+
+  // Arguments.
+  const resolvedArgs: SetPauseInstructionArgs = { ...input };
+
+  // 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 = getSetPauseInstructionDataSerializer().serialize(
+    resolvedArgs as SetPauseInstructionDataArgs
+  );
+
+  // Bytes Created On Chain.
+  const bytesCreatedOnChain = 0;
+
+  return transactionBuilder([
+    { instruction: { keys, programId, data }, signers, bytesCreatedOnChain },
+  ]);
+}

package/src/generated/oft302/instructions/setPeerConfig.ts

@@ -0,0 +1,148 @@
+/**
+ * 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,
+  transactionBuilder,
+} from '@metaplex-foundation/umi';
+import {
+  Serializer,
+  bytes,
+  mapSerializer,
+  struct,
+  u32,
+} from '@metaplex-foundation/umi/serializers';
+import {
+  ResolvedAccount,
+  ResolvedAccountsWithIndices,
+  getAccountMetasAndSigners,
+} from '../shared';
+import {
+  PeerConfigParam,
+  PeerConfigParamArgs,
+  getPeerConfigParamSerializer,
+} from '../types';
+
+// Accounts.
+export type SetPeerConfigInstructionAccounts = {
+  admin: Signer;
+  peer: PublicKey | Pda;
+  oftStore: PublicKey | Pda;
+  systemProgram?: PublicKey | Pda;
+};
+
+// Data.
+export type SetPeerConfigInstructionData = {
+  discriminator: Uint8Array;
+  remoteEid: number;
+  config: PeerConfigParam;
+};
+
+export type SetPeerConfigInstructionDataArgs = {
+  remoteEid: number;
+  config: PeerConfigParamArgs;
+};
+
+export function getSetPeerConfigInstructionDataSerializer(): Serializer<
+  SetPeerConfigInstructionDataArgs,
+  SetPeerConfigInstructionData
+> {
+  return mapSerializer<
+    SetPeerConfigInstructionDataArgs,
+    any,
+    SetPeerConfigInstructionData
+  >(
+    struct<SetPeerConfigInstructionData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['remoteEid', u32()],
+        ['config', getPeerConfigParamSerializer()],
+      ],
+      { description: 'SetPeerConfigInstructionData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([79, 187, 168, 57, 139, 140, 93, 47]),
+    })
+  ) as Serializer<
+    SetPeerConfigInstructionDataArgs,
+    SetPeerConfigInstructionData
+  >;
+}
+
+// Args.
+export type SetPeerConfigInstructionArgs = SetPeerConfigInstructionDataArgs;
+
+// Instruction.
+export function setPeerConfig(
+  context: Pick<Context, 'programs'>,
+  input: SetPeerConfigInstructionAccounts & SetPeerConfigInstructionArgs
+): TransactionBuilder {
+  // Program ID.
+  const programId = context.programs.getPublicKey('oft', '');
+
+  // Accounts.
+  const resolvedAccounts = {
+    admin: {
+      index: 0,
+      isWritable: true as boolean,
+      value: input.admin ?? null,
+    },
+    peer: { index: 1, isWritable: true as boolean, value: input.peer ?? null },
+    oftStore: {
+      index: 2,
+      isWritable: false as boolean,
+      value: input.oftStore ?? null,
+    },
+    systemProgram: {
+      index: 3,
+      isWritable: false as boolean,
+      value: input.systemProgram ?? null,
+    },
+  } satisfies ResolvedAccountsWithIndices;
+
+  // Arguments.
+  const resolvedArgs: SetPeerConfigInstructionArgs = { ...input };
+
+  // Default values.
+  if (!resolvedAccounts.systemProgram.value) {
+    resolvedAccounts.systemProgram.value = context.programs.getPublicKey(
+      'splSystem',
+      '11111111111111111111111111111111'
+    );
+    resolvedAccounts.systemProgram.isWritable = false;
+  }
+
+  // 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 = getSetPeerConfigInstructionDataSerializer().serialize(
+    resolvedArgs as SetPeerConfigInstructionDataArgs
+  );
+
+  // Bytes Created On Chain.
+  const bytesCreatedOnChain = 0;
+
+  return transactionBuilder([
+    { instruction: { keys, programId, data }, signers, bytesCreatedOnChain },
+  ]);
+}

package/src/generated/oft302/instructions/withdrawFee.ts

@@ -0,0 +1,151 @@
+/**
+ * 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,
+  transactionBuilder,
+} from '@metaplex-foundation/umi';
+import {
+  Serializer,
+  bytes,
+  mapSerializer,
+  struct,
+  u64,
+} from '@metaplex-foundation/umi/serializers';
+import {
+  ResolvedAccount,
+  ResolvedAccountsWithIndices,
+  getAccountMetasAndSigners,
+} from '../shared';
+
+// Accounts.
+export type WithdrawFeeInstructionAccounts = {
+  admin: Signer;
+  oftStore: PublicKey | Pda;
+  tokenMint: PublicKey | Pda;
+  tokenEscrow: PublicKey | Pda;
+  tokenDest: PublicKey | Pda;
+  tokenProgram?: PublicKey | Pda;
+};
+
+// Data.
+export type WithdrawFeeInstructionData = {
+  discriminator: Uint8Array;
+  feeLd: bigint;
+};
+
+export type WithdrawFeeInstructionDataArgs = { feeLd: number | bigint };
+
+export function getWithdrawFeeInstructionDataSerializer(): Serializer<
+  WithdrawFeeInstructionDataArgs,
+  WithdrawFeeInstructionData
+> {
+  return mapSerializer<
+    WithdrawFeeInstructionDataArgs,
+    any,
+    WithdrawFeeInstructionData
+  >(
+    struct<WithdrawFeeInstructionData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['feeLd', u64()],
+      ],
+      { description: 'WithdrawFeeInstructionData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([14, 122, 231, 218, 31, 238, 223, 150]),
+    })
+  ) as Serializer<WithdrawFeeInstructionDataArgs, WithdrawFeeInstructionData>;
+}
+
+// Args.
+export type WithdrawFeeInstructionArgs = WithdrawFeeInstructionDataArgs;
+
+// Instruction.
+export function withdrawFee(
+  context: Pick<Context, 'programs'>,
+  input: WithdrawFeeInstructionAccounts & WithdrawFeeInstructionArgs
+): TransactionBuilder {
+  // Program ID.
+  const programId = context.programs.getPublicKey('oft', '');
+
+  // Accounts.
+  const resolvedAccounts = {
+    admin: {
+      index: 0,
+      isWritable: false as boolean,
+      value: input.admin ?? null,
+    },
+    oftStore: {
+      index: 1,
+      isWritable: false as boolean,
+      value: input.oftStore ?? null,
+    },
+    tokenMint: {
+      index: 2,
+      isWritable: false as boolean,
+      value: input.tokenMint ?? null,
+    },
+    tokenEscrow: {
+      index: 3,
+      isWritable: true as boolean,
+      value: input.tokenEscrow ?? null,
+    },
+    tokenDest: {
+      index: 4,
+      isWritable: true as boolean,
+      value: input.tokenDest ?? null,
+    },
+    tokenProgram: {
+      index: 5,
+      isWritable: false as boolean,
+      value: input.tokenProgram ?? null,
+    },
+  } satisfies ResolvedAccountsWithIndices;
+
+  // Arguments.
+  const resolvedArgs: WithdrawFeeInstructionArgs = { ...input };
+
+  // Default values.
+  if (!resolvedAccounts.tokenProgram.value) {
+    resolvedAccounts.tokenProgram.value = context.programs.getPublicKey(
+      'splToken',
+      'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
+    );
+    resolvedAccounts.tokenProgram.isWritable = false;
+  }
+
+  // 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 = getWithdrawFeeInstructionDataSerializer().serialize(
+    resolvedArgs as WithdrawFeeInstructionDataArgs
+  );
+
+  // Bytes Created On Chain.
+  const bytesCreatedOnChain = 0;
+
+  return transactionBuilder([
+    { instruction: { keys, programId, data }, signers, bytesCreatedOnChain },
+  ]);
+}

package/src/generated/oft302/programs/index.ts

@@ -0,0 +1,9 @@
+/**
+ * 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
+ */
+
+export * from './oft';

package/src/generated/oft302/programs/oft.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 {
+  ClusterFilter,
+  Context,
+  Program,
+  PublicKey,
+} from '@metaplex-foundation/umi';
+import { getOftErrorFromCode, getOftErrorFromName } from '../errors';
+
+export const OFT_PROGRAM_ID = '' as PublicKey<''>;
+
+export function createOftProgram(): Program {
+  return {
+    name: 'oft',
+    publicKey: OFT_PROGRAM_ID,
+    getErrorFromCode(code: number, cause?: Error) {
+      return getOftErrorFromCode(code, this, cause);
+    },
+    getErrorFromName(name: string, cause?: Error) {
+      return getOftErrorFromName(name, this, cause);
+    },
+    isOnCluster() {
+      return true;
+    },
+  };
+}
+
+export function getOftProgram<T extends Program = Program>(
+  context: Pick<Context, 'programs'>,
+  clusterFilter?: ClusterFilter
+): T {
+  return context.programs.get<T>('oft', clusterFilter);
+}
+
+export function getOftProgramId(
+  context: Pick<Context, 'programs'>,
+  clusterFilter?: ClusterFilter
+): PublicKey {
+  return context.programs.getPublicKey('oft', OFT_PROGRAM_ID, clusterFilter);
+}

package/src/generated/oft302/shared/index.ts

@@ -0,0 +1,117 @@
+/**
+ * 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 {
+  AccountMeta,
+  isSigner,
+  Pda,
+  publicKey,
+  PublicKey,
+  Signer,
+  isPda,
+} from '@metaplex-foundation/umi';
+
+/**
+ * Transforms the given object such that the given keys are optional.
+ * @internal
+ */
+export type PickPartial<T, K extends keyof T> = Omit<T, K> &
+  Partial<Pick<T, K>>;
+
+/**
+ * Asserts that the given value is not null or undefined.
+ * @internal
+ */
+export function expectSome<T>(value: T | null | undefined): T {
+  if (value == null) {
+    throw new Error('Expected a value but received null or undefined.');
+  }
+  return value;
+}
+
+/**
+ * Asserts that the given value is a PublicKey.
+ * @internal
+ */
+export function expectPublicKey(
+  value: PublicKey | Pda | Signer | null | undefined
+): PublicKey {
+  if (!value) {
+    throw new Error('Expected a PublicKey.');
+  }
+  return publicKey(value, false);
+}
+
+/**
+ * Asserts that the given value is a PDA.
+ * @internal
+ */
+export function expectPda(
+  value: PublicKey | Pda | Signer | null | undefined
+): Pda {
+  if (!value || !Array.isArray(value) || !isPda(value)) {
+    throw new Error('Expected a PDA.');
+  }
+  return value;
+}
+
+/**
+ * Defines an instruction account to resolve.
+ * @internal
+ */
+export type ResolvedAccount<T = PublicKey | Pda | Signer | null> = {
+  isWritable: boolean;
+  value: T;
+};
+
+/**
+ * Defines a set of instruction account to resolve.
+ * @internal
+ */
+export type ResolvedAccounts = Record<string, ResolvedAccount>;
+
+/**
+ * Defines a set of instruction account to resolve with their indices.
+ * @internal
+ */
+export type ResolvedAccountsWithIndices = Record<
+  string,
+  ResolvedAccount & { index: number }
+>;
+
+/**
+ * Get account metas and signers from resolved accounts.
+ * @internal
+ */
+export function getAccountMetasAndSigners(
+  accounts: ResolvedAccount[],
+  optionalAccountStrategy: 'omitted' | 'programId',
+  programId: PublicKey
+): [AccountMeta[], Signer[]] {
+  const keys: AccountMeta[] = [];
+  const signers: Signer[] = [];
+
+  accounts.forEach((account) => {
+    if (!account.value) {
+      if (optionalAccountStrategy === 'omitted') return;
+      keys.push({ pubkey: programId, isSigner: false, isWritable: false });
+      return;
+    }
+
+    if (isSigner(account.value)) {
+      signers.push(account.value);
+    }
+    keys.push({
+      pubkey: publicKey(account.value, false),
+      isSigner: isSigner(account.value),
+      isWritable: account.isWritable,
+    });
+  });
+
+  return [keys, signers];
+}

package/src/generated/oft302/types/enforcedOptions.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 {
+  Serializer,
+  bytes,
+  struct,
+  u32,
+} from '@metaplex-foundation/umi/serializers';
+
+export type EnforcedOptions = { send: Uint8Array; sendAndCall: Uint8Array };
+
+export type EnforcedOptionsArgs = EnforcedOptions;
+
+export function getEnforcedOptionsSerializer(): Serializer<
+  EnforcedOptionsArgs,
+  EnforcedOptions
+> {
+  return struct<EnforcedOptions>(
+    [
+      ['send', bytes({ size: u32() })],
+      ['sendAndCall', bytes({ size: u32() })],
+    ],
+    { description: 'EnforcedOptions' }
+  ) as Serializer<EnforcedOptionsArgs, EnforcedOptions>;
+}

package/src/generated/oft302/types/lzAccount.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 { PublicKey } from '@metaplex-foundation/umi';
+import {
+  Serializer,
+  bool,
+  publicKey as publicKeySerializer,
+  struct,
+} from '@metaplex-foundation/umi/serializers';
+
+/** same to anchor_lang::prelude::AccountMeta */
+export type LzAccount = {
+  pubkey: PublicKey;
+  isSigner: boolean;
+  isWritable: boolean;
+};
+
+export type LzAccountArgs = LzAccount;
+
+export function getLzAccountSerializer(): Serializer<LzAccountArgs, LzAccount> {
+  return struct<LzAccount>(
+    [
+      ['pubkey', publicKeySerializer()],
+      ['isSigner', bool()],
+      ['isWritable', bool()],
+    ],
+    { description: 'LzAccount' }
+  ) as Serializer<LzAccountArgs, LzAccount>;
+}

package/src/generated/oft302/types/lzReceiveParams.ts

@@ -0,0 +1,50 @@
+/**
+ * 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 {
+  Serializer,
+  bytes,
+  struct,
+  u32,
+  u64,
+} from '@metaplex-foundation/umi/serializers';
+
+export type LzReceiveParams = {
+  srcEid: number;
+  sender: Uint8Array;
+  nonce: bigint;
+  guid: Uint8Array;
+  message: Uint8Array;
+  extraData: Uint8Array;
+};
+
+export type LzReceiveParamsArgs = {
+  srcEid: number;
+  sender: Uint8Array;
+  nonce: number | bigint;
+  guid: Uint8Array;
+  message: Uint8Array;
+  extraData: Uint8Array;
+};
+
+export function getLzReceiveParamsSerializer(): Serializer<
+  LzReceiveParamsArgs,
+  LzReceiveParams
+> {
+  return struct<LzReceiveParams>(
+    [
+      ['srcEid', u32()],
+      ['sender', bytes({ size: 32 })],
+      ['nonce', u64()],
+      ['guid', bytes({ size: 32 })],
+      ['message', bytes({ size: u32() })],
+      ['extraData', bytes({ size: u32() })],
+    ],
+    { description: 'LzReceiveParams' }
+  ) as Serializer<LzReceiveParamsArgs, LzReceiveParams>;
+}