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

package/src/generated/kinobi/simple_messagelib/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/kinobi/simple_messagelib/types/index.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 './messagingFee';
+export * from './packet';
+export * from './version';

package/src/generated/kinobi/simple_messagelib/types/messagingFee.ts

@@ -0,0 +1,29 @@
+/**
+ * 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, struct, u64 } from '@metaplex-foundation/umi/serializers';
+
+export type MessagingFee = { nativeFee: bigint; lzTokenFee: bigint };
+
+export type MessagingFeeArgs = {
+  nativeFee: number | bigint;
+  lzTokenFee: number | bigint;
+};
+
+export function getMessagingFeeSerializer(): Serializer<
+  MessagingFeeArgs,
+  MessagingFee
+> {
+  return struct<MessagingFee>(
+    [
+      ['nativeFee', u64()],
+      ['lzTokenFee', u64()],
+    ],
+    { description: 'MessagingFee' }
+  ) as Serializer<MessagingFeeArgs, MessagingFee>;
+}

package/src/generated/kinobi/simple_messagelib/types/packet.ts

@@ -0,0 +1,52 @@
+/**
+ * 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,
+  bytes,
+  publicKey as publicKeySerializer,
+  struct,
+  u32,
+  u64,
+} from '@metaplex-foundation/umi/serializers';
+
+export type Packet = {
+  nonce: bigint;
+  srcEid: number;
+  sender: PublicKey;
+  dstEid: number;
+  receiver: Uint8Array;
+  guid: Uint8Array;
+  message: Uint8Array;
+};
+
+export type PacketArgs = {
+  nonce: number | bigint;
+  srcEid: number;
+  sender: PublicKey;
+  dstEid: number;
+  receiver: Uint8Array;
+  guid: Uint8Array;
+  message: Uint8Array;
+};
+
+export function getPacketSerializer(): Serializer<PacketArgs, Packet> {
+  return struct<Packet>(
+    [
+      ['nonce', u64()],
+      ['srcEid', u32()],
+      ['sender', publicKeySerializer()],
+      ['dstEid', u32()],
+      ['receiver', bytes({ size: 32 })],
+      ['guid', bytes({ size: 32 })],
+      ['message', bytes({ size: u32() })],
+    ],
+    { description: 'Packet' }
+  ) as Serializer<PacketArgs, Packet>;
+}

package/src/generated/kinobi/simple_messagelib/types/version.ts

@@ -0,0 +1,33 @@
+/**
+ * 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,
+  struct,
+  u64,
+  u8,
+} from '@metaplex-foundation/umi/serializers';
+
+export type Version = { major: bigint; minor: number; endpointVersion: number };
+
+export type VersionArgs = {
+  major: number | bigint;
+  minor: number;
+  endpointVersion: number;
+};
+
+export function getVersionSerializer(): Serializer<VersionArgs, Version> {
+  return struct<Version>(
+    [
+      ['major', u64()],
+      ['minor', u8()],
+      ['endpointVersion', u8()],
+    ],
+    { description: 'Version' }
+  ) as Serializer<VersionArgs, Version>;
+}

package/src/generated/kinobi/uln/accounts/confirmations.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 {
+  Account,
+  Context,
+  Option,
+  OptionOrNullable,
+  Pda,
+  PublicKey,
+  RpcAccount,
+  RpcGetAccountOptions,
+  RpcGetAccountsOptions,
+  assertAccountExists,
+  deserializeAccount,
+  gpaBuilder,
+  publicKey as toPublicKey,
+} from '@metaplex-foundation/umi';
+import {
+  Serializer,
+  bytes,
+  mapSerializer,
+  option,
+  struct,
+  u64,
+  u8,
+} from '@metaplex-foundation/umi/serializers';
+
+export type Confirmations = Account<ConfirmationsAccountData>;
+
+export type ConfirmationsAccountData = {
+  discriminator: Uint8Array;
+  value: Option<bigint>;
+  bump: number;
+};
+
+export type ConfirmationsAccountDataArgs = {
+  value: OptionOrNullable<number | bigint>;
+  bump: number;
+};
+
+export function getConfirmationsAccountDataSerializer(): Serializer<
+  ConfirmationsAccountDataArgs,
+  ConfirmationsAccountData
+> {
+  return mapSerializer<
+    ConfirmationsAccountDataArgs,
+    any,
+    ConfirmationsAccountData
+  >(
+    struct<ConfirmationsAccountData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['value', option(u64())],
+        ['bump', u8()],
+      ],
+      { description: 'ConfirmationsAccountData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([206, 57, 50, 8, 124, 133, 138, 112]),
+    })
+  ) as Serializer<ConfirmationsAccountDataArgs, ConfirmationsAccountData>;
+}
+
+export function deserializeConfirmations(
+  rawAccount: RpcAccount
+): Confirmations {
+  return deserializeAccount(
+    rawAccount,
+    getConfirmationsAccountDataSerializer()
+  );
+}
+
+export async function fetchConfirmations(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<Confirmations> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  assertAccountExists(maybeAccount, 'Confirmations');
+  return deserializeConfirmations(maybeAccount);
+}
+
+export async function safeFetchConfirmations(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<Confirmations | null> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  return maybeAccount.exists ? deserializeConfirmations(maybeAccount) : null;
+}
+
+export async function fetchAllConfirmations(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<Confirmations[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts.map((maybeAccount) => {
+    assertAccountExists(maybeAccount, 'Confirmations');
+    return deserializeConfirmations(maybeAccount);
+  });
+}
+
+export async function safeFetchAllConfirmations(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<Confirmations[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts
+    .filter((maybeAccount) => maybeAccount.exists)
+    .map((maybeAccount) =>
+      deserializeConfirmations(maybeAccount as RpcAccount)
+    );
+}
+
+export function getConfirmationsGpaBuilder(
+  context: Pick<Context, 'rpc' | 'programs'>
+) {
+  const programId = context.programs.getPublicKey(
+    'uln',
+    '7a4WjyR8VZ7yZz5XJAKm39BUGn5iT9CKcv2pmG9tdXVH'
+  );
+  return gpaBuilder(context, programId)
+    .registerFields<{
+      discriminator: Uint8Array;
+      value: OptionOrNullable<number | bigint>;
+      bump: number;
+    }>({
+      discriminator: [0, bytes({ size: 8 })],
+      value: [8, option(u64())],
+      bump: [null, u8()],
+    })
+    .deserializeUsing<Confirmations>((account) =>
+      deserializeConfirmations(account)
+    )
+    .whereField(
+      'discriminator',
+      new Uint8Array([206, 57, 50, 8, 124, 133, 138, 112])
+    );
+}

package/src/generated/kinobi/uln/accounts/index.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 './confirmations';
+export * from './receiveConfig';
+export * from './sendConfig';
+export * from './ulnSettings';

package/src/generated/kinobi/uln/accounts/receiveConfig.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,
+  u8,
+} from '@metaplex-foundation/umi/serializers';
+import { UlnConfig, UlnConfigArgs, getUlnConfigSerializer } from '../types';
+
+export type ReceiveConfig = Account<ReceiveConfigAccountData>;
+
+export type ReceiveConfigAccountData = {
+  discriminator: Uint8Array;
+  bump: number;
+  uln: UlnConfig;
+};
+
+export type ReceiveConfigAccountDataArgs = { bump: number; uln: UlnConfigArgs };
+
+export function getReceiveConfigAccountDataSerializer(): Serializer<
+  ReceiveConfigAccountDataArgs,
+  ReceiveConfigAccountData
+> {
+  return mapSerializer<
+    ReceiveConfigAccountDataArgs,
+    any,
+    ReceiveConfigAccountData
+  >(
+    struct<ReceiveConfigAccountData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['bump', u8()],
+        ['uln', getUlnConfigSerializer()],
+      ],
+      { description: 'ReceiveConfigAccountData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([162, 159, 153, 188, 56, 65, 245, 58]),
+    })
+  ) as Serializer<ReceiveConfigAccountDataArgs, ReceiveConfigAccountData>;
+}
+
+export function deserializeReceiveConfig(
+  rawAccount: RpcAccount
+): ReceiveConfig {
+  return deserializeAccount(
+    rawAccount,
+    getReceiveConfigAccountDataSerializer()
+  );
+}
+
+export async function fetchReceiveConfig(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<ReceiveConfig> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  assertAccountExists(maybeAccount, 'ReceiveConfig');
+  return deserializeReceiveConfig(maybeAccount);
+}
+
+export async function safeFetchReceiveConfig(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<ReceiveConfig | null> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  return maybeAccount.exists ? deserializeReceiveConfig(maybeAccount) : null;
+}
+
+export async function fetchAllReceiveConfig(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<ReceiveConfig[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts.map((maybeAccount) => {
+    assertAccountExists(maybeAccount, 'ReceiveConfig');
+    return deserializeReceiveConfig(maybeAccount);
+  });
+}
+
+export async function safeFetchAllReceiveConfig(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<ReceiveConfig[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts
+    .filter((maybeAccount) => maybeAccount.exists)
+    .map((maybeAccount) =>
+      deserializeReceiveConfig(maybeAccount as RpcAccount)
+    );
+}
+
+export function getReceiveConfigGpaBuilder(
+  context: Pick<Context, 'rpc' | 'programs'>
+) {
+  const programId = context.programs.getPublicKey(
+    'uln',
+    '7a4WjyR8VZ7yZz5XJAKm39BUGn5iT9CKcv2pmG9tdXVH'
+  );
+  return gpaBuilder(context, programId)
+    .registerFields<{
+      discriminator: Uint8Array;
+      bump: number;
+      uln: UlnConfigArgs;
+    }>({
+      discriminator: [0, bytes({ size: 8 })],
+      bump: [8, u8()],
+      uln: [9, getUlnConfigSerializer()],
+    })
+    .deserializeUsing<ReceiveConfig>((account) =>
+      deserializeReceiveConfig(account)
+    )
+    .whereField(
+      'discriminator',
+      new Uint8Array([162, 159, 153, 188, 56, 65, 245, 58])
+    );
+}