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

package/src/generated/kinobi/simple_messagelib/accounts/receiveConfigStore.ts

@@ -0,0 +1,162 @@
+/**
+ * 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 {
+  Account,
+  Context,
+  Pda,
+  PublicKey,
+  RpcAccount,
+  RpcGetAccountOptions,
+  RpcGetAccountsOptions,
+  assertAccountExists,
+  deserializeAccount,
+  gpaBuilder,
+  publicKey as toPublicKey,
+} from '@metaplex-foundation/umi';
+import {
+  Serializer,
+  bytes,
+  mapSerializer,
+  struct,
+  u32,
+  u8,
+} from '@metaplex-foundation/umi/serializers';
+
+export type ReceiveConfigStore = Account<ReceiveConfigStoreAccountData>;
+
+export type ReceiveConfigStoreAccountData = {
+  discriminator: Uint8Array;
+  bump: number;
+  data: Uint8Array;
+};
+
+export type ReceiveConfigStoreAccountDataArgs = {
+  bump: number;
+  data: Uint8Array;
+};
+
+export function getReceiveConfigStoreAccountDataSerializer(): Serializer<
+  ReceiveConfigStoreAccountDataArgs,
+  ReceiveConfigStoreAccountData
+> {
+  return mapSerializer<
+    ReceiveConfigStoreAccountDataArgs,
+    any,
+    ReceiveConfigStoreAccountData
+  >(
+    struct<ReceiveConfigStoreAccountData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['bump', u8()],
+        ['data', bytes({ size: u32() })],
+      ],
+      { description: 'ReceiveConfigStoreAccountData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([70, 73, 30, 1, 248, 48, 93, 125]),
+    })
+  ) as Serializer<
+    ReceiveConfigStoreAccountDataArgs,
+    ReceiveConfigStoreAccountData
+  >;
+}
+
+export function deserializeReceiveConfigStore(
+  rawAccount: RpcAccount
+): ReceiveConfigStore {
+  return deserializeAccount(
+    rawAccount,
+    getReceiveConfigStoreAccountDataSerializer()
+  );
+}
+
+export async function fetchReceiveConfigStore(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<ReceiveConfigStore> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  assertAccountExists(maybeAccount, 'ReceiveConfigStore');
+  return deserializeReceiveConfigStore(maybeAccount);
+}
+
+export async function safeFetchReceiveConfigStore(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<ReceiveConfigStore | null> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  return maybeAccount.exists
+    ? deserializeReceiveConfigStore(maybeAccount)
+    : null;
+}
+
+export async function fetchAllReceiveConfigStore(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<ReceiveConfigStore[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts.map((maybeAccount) => {
+    assertAccountExists(maybeAccount, 'ReceiveConfigStore');
+    return deserializeReceiveConfigStore(maybeAccount);
+  });
+}
+
+export async function safeFetchAllReceiveConfigStore(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<ReceiveConfigStore[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts
+    .filter((maybeAccount) => maybeAccount.exists)
+    .map((maybeAccount) =>
+      deserializeReceiveConfigStore(maybeAccount as RpcAccount)
+    );
+}
+
+export function getReceiveConfigStoreGpaBuilder(
+  context: Pick<Context, 'rpc' | 'programs'>
+) {
+  const programId = context.programs.getPublicKey(
+    'simpleMessagelib',
+    '6GsmxMTHAAiFKfemuM4zBjumTjNSX5CAiw4xSSXM2Toy'
+  );
+  return gpaBuilder(context, programId)
+    .registerFields<{
+      discriminator: Uint8Array;
+      bump: number;
+      data: Uint8Array;
+    }>({
+      discriminator: [0, bytes({ size: 8 })],
+      bump: [8, u8()],
+      data: [9, bytes({ size: u32() })],
+    })
+    .deserializeUsing<ReceiveConfigStore>((account) =>
+      deserializeReceiveConfigStore(account)
+    )
+    .whereField(
+      'discriminator',
+      new Uint8Array([70, 73, 30, 1, 248, 48, 93, 125])
+    );
+}

package/src/generated/kinobi/simple_messagelib/accounts/sendConfigStore.ts

@@ -0,0 +1,154 @@
+/**
+ * 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 {
+  Account,
+  Context,
+  Pda,
+  PublicKey,
+  RpcAccount,
+  RpcGetAccountOptions,
+  RpcGetAccountsOptions,
+  assertAccountExists,
+  deserializeAccount,
+  gpaBuilder,
+  publicKey as toPublicKey,
+} from '@metaplex-foundation/umi';
+import {
+  Serializer,
+  bytes,
+  mapSerializer,
+  struct,
+  u32,
+  u8,
+} from '@metaplex-foundation/umi/serializers';
+
+export type SendConfigStore = Account<SendConfigStoreAccountData>;
+
+export type SendConfigStoreAccountData = {
+  discriminator: Uint8Array;
+  bump: number;
+  data: Uint8Array;
+};
+
+export type SendConfigStoreAccountDataArgs = { bump: number; data: Uint8Array };
+
+export function getSendConfigStoreAccountDataSerializer(): Serializer<
+  SendConfigStoreAccountDataArgs,
+  SendConfigStoreAccountData
+> {
+  return mapSerializer<
+    SendConfigStoreAccountDataArgs,
+    any,
+    SendConfigStoreAccountData
+  >(
+    struct<SendConfigStoreAccountData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['bump', u8()],
+        ['data', bytes({ size: u32() })],
+      ],
+      { description: 'SendConfigStoreAccountData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([246, 55, 104, 200, 90, 164, 50, 196]),
+    })
+  ) as Serializer<SendConfigStoreAccountDataArgs, SendConfigStoreAccountData>;
+}
+
+export function deserializeSendConfigStore(
+  rawAccount: RpcAccount
+): SendConfigStore {
+  return deserializeAccount(
+    rawAccount,
+    getSendConfigStoreAccountDataSerializer()
+  );
+}
+
+export async function fetchSendConfigStore(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<SendConfigStore> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  assertAccountExists(maybeAccount, 'SendConfigStore');
+  return deserializeSendConfigStore(maybeAccount);
+}
+
+export async function safeFetchSendConfigStore(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<SendConfigStore | null> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  return maybeAccount.exists ? deserializeSendConfigStore(maybeAccount) : null;
+}
+
+export async function fetchAllSendConfigStore(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<SendConfigStore[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts.map((maybeAccount) => {
+    assertAccountExists(maybeAccount, 'SendConfigStore');
+    return deserializeSendConfigStore(maybeAccount);
+  });
+}
+
+export async function safeFetchAllSendConfigStore(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<SendConfigStore[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts
+    .filter((maybeAccount) => maybeAccount.exists)
+    .map((maybeAccount) =>
+      deserializeSendConfigStore(maybeAccount as RpcAccount)
+    );
+}
+
+export function getSendConfigStoreGpaBuilder(
+  context: Pick<Context, 'rpc' | 'programs'>
+) {
+  const programId = context.programs.getPublicKey(
+    'simpleMessagelib',
+    '6GsmxMTHAAiFKfemuM4zBjumTjNSX5CAiw4xSSXM2Toy'
+  );
+  return gpaBuilder(context, programId)
+    .registerFields<{
+      discriminator: Uint8Array;
+      bump: number;
+      data: Uint8Array;
+    }>({
+      discriminator: [0, bytes({ size: 8 })],
+      bump: [8, u8()],
+      data: [9, bytes({ size: u32() })],
+    })
+    .deserializeUsing<SendConfigStore>((account) =>
+      deserializeSendConfigStore(account)
+    )
+    .whereField(
+      'discriminator',
+      new Uint8Array([246, 55, 104, 200, 90, 164, 50, 196])
+    );
+}

package/src/generated/kinobi/simple_messagelib/errors/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 './simpleMessagelib';

package/src/generated/kinobi/simple_messagelib/errors/simpleMessagelib.ts

@@ -0,0 +1,146 @@
+/**
+ * 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 { Program, ProgramError } from '@metaplex-foundation/umi';
+
+type ProgramErrorConstructor = new (
+  program: Program,
+  cause?: Error
+) => ProgramError;
+const codeToErrorMap: Map<number, ProgramErrorConstructor> = new Map();
+const nameToErrorMap: Map<string, ProgramErrorConstructor> = new Map();
+
+/** OnlyWhitelistedCaller */
+export class OnlyWhitelistedCallerError extends ProgramError {
+  override readonly name: string = 'OnlyWhitelistedCaller';
+
+  readonly code: number = 0x1770; // 6000
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1770, OnlyWhitelistedCallerError);
+nameToErrorMap.set('OnlyWhitelistedCaller', OnlyWhitelistedCallerError);
+
+/** InsufficientFee */
+export class InsufficientFeeError extends ProgramError {
+  override readonly name: string = 'InsufficientFee';
+
+  readonly code: number = 0x1771; // 6001
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1771, InsufficientFeeError);
+nameToErrorMap.set('InsufficientFee', InsufficientFeeError);
+
+/** InvalidAmount */
+export class InvalidAmountError extends ProgramError {
+  override readonly name: string = 'InvalidAmount';
+
+  readonly code: number = 0x1772; // 6002
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1772, InvalidAmountError);
+nameToErrorMap.set('InvalidAmount', InvalidAmountError);
+
+/** InvalidConfigType */
+export class InvalidConfigTypeError extends ProgramError {
+  override readonly name: string = 'InvalidConfigType';
+
+  readonly code: number = 0x1773; // 6003
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1773, InvalidConfigTypeError);
+nameToErrorMap.set('InvalidConfigType', InvalidConfigTypeError);
+
+/** InvalidLzTokenMint */
+export class InvalidLzTokenMintError extends ProgramError {
+  override readonly name: string = 'InvalidLzTokenMint';
+
+  readonly code: number = 0x1774; // 6004
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1774, InvalidLzTokenMintError);
+nameToErrorMap.set('InvalidLzTokenMint', InvalidLzTokenMintError);
+
+/** LzTokenUnavailable */
+export class LzTokenUnavailableError extends ProgramError {
+  override readonly name: string = 'LzTokenUnavailable';
+
+  readonly code: number = 0x1775; // 6005
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1775, LzTokenUnavailableError);
+nameToErrorMap.set('LzTokenUnavailable', LzTokenUnavailableError);
+
+/** SendReentrancy */
+export class SendReentrancyError extends ProgramError {
+  override readonly name: string = 'SendReentrancy';
+
+  readonly code: number = 0x1776; // 6006
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1776, SendReentrancyError);
+nameToErrorMap.set('SendReentrancy', SendReentrancyError);
+
+/** OnlyRevert */
+export class OnlyRevertError extends ProgramError {
+  override readonly name: string = 'OnlyRevert';
+
+  readonly code: number = 0x1777; // 6007
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1777, OnlyRevertError);
+nameToErrorMap.set('OnlyRevert', OnlyRevertError);
+
+/**
+ * Attempts to resolve a custom program error from the provided error code.
+ * @category Errors
+ */
+export function getSimpleMessagelibErrorFromCode(
+  code: number,
+  program: Program,
+  cause?: Error
+): ProgramError | null {
+  const constructor = codeToErrorMap.get(code);
+  return constructor ? new constructor(program, cause) : null;
+}
+
+/**
+ * Attempts to resolve a custom program error from the provided error name, i.e. 'Unauthorized'.
+ * @category Errors
+ */
+export function getSimpleMessagelibErrorFromName(
+  name: string,
+  program: Program,
+  cause?: Error
+): ProgramError | null {
+  const constructor = nameToErrorMap.get(name);
+  return constructor ? new constructor(program, cause) : null;
+}

package/src/generated/kinobi/simple_messagelib/index.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 './accounts';
+export * from './errors';
+export * from './instructions';
+export * from './programs';
+export * from './shared';
+export * from './types';

package/src/generated/kinobi/simple_messagelib/instructions/index.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 './initConfig';
+export * from './initDefaultConfig';
+export * from './initMessageLib';
+export * from './quote';
+export * from './revertCall';
+export * from './send';
+export * from './sendWithLzToken';
+export * from './setConfig';
+export * from './setDefaultConfig';
+export * from './setFee';
+export * from './setWlCaller';
+export * from './transferAdmin';
+export * from './validatePacket';
+export * from './version';
+export * from './withdrawFees';

package/src/generated/kinobi/simple_messagelib/instructions/initConfig.ts

@@ -0,0 +1,160 @@
+/**
+ * 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,
+  publicKey as publicKeySerializer,
+  struct,
+  u32,
+} from '@metaplex-foundation/umi/serializers';
+import {
+  ResolvedAccount,
+  ResolvedAccountsWithIndices,
+  getAccountMetasAndSigners,
+} from '../shared';
+
+// Accounts.
+export type InitConfigInstructionAccounts = {
+  endpoint: Signer;
+  payer?: Signer;
+  messageLib: PublicKey | Pda;
+  sendConfig: PublicKey | Pda;
+  receiveConfig: PublicKey | Pda;
+  systemProgram?: PublicKey | Pda;
+};
+
+// Data.
+export type InitConfigInstructionData = {
+  discriminator: Uint8Array;
+  oapp: PublicKey;
+  eid: number;
+};
+
+export type InitConfigInstructionDataArgs = { oapp: PublicKey; eid: number };
+
+export function getInitConfigInstructionDataSerializer(): Serializer<
+  InitConfigInstructionDataArgs,
+  InitConfigInstructionData
+> {
+  return mapSerializer<
+    InitConfigInstructionDataArgs,
+    any,
+    InitConfigInstructionData
+  >(
+    struct<InitConfigInstructionData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['oapp', publicKeySerializer()],
+        ['eid', u32()],
+      ],
+      { description: 'InitConfigInstructionData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([23, 235, 115, 232, 168, 96, 1, 231]),
+    })
+  ) as Serializer<InitConfigInstructionDataArgs, InitConfigInstructionData>;
+}
+
+// Args.
+export type InitConfigInstructionArgs = InitConfigInstructionDataArgs;
+
+// Instruction.
+export function initConfig(
+  context: Pick<Context, 'payer' | 'programs'>,
+  input: InitConfigInstructionAccounts & InitConfigInstructionArgs
+): TransactionBuilder {
+  // Program ID.
+  const programId = context.programs.getPublicKey(
+    'simpleMessagelib',
+    '6GsmxMTHAAiFKfemuM4zBjumTjNSX5CAiw4xSSXM2Toy'
+  );
+
+  // Accounts.
+  const resolvedAccounts = {
+    endpoint: {
+      index: 0,
+      isWritable: false as boolean,
+      value: input.endpoint ?? null,
+    },
+    payer: {
+      index: 1,
+      isWritable: true as boolean,
+      value: input.payer ?? null,
+    },
+    messageLib: {
+      index: 2,
+      isWritable: false as boolean,
+      value: input.messageLib ?? null,
+    },
+    sendConfig: {
+      index: 3,
+      isWritable: true as boolean,
+      value: input.sendConfig ?? null,
+    },
+    receiveConfig: {
+      index: 4,
+      isWritable: true as boolean,
+      value: input.receiveConfig ?? null,
+    },
+    systemProgram: {
+      index: 5,
+      isWritable: false as boolean,
+      value: input.systemProgram ?? null,
+    },
+  } satisfies ResolvedAccountsWithIndices;
+
+  // Arguments.
+  const resolvedArgs: InitConfigInstructionArgs = { ...input };
+
+  // Default values.
+  if (!resolvedAccounts.payer.value) {
+    resolvedAccounts.payer.value = context.payer;
+  }
+  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 = getInitConfigInstructionDataSerializer().serialize(
+    resolvedArgs as InitConfigInstructionDataArgs
+  );
+
+  // Bytes Created On Chain.
+  const bytesCreatedOnChain = 0;
+
+  return transactionBuilder([
+    { instruction: { keys, programId, data }, signers, bytesCreatedOnChain },
+  ]);
+}