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

package/src/generated/kinobi/endpoint/accounts/pendingInboundNonce.ts

@@ -0,0 +1,163 @@
+/**
+ * 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,
+  array,
+  bytes,
+  mapSerializer,
+  struct,
+  u64,
+  u8,
+} from '@metaplex-foundation/umi/serializers';
+
+export type PendingInboundNonce = Account<PendingInboundNonceAccountData>;
+
+export type PendingInboundNonceAccountData = {
+  discriminator: Uint8Array;
+  nonces: Array<bigint>;
+  bump: number;
+};
+
+export type PendingInboundNonceAccountDataArgs = {
+  nonces: Array<number | bigint>;
+  bump: number;
+};
+
+export function getPendingInboundNonceAccountDataSerializer(): Serializer<
+  PendingInboundNonceAccountDataArgs,
+  PendingInboundNonceAccountData
+> {
+  return mapSerializer<
+    PendingInboundNonceAccountDataArgs,
+    any,
+    PendingInboundNonceAccountData
+  >(
+    struct<PendingInboundNonceAccountData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['nonces', array(u64())],
+        ['bump', u8()],
+      ],
+      { description: 'PendingInboundNonceAccountData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([170, 176, 95, 240, 120, 231, 241, 218]),
+    })
+  ) as Serializer<
+    PendingInboundNonceAccountDataArgs,
+    PendingInboundNonceAccountData
+  >;
+}
+
+export function deserializePendingInboundNonce(
+  rawAccount: RpcAccount
+): PendingInboundNonce {
+  return deserializeAccount(
+    rawAccount,
+    getPendingInboundNonceAccountDataSerializer()
+  );
+}
+
+export async function fetchPendingInboundNonce(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<PendingInboundNonce> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  assertAccountExists(maybeAccount, 'PendingInboundNonce');
+  return deserializePendingInboundNonce(maybeAccount);
+}
+
+export async function safeFetchPendingInboundNonce(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<PendingInboundNonce | null> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  return maybeAccount.exists
+    ? deserializePendingInboundNonce(maybeAccount)
+    : null;
+}
+
+export async function fetchAllPendingInboundNonce(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<PendingInboundNonce[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts.map((maybeAccount) => {
+    assertAccountExists(maybeAccount, 'PendingInboundNonce');
+    return deserializePendingInboundNonce(maybeAccount);
+  });
+}
+
+export async function safeFetchAllPendingInboundNonce(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<PendingInboundNonce[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts
+    .filter((maybeAccount) => maybeAccount.exists)
+    .map((maybeAccount) =>
+      deserializePendingInboundNonce(maybeAccount as RpcAccount)
+    );
+}
+
+export function getPendingInboundNonceGpaBuilder(
+  context: Pick<Context, 'rpc' | 'programs'>
+) {
+  const programId = context.programs.getPublicKey(
+    'endpoint',
+    '76y77prsiCMvXMjuoZ5VRrhG5qYBrUMYTE5WgHqgjEn6'
+  );
+  return gpaBuilder(context, programId)
+    .registerFields<{
+      discriminator: Uint8Array;
+      nonces: Array<number | bigint>;
+      bump: number;
+    }>({
+      discriminator: [0, bytes({ size: 8 })],
+      nonces: [8, array(u64())],
+      bump: [null, u8()],
+    })
+    .deserializeUsing<PendingInboundNonce>((account) =>
+      deserializePendingInboundNonce(account)
+    )
+    .whereField(
+      'discriminator',
+      new Uint8Array([170, 176, 95, 240, 120, 231, 241, 218])
+    );
+}

package/src/generated/kinobi/endpoint/accounts/receiveLibraryConfig.ts

@@ -0,0 +1,175 @@
+/**
+ * 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,
+  Option,
+  OptionOrNullable,
+  Pda,
+  PublicKey,
+  RpcAccount,
+  RpcGetAccountOptions,
+  RpcGetAccountsOptions,
+  assertAccountExists,
+  deserializeAccount,
+  gpaBuilder,
+  publicKey as toPublicKey,
+} from '@metaplex-foundation/umi';
+import {
+  Serializer,
+  bytes,
+  mapSerializer,
+  option,
+  publicKey as publicKeySerializer,
+  struct,
+  u8,
+} from '@metaplex-foundation/umi/serializers';
+import {
+  ReceiveLibraryTimeout,
+  ReceiveLibraryTimeoutArgs,
+  getReceiveLibraryTimeoutSerializer,
+} from '../types';
+
+export type ReceiveLibraryConfig = Account<ReceiveLibraryConfigAccountData>;
+
+export type ReceiveLibraryConfigAccountData = {
+  discriminator: Uint8Array;
+  messageLib: PublicKey;
+  timeout: Option<ReceiveLibraryTimeout>;
+  bump: number;
+};
+
+export type ReceiveLibraryConfigAccountDataArgs = {
+  messageLib: PublicKey;
+  timeout: OptionOrNullable<ReceiveLibraryTimeoutArgs>;
+  bump: number;
+};
+
+export function getReceiveLibraryConfigAccountDataSerializer(): Serializer<
+  ReceiveLibraryConfigAccountDataArgs,
+  ReceiveLibraryConfigAccountData
+> {
+  return mapSerializer<
+    ReceiveLibraryConfigAccountDataArgs,
+    any,
+    ReceiveLibraryConfigAccountData
+  >(
+    struct<ReceiveLibraryConfigAccountData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['messageLib', publicKeySerializer()],
+        ['timeout', option(getReceiveLibraryTimeoutSerializer())],
+        ['bump', u8()],
+      ],
+      { description: 'ReceiveLibraryConfigAccountData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([142, 226, 251, 138, 1, 206, 91, 193]),
+    })
+  ) as Serializer<
+    ReceiveLibraryConfigAccountDataArgs,
+    ReceiveLibraryConfigAccountData
+  >;
+}
+
+export function deserializeReceiveLibraryConfig(
+  rawAccount: RpcAccount
+): ReceiveLibraryConfig {
+  return deserializeAccount(
+    rawAccount,
+    getReceiveLibraryConfigAccountDataSerializer()
+  );
+}
+
+export async function fetchReceiveLibraryConfig(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<ReceiveLibraryConfig> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  assertAccountExists(maybeAccount, 'ReceiveLibraryConfig');
+  return deserializeReceiveLibraryConfig(maybeAccount);
+}
+
+export async function safeFetchReceiveLibraryConfig(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<ReceiveLibraryConfig | null> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  return maybeAccount.exists
+    ? deserializeReceiveLibraryConfig(maybeAccount)
+    : null;
+}
+
+export async function fetchAllReceiveLibraryConfig(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<ReceiveLibraryConfig[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts.map((maybeAccount) => {
+    assertAccountExists(maybeAccount, 'ReceiveLibraryConfig');
+    return deserializeReceiveLibraryConfig(maybeAccount);
+  });
+}
+
+export async function safeFetchAllReceiveLibraryConfig(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<ReceiveLibraryConfig[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts
+    .filter((maybeAccount) => maybeAccount.exists)
+    .map((maybeAccount) =>
+      deserializeReceiveLibraryConfig(maybeAccount as RpcAccount)
+    );
+}
+
+export function getReceiveLibraryConfigGpaBuilder(
+  context: Pick<Context, 'rpc' | 'programs'>
+) {
+  const programId = context.programs.getPublicKey(
+    'endpoint',
+    '76y77prsiCMvXMjuoZ5VRrhG5qYBrUMYTE5WgHqgjEn6'
+  );
+  return gpaBuilder(context, programId)
+    .registerFields<{
+      discriminator: Uint8Array;
+      messageLib: PublicKey;
+      timeout: OptionOrNullable<ReceiveLibraryTimeoutArgs>;
+      bump: number;
+    }>({
+      discriminator: [0, bytes({ size: 8 })],
+      messageLib: [8, publicKeySerializer()],
+      timeout: [40, option(getReceiveLibraryTimeoutSerializer())],
+      bump: [null, u8()],
+    })
+    .deserializeUsing<ReceiveLibraryConfig>((account) =>
+      deserializeReceiveLibraryConfig(account)
+    )
+    .whereField(
+      'discriminator',
+      new Uint8Array([142, 226, 251, 138, 1, 206, 91, 193])
+    );
+}

package/src/generated/kinobi/endpoint/accounts/sendLibraryConfig.ts

@@ -0,0 +1,167 @@
+/**
+ * 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,
+  publicKey as publicKeySerializer,
+  struct,
+  u8,
+} from '@metaplex-foundation/umi/serializers';
+
+/** the reason for not using Option::None to indicate default is to respect the spec on evm */
+export type SendLibraryConfig = Account<SendLibraryConfigAccountData>;
+
+export type SendLibraryConfigAccountData = {
+  discriminator: Uint8Array;
+  messageLib: PublicKey;
+  bump: number;
+};
+
+export type SendLibraryConfigAccountDataArgs = {
+  messageLib: PublicKey;
+  bump: number;
+};
+
+export function getSendLibraryConfigAccountDataSerializer(): Serializer<
+  SendLibraryConfigAccountDataArgs,
+  SendLibraryConfigAccountData
+> {
+  return mapSerializer<
+    SendLibraryConfigAccountDataArgs,
+    any,
+    SendLibraryConfigAccountData
+  >(
+    struct<SendLibraryConfigAccountData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['messageLib', publicKeySerializer()],
+        ['bump', u8()],
+      ],
+      { description: 'SendLibraryConfigAccountData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([61, 238, 31, 72, 251, 117, 66, 176]),
+    })
+  ) as Serializer<
+    SendLibraryConfigAccountDataArgs,
+    SendLibraryConfigAccountData
+  >;
+}
+
+export function deserializeSendLibraryConfig(
+  rawAccount: RpcAccount
+): SendLibraryConfig {
+  return deserializeAccount(
+    rawAccount,
+    getSendLibraryConfigAccountDataSerializer()
+  );
+}
+
+export async function fetchSendLibraryConfig(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<SendLibraryConfig> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  assertAccountExists(maybeAccount, 'SendLibraryConfig');
+  return deserializeSendLibraryConfig(maybeAccount);
+}
+
+export async function safeFetchSendLibraryConfig(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<SendLibraryConfig | null> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  return maybeAccount.exists
+    ? deserializeSendLibraryConfig(maybeAccount)
+    : null;
+}
+
+export async function fetchAllSendLibraryConfig(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<SendLibraryConfig[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts.map((maybeAccount) => {
+    assertAccountExists(maybeAccount, 'SendLibraryConfig');
+    return deserializeSendLibraryConfig(maybeAccount);
+  });
+}
+
+export async function safeFetchAllSendLibraryConfig(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<SendLibraryConfig[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts
+    .filter((maybeAccount) => maybeAccount.exists)
+    .map((maybeAccount) =>
+      deserializeSendLibraryConfig(maybeAccount as RpcAccount)
+    );
+}
+
+export function getSendLibraryConfigGpaBuilder(
+  context: Pick<Context, 'rpc' | 'programs'>
+) {
+  const programId = context.programs.getPublicKey(
+    'endpoint',
+    '76y77prsiCMvXMjuoZ5VRrhG5qYBrUMYTE5WgHqgjEn6'
+  );
+  return gpaBuilder(context, programId)
+    .registerFields<{
+      discriminator: Uint8Array;
+      messageLib: PublicKey;
+      bump: number;
+    }>({
+      discriminator: [0, bytes({ size: 8 })],
+      messageLib: [8, publicKeySerializer()],
+      bump: [40, u8()],
+    })
+    .deserializeUsing<SendLibraryConfig>((account) =>
+      deserializeSendLibraryConfig(account)
+    )
+    .whereField(
+      'discriminator',
+      new Uint8Array([61, 238, 31, 72, 251, 117, 66, 176])
+    );
+}
+
+export function getSendLibraryConfigSize(): number {
+  return 41;
+}