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

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

@@ -0,0 +1,170 @@
+/**
+ * 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,
+  u8,
+} from '@metaplex-foundation/umi/serializers';
+import {
+  MessageLibType,
+  MessageLibTypeArgs,
+  getMessageLibTypeSerializer,
+} from '../types';
+
+export type MessageLibInfo = Account<MessageLibInfoAccountData>;
+
+export type MessageLibInfoAccountData = {
+  discriminator: Uint8Array;
+  messageLibType: MessageLibType;
+  bump: number;
+  messageLibBump: number;
+};
+
+export type MessageLibInfoAccountDataArgs = {
+  messageLibType: MessageLibTypeArgs;
+  bump: number;
+  messageLibBump: number;
+};
+
+export function getMessageLibInfoAccountDataSerializer(): Serializer<
+  MessageLibInfoAccountDataArgs,
+  MessageLibInfoAccountData
+> {
+  return mapSerializer<
+    MessageLibInfoAccountDataArgs,
+    any,
+    MessageLibInfoAccountData
+  >(
+    struct<MessageLibInfoAccountData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['messageLibType', getMessageLibTypeSerializer()],
+        ['bump', u8()],
+        ['messageLibBump', u8()],
+      ],
+      { description: 'MessageLibInfoAccountData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([103, 102, 218, 28, 204, 135, 71, 14]),
+    })
+  ) as Serializer<MessageLibInfoAccountDataArgs, MessageLibInfoAccountData>;
+}
+
+export function deserializeMessageLibInfo(
+  rawAccount: RpcAccount
+): MessageLibInfo {
+  return deserializeAccount(
+    rawAccount,
+    getMessageLibInfoAccountDataSerializer()
+  );
+}
+
+export async function fetchMessageLibInfo(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<MessageLibInfo> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  assertAccountExists(maybeAccount, 'MessageLibInfo');
+  return deserializeMessageLibInfo(maybeAccount);
+}
+
+export async function safeFetchMessageLibInfo(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<MessageLibInfo | null> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  return maybeAccount.exists ? deserializeMessageLibInfo(maybeAccount) : null;
+}
+
+export async function fetchAllMessageLibInfo(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<MessageLibInfo[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts.map((maybeAccount) => {
+    assertAccountExists(maybeAccount, 'MessageLibInfo');
+    return deserializeMessageLibInfo(maybeAccount);
+  });
+}
+
+export async function safeFetchAllMessageLibInfo(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<MessageLibInfo[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts
+    .filter((maybeAccount) => maybeAccount.exists)
+    .map((maybeAccount) =>
+      deserializeMessageLibInfo(maybeAccount as RpcAccount)
+    );
+}
+
+export function getMessageLibInfoGpaBuilder(
+  context: Pick<Context, 'rpc' | 'programs'>
+) {
+  const programId = context.programs.getPublicKey(
+    'endpoint',
+    '76y77prsiCMvXMjuoZ5VRrhG5qYBrUMYTE5WgHqgjEn6'
+  );
+  return gpaBuilder(context, programId)
+    .registerFields<{
+      discriminator: Uint8Array;
+      messageLibType: MessageLibTypeArgs;
+      bump: number;
+      messageLibBump: number;
+    }>({
+      discriminator: [0, bytes({ size: 8 })],
+      messageLibType: [8, getMessageLibTypeSerializer()],
+      bump: [9, u8()],
+      messageLibBump: [10, u8()],
+    })
+    .deserializeUsing<MessageLibInfo>((account) =>
+      deserializeMessageLibInfo(account)
+    )
+    .whereField(
+      'discriminator',
+      new Uint8Array([103, 102, 218, 28, 204, 135, 71, 14])
+    );
+}
+
+export function getMessageLibInfoSize(): number {
+  return 11;
+}

package/src/generated/kinobi/endpoint/accounts/nonce.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 {
+  Account,
+  Context,
+  Pda,
+  PublicKey,
+  RpcAccount,
+  RpcGetAccountOptions,
+  RpcGetAccountsOptions,
+  assertAccountExists,
+  deserializeAccount,
+  gpaBuilder,
+  publicKey as toPublicKey,
+} from '@metaplex-foundation/umi';
+import {
+  Serializer,
+  bytes,
+  mapSerializer,
+  struct,
+  u64,
+  u8,
+} from '@metaplex-foundation/umi/serializers';
+
+export type Nonce = Account<NonceAccountData>;
+
+export type NonceAccountData = {
+  discriminator: Uint8Array;
+  bump: number;
+  outboundNonce: bigint;
+  inboundNonce: bigint;
+};
+
+export type NonceAccountDataArgs = {
+  bump: number;
+  outboundNonce: number | bigint;
+  inboundNonce: number | bigint;
+};
+
+export function getNonceAccountDataSerializer(): Serializer<
+  NonceAccountDataArgs,
+  NonceAccountData
+> {
+  return mapSerializer<NonceAccountDataArgs, any, NonceAccountData>(
+    struct<NonceAccountData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['bump', u8()],
+        ['outboundNonce', u64()],
+        ['inboundNonce', u64()],
+      ],
+      { description: 'NonceAccountData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([143, 197, 147, 95, 106, 165, 50, 43]),
+    })
+  ) as Serializer<NonceAccountDataArgs, NonceAccountData>;
+}
+
+export function deserializeNonce(rawAccount: RpcAccount): Nonce {
+  return deserializeAccount(rawAccount, getNonceAccountDataSerializer());
+}
+
+export async function fetchNonce(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<Nonce> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  assertAccountExists(maybeAccount, 'Nonce');
+  return deserializeNonce(maybeAccount);
+}
+
+export async function safeFetchNonce(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<Nonce | null> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  return maybeAccount.exists ? deserializeNonce(maybeAccount) : null;
+}
+
+export async function fetchAllNonce(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<Nonce[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts.map((maybeAccount) => {
+    assertAccountExists(maybeAccount, 'Nonce');
+    return deserializeNonce(maybeAccount);
+  });
+}
+
+export async function safeFetchAllNonce(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<Nonce[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts
+    .filter((maybeAccount) => maybeAccount.exists)
+    .map((maybeAccount) => deserializeNonce(maybeAccount as RpcAccount));
+}
+
+export function getNonceGpaBuilder(context: Pick<Context, 'rpc' | 'programs'>) {
+  const programId = context.programs.getPublicKey(
+    'endpoint',
+    '76y77prsiCMvXMjuoZ5VRrhG5qYBrUMYTE5WgHqgjEn6'
+  );
+  return gpaBuilder(context, programId)
+    .registerFields<{
+      discriminator: Uint8Array;
+      bump: number;
+      outboundNonce: number | bigint;
+      inboundNonce: number | bigint;
+    }>({
+      discriminator: [0, bytes({ size: 8 })],
+      bump: [8, u8()],
+      outboundNonce: [9, u64()],
+      inboundNonce: [17, u64()],
+    })
+    .deserializeUsing<Nonce>((account) => deserializeNonce(account))
+    .whereField(
+      'discriminator',
+      new Uint8Array([143, 197, 147, 95, 106, 165, 50, 43])
+    );
+}
+
+export function getNonceSize(): number {
+  return 25;
+}

package/src/generated/kinobi/endpoint/accounts/oAppRegistry.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 {
+  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';
+
+export type OAppRegistry = Account<OAppRegistryAccountData>;
+
+export type OAppRegistryAccountData = {
+  discriminator: Uint8Array;
+  delegate: PublicKey;
+  bump: number;
+};
+
+export type OAppRegistryAccountDataArgs = { delegate: PublicKey; bump: number };
+
+export function getOAppRegistryAccountDataSerializer(): Serializer<
+  OAppRegistryAccountDataArgs,
+  OAppRegistryAccountData
+> {
+  return mapSerializer<
+    OAppRegistryAccountDataArgs,
+    any,
+    OAppRegistryAccountData
+  >(
+    struct<OAppRegistryAccountData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['delegate', publicKeySerializer()],
+        ['bump', u8()],
+      ],
+      { description: 'OAppRegistryAccountData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([6, 152, 199, 30, 217, 50, 69, 149]),
+    })
+  ) as Serializer<OAppRegistryAccountDataArgs, OAppRegistryAccountData>;
+}
+
+export function deserializeOAppRegistry(rawAccount: RpcAccount): OAppRegistry {
+  return deserializeAccount(rawAccount, getOAppRegistryAccountDataSerializer());
+}
+
+export async function fetchOAppRegistry(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<OAppRegistry> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  assertAccountExists(maybeAccount, 'OAppRegistry');
+  return deserializeOAppRegistry(maybeAccount);
+}
+
+export async function safeFetchOAppRegistry(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<OAppRegistry | null> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  return maybeAccount.exists ? deserializeOAppRegistry(maybeAccount) : null;
+}
+
+export async function fetchAllOAppRegistry(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<OAppRegistry[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts.map((maybeAccount) => {
+    assertAccountExists(maybeAccount, 'OAppRegistry');
+    return deserializeOAppRegistry(maybeAccount);
+  });
+}
+
+export async function safeFetchAllOAppRegistry(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<OAppRegistry[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts
+    .filter((maybeAccount) => maybeAccount.exists)
+    .map((maybeAccount) => deserializeOAppRegistry(maybeAccount as RpcAccount));
+}
+
+export function getOAppRegistryGpaBuilder(
+  context: Pick<Context, 'rpc' | 'programs'>
+) {
+  const programId = context.programs.getPublicKey(
+    'endpoint',
+    '76y77prsiCMvXMjuoZ5VRrhG5qYBrUMYTE5WgHqgjEn6'
+  );
+  return gpaBuilder(context, programId)
+    .registerFields<{
+      discriminator: Uint8Array;
+      delegate: PublicKey;
+      bump: number;
+    }>({
+      discriminator: [0, bytes({ size: 8 })],
+      delegate: [8, publicKeySerializer()],
+      bump: [40, u8()],
+    })
+    .deserializeUsing<OAppRegistry>((account) =>
+      deserializeOAppRegistry(account)
+    )
+    .whereField(
+      'discriminator',
+      new Uint8Array([6, 152, 199, 30, 217, 50, 69, 149])
+    );
+}
+
+export function getOAppRegistrySize(): number {
+  return 41;
+}

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

@@ -0,0 +1,144 @@
+/**
+ * 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,
+  u8,
+} from '@metaplex-foundation/umi/serializers';
+
+export type PayloadHash = Account<PayloadHashAccountData>;
+
+export type PayloadHashAccountData = {
+  discriminator: Uint8Array;
+  hash: Uint8Array;
+  bump: number;
+};
+
+export type PayloadHashAccountDataArgs = { hash: Uint8Array; bump: number };
+
+export function getPayloadHashAccountDataSerializer(): Serializer<
+  PayloadHashAccountDataArgs,
+  PayloadHashAccountData
+> {
+  return mapSerializer<PayloadHashAccountDataArgs, any, PayloadHashAccountData>(
+    struct<PayloadHashAccountData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['hash', bytes({ size: 32 })],
+        ['bump', u8()],
+      ],
+      { description: 'PayloadHashAccountData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([96, 28, 106, 145, 103, 32, 186, 70]),
+    })
+  ) as Serializer<PayloadHashAccountDataArgs, PayloadHashAccountData>;
+}
+
+export function deserializePayloadHash(rawAccount: RpcAccount): PayloadHash {
+  return deserializeAccount(rawAccount, getPayloadHashAccountDataSerializer());
+}
+
+export async function fetchPayloadHash(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<PayloadHash> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  assertAccountExists(maybeAccount, 'PayloadHash');
+  return deserializePayloadHash(maybeAccount);
+}
+
+export async function safeFetchPayloadHash(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<PayloadHash | null> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  return maybeAccount.exists ? deserializePayloadHash(maybeAccount) : null;
+}
+
+export async function fetchAllPayloadHash(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<PayloadHash[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts.map((maybeAccount) => {
+    assertAccountExists(maybeAccount, 'PayloadHash');
+    return deserializePayloadHash(maybeAccount);
+  });
+}
+
+export async function safeFetchAllPayloadHash(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<PayloadHash[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts
+    .filter((maybeAccount) => maybeAccount.exists)
+    .map((maybeAccount) => deserializePayloadHash(maybeAccount as RpcAccount));
+}
+
+export function getPayloadHashGpaBuilder(
+  context: Pick<Context, 'rpc' | 'programs'>
+) {
+  const programId = context.programs.getPublicKey(
+    'endpoint',
+    '76y77prsiCMvXMjuoZ5VRrhG5qYBrUMYTE5WgHqgjEn6'
+  );
+  return gpaBuilder(context, programId)
+    .registerFields<{
+      discriminator: Uint8Array;
+      hash: Uint8Array;
+      bump: number;
+    }>({
+      discriminator: [0, bytes({ size: 8 })],
+      hash: [8, bytes({ size: 32 })],
+      bump: [40, u8()],
+    })
+    .deserializeUsing<PayloadHash>((account) => deserializePayloadHash(account))
+    .whereField(
+      'discriminator',
+      new Uint8Array([96, 28, 106, 145, 103, 32, 186, 70])
+    );
+}
+
+export function getPayloadHashSize(): number {
+  return 41;
+}