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

package/src/generated/oft302/accounts/oFTStore.ts

@@ -0,0 +1,198 @@
+/**
+ * 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,
+  bool,
+  bytes,
+  mapSerializer,
+  option,
+  publicKey as publicKeySerializer,
+  struct,
+  u16,
+  u64,
+  u8,
+} from '@metaplex-foundation/umi/serializers';
+import { OFTType, OFTTypeArgs, getOFTTypeSerializer } from '../types';
+
+export type OFTStore = Account<OFTStoreAccountData>;
+
+export type OFTStoreAccountData = {
+  discriminator: Uint8Array;
+  oftType: OFTType;
+  ld2sdRate: bigint;
+  tokenMint: PublicKey;
+  tokenEscrow: PublicKey;
+  endpointProgram: PublicKey;
+  bump: number;
+  tvlLd: bigint;
+  admin: PublicKey;
+  defaultFeeBps: number;
+  paused: boolean;
+  pauser: Option<PublicKey>;
+  unpauser: Option<PublicKey>;
+};
+
+export type OFTStoreAccountDataArgs = {
+  oftType: OFTTypeArgs;
+  ld2sdRate: number | bigint;
+  tokenMint: PublicKey;
+  tokenEscrow: PublicKey;
+  endpointProgram: PublicKey;
+  bump: number;
+  tvlLd: number | bigint;
+  admin: PublicKey;
+  defaultFeeBps: number;
+  paused: boolean;
+  pauser: OptionOrNullable<PublicKey>;
+  unpauser: OptionOrNullable<PublicKey>;
+};
+
+export function getOFTStoreAccountDataSerializer(): Serializer<
+  OFTStoreAccountDataArgs,
+  OFTStoreAccountData
+> {
+  return mapSerializer<OFTStoreAccountDataArgs, any, OFTStoreAccountData>(
+    struct<OFTStoreAccountData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['oftType', getOFTTypeSerializer()],
+        ['ld2sdRate', u64()],
+        ['tokenMint', publicKeySerializer()],
+        ['tokenEscrow', publicKeySerializer()],
+        ['endpointProgram', publicKeySerializer()],
+        ['bump', u8()],
+        ['tvlLd', u64()],
+        ['admin', publicKeySerializer()],
+        ['defaultFeeBps', u16()],
+        ['paused', bool()],
+        ['pauser', option(publicKeySerializer())],
+        ['unpauser', option(publicKeySerializer())],
+      ],
+      { description: 'OFTStoreAccountData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([195, 215, 104, 134, 185, 195, 240, 114]),
+    })
+  ) as Serializer<OFTStoreAccountDataArgs, OFTStoreAccountData>;
+}
+
+export function deserializeOFTStore(rawAccount: RpcAccount): OFTStore {
+  return deserializeAccount(rawAccount, getOFTStoreAccountDataSerializer());
+}
+
+export async function fetchOFTStore(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<OFTStore> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  assertAccountExists(maybeAccount, 'OFTStore');
+  return deserializeOFTStore(maybeAccount);
+}
+
+export async function safeFetchOFTStore(
+  context: Pick<Context, 'rpc'>,
+  publicKey: PublicKey | Pda,
+  options?: RpcGetAccountOptions
+): Promise<OFTStore | null> {
+  const maybeAccount = await context.rpc.getAccount(
+    toPublicKey(publicKey, false),
+    options
+  );
+  return maybeAccount.exists ? deserializeOFTStore(maybeAccount) : null;
+}
+
+export async function fetchAllOFTStore(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<OFTStore[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts.map((maybeAccount) => {
+    assertAccountExists(maybeAccount, 'OFTStore');
+    return deserializeOFTStore(maybeAccount);
+  });
+}
+
+export async function safeFetchAllOFTStore(
+  context: Pick<Context, 'rpc'>,
+  publicKeys: Array<PublicKey | Pda>,
+  options?: RpcGetAccountsOptions
+): Promise<OFTStore[]> {
+  const maybeAccounts = await context.rpc.getAccounts(
+    publicKeys.map((key) => toPublicKey(key, false)),
+    options
+  );
+  return maybeAccounts
+    .filter((maybeAccount) => maybeAccount.exists)
+    .map((maybeAccount) => deserializeOFTStore(maybeAccount as RpcAccount));
+}
+
+export function getOFTStoreGpaBuilder(
+  context: Pick<Context, 'rpc' | 'programs'>
+) {
+  const programId = context.programs.getPublicKey('oft', '');
+  return gpaBuilder(context, programId)
+    .registerFields<{
+      discriminator: Uint8Array;
+      oftType: OFTTypeArgs;
+      ld2sdRate: number | bigint;
+      tokenMint: PublicKey;
+      tokenEscrow: PublicKey;
+      endpointProgram: PublicKey;
+      bump: number;
+      tvlLd: number | bigint;
+      admin: PublicKey;
+      defaultFeeBps: number;
+      paused: boolean;
+      pauser: OptionOrNullable<PublicKey>;
+      unpauser: OptionOrNullable<PublicKey>;
+    }>({
+      discriminator: [0, bytes({ size: 8 })],
+      oftType: [8, getOFTTypeSerializer()],
+      ld2sdRate: [9, u64()],
+      tokenMint: [17, publicKeySerializer()],
+      tokenEscrow: [49, publicKeySerializer()],
+      endpointProgram: [81, publicKeySerializer()],
+      bump: [113, u8()],
+      tvlLd: [114, u64()],
+      admin: [122, publicKeySerializer()],
+      defaultFeeBps: [154, u16()],
+      paused: [156, bool()],
+      pauser: [157, option(publicKeySerializer())],
+      unpauser: [null, option(publicKeySerializer())],
+    })
+    .deserializeUsing<OFTStore>((account) => deserializeOFTStore(account))
+    .whereField(
+      'discriminator',
+      new Uint8Array([195, 215, 104, 134, 185, 195, 240, 114])
+    );
+}

package/src/generated/{accounts → oft302/accounts}/peerConfig.ts

@@ -17,7 +17,6 @@ import {
   RpcGetAccountOptions,
   RpcGetAccountsOptions,
   assertAccountExists,
-  defaultPublicKey,
   deserializeAccount,
   gpaBuilder,
   publicKey as toPublicKey,
@@ -146,7 +145,7 @@ export async function safeFetchAllPeerConfig(
 export function getPeerConfigGpaBuilder(
   context: Pick<Context, 'rpc' | 'programs'>
 ) {
-  const programId = context.programs.getPublicKey('oft', defaultPublicKey(), 'custom')
+  const programId = context.programs.getPublicKey('oft', '');
   return gpaBuilder(context, programId)
     .registerFields<{
       discriminator: Uint8Array;

package/src/generated/oft302/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 './oft';

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

@@ -0,0 +1,159 @@
+/**
+ * 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();
+
+/** Unauthorized */
+export class UnauthorizedError extends ProgramError {
+  override readonly name: string = 'Unauthorized';
+
+  readonly code: number = 0x1770; // 6000
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1770, UnauthorizedError);
+nameToErrorMap.set('Unauthorized', UnauthorizedError);
+
+/** InvalidSender */
+export class InvalidSenderError extends ProgramError {
+  override readonly name: string = 'InvalidSender';
+
+  readonly code: number = 0x1771; // 6001
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1771, InvalidSenderError);
+nameToErrorMap.set('InvalidSender', InvalidSenderError);
+
+/** InvalidDecimals */
+export class InvalidDecimalsError extends ProgramError {
+  override readonly name: string = 'InvalidDecimals';
+
+  readonly code: number = 0x1772; // 6002
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1772, InvalidDecimalsError);
+nameToErrorMap.set('InvalidDecimals', InvalidDecimalsError);
+
+/** SlippageExceeded */
+export class SlippageExceededError extends ProgramError {
+  override readonly name: string = 'SlippageExceeded';
+
+  readonly code: number = 0x1773; // 6003
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1773, SlippageExceededError);
+nameToErrorMap.set('SlippageExceeded', SlippageExceededError);
+
+/** InvalidTokenDest */
+export class InvalidTokenDestError extends ProgramError {
+  override readonly name: string = 'InvalidTokenDest';
+
+  readonly code: number = 0x1774; // 6004
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1774, InvalidTokenDestError);
+nameToErrorMap.set('InvalidTokenDest', InvalidTokenDestError);
+
+/** RateLimitExceeded */
+export class RateLimitExceededError extends ProgramError {
+  override readonly name: string = 'RateLimitExceeded';
+
+  readonly code: number = 0x1775; // 6005
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1775, RateLimitExceededError);
+nameToErrorMap.set('RateLimitExceeded', RateLimitExceededError);
+
+/** InvalidFee */
+export class InvalidFeeError extends ProgramError {
+  override readonly name: string = 'InvalidFee';
+
+  readonly code: number = 0x1776; // 6006
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1776, InvalidFeeError);
+nameToErrorMap.set('InvalidFee', InvalidFeeError);
+
+/** InvalidMintAuthority */
+export class InvalidMintAuthorityError extends ProgramError {
+  override readonly name: string = 'InvalidMintAuthority';
+
+  readonly code: number = 0x1777; // 6007
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1777, InvalidMintAuthorityError);
+nameToErrorMap.set('InvalidMintAuthority', InvalidMintAuthorityError);
+
+/** Paused */
+export class PausedError extends ProgramError {
+  override readonly name: string = 'Paused';
+
+  readonly code: number = 0x1778; // 6008
+
+  constructor(program: Program, cause?: Error) {
+    super('', program, cause);
+  }
+}
+codeToErrorMap.set(0x1778, PausedError);
+nameToErrorMap.set('Paused', PausedError);
+
+/**
+ * Attempts to resolve a custom program error from the provided error code.
+ * @category Errors
+ */
+export function getOftErrorFromCode(
+  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 getOftErrorFromName(
+  name: string,
+  program: Program,
+  cause?: Error
+): ProgramError | null {
+  const constructor = nameToErrorMap.get(name);
+  return constructor ? new constructor(program, cause) : null;
+}

package/src/generated/oft302/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/oft302/instructions/initOft.ts

@@ -0,0 +1,179 @@
+/**
+ * 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,
+  Option,
+  OptionOrNullable,
+  Pda,
+  PublicKey,
+  Signer,
+  TransactionBuilder,
+  transactionBuilder,
+} from '@metaplex-foundation/umi';
+import {
+  Serializer,
+  bytes,
+  mapSerializer,
+  option,
+  publicKey as publicKeySerializer,
+  struct,
+  u8,
+} from '@metaplex-foundation/umi/serializers';
+import {
+  ResolvedAccount,
+  ResolvedAccountsWithIndices,
+  getAccountMetasAndSigners,
+} from '../shared';
+import { OFTType, OFTTypeArgs, getOFTTypeSerializer } from '../types';
+
+// Accounts.
+export type InitOftInstructionAccounts = {
+  payer?: Signer;
+  oftStore: PublicKey | Pda;
+  lzReceiveTypesAccounts: PublicKey | Pda;
+  tokenMint: PublicKey | Pda;
+  tokenEscrow: Signer;
+  tokenProgram?: PublicKey | Pda;
+  systemProgram?: PublicKey | Pda;
+};
+
+// Data.
+export type InitOftInstructionData = {
+  discriminator: Uint8Array;
+  oftType: OFTType;
+  admin: PublicKey;
+  sharedDecimals: number;
+  endpointProgram: Option<PublicKey>;
+};
+
+export type InitOftInstructionDataArgs = {
+  oftType: OFTTypeArgs;
+  admin: PublicKey;
+  sharedDecimals: number;
+  endpointProgram: OptionOrNullable<PublicKey>;
+};
+
+export function getInitOftInstructionDataSerializer(): Serializer<
+  InitOftInstructionDataArgs,
+  InitOftInstructionData
+> {
+  return mapSerializer<InitOftInstructionDataArgs, any, InitOftInstructionData>(
+    struct<InitOftInstructionData>(
+      [
+        ['discriminator', bytes({ size: 8 })],
+        ['oftType', getOFTTypeSerializer()],
+        ['admin', publicKeySerializer()],
+        ['sharedDecimals', u8()],
+        ['endpointProgram', option(publicKeySerializer())],
+      ],
+      { description: 'InitOftInstructionData' }
+    ),
+    (value) => ({
+      ...value,
+      discriminator: new Uint8Array([182, 169, 147, 16, 201, 45, 76, 23]),
+    })
+  ) as Serializer<InitOftInstructionDataArgs, InitOftInstructionData>;
+}
+
+// Args.
+export type InitOftInstructionArgs = InitOftInstructionDataArgs;
+
+// Instruction.
+export function initOft(
+  context: Pick<Context, 'payer' | 'programs'>,
+  input: InitOftInstructionAccounts & InitOftInstructionArgs
+): TransactionBuilder {
+  // Program ID.
+  const programId = context.programs.getPublicKey('oft', '');
+
+  // Accounts.
+  const resolvedAccounts = {
+    payer: {
+      index: 0,
+      isWritable: true as boolean,
+      value: input.payer ?? null,
+    },
+    oftStore: {
+      index: 1,
+      isWritable: true as boolean,
+      value: input.oftStore ?? null,
+    },
+    lzReceiveTypesAccounts: {
+      index: 2,
+      isWritable: true as boolean,
+      value: input.lzReceiveTypesAccounts ?? null,
+    },
+    tokenMint: {
+      index: 3,
+      isWritable: false as boolean,
+      value: input.tokenMint ?? null,
+    },
+    tokenEscrow: {
+      index: 4,
+      isWritable: true as boolean,
+      value: input.tokenEscrow ?? null,
+    },
+    tokenProgram: {
+      index: 5,
+      isWritable: false as boolean,
+      value: input.tokenProgram ?? null,
+    },
+    systemProgram: {
+      index: 6,
+      isWritable: false as boolean,
+      value: input.systemProgram ?? null,
+    },
+  } satisfies ResolvedAccountsWithIndices;
+
+  // Arguments.
+  const resolvedArgs: InitOftInstructionArgs = { ...input };
+
+  // Default values.
+  if (!resolvedAccounts.payer.value) {
+    resolvedAccounts.payer.value = context.payer;
+  }
+  if (!resolvedAccounts.tokenProgram.value) {
+    resolvedAccounts.tokenProgram.value = context.programs.getPublicKey(
+      'splToken',
+      'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'
+    );
+    resolvedAccounts.tokenProgram.isWritable = false;
+  }
+  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 = getInitOftInstructionDataSerializer().serialize(
+    resolvedArgs as InitOftInstructionDataArgs
+  );
+
+  // Bytes Created On Chain.
+  const bytesCreatedOnChain = 0;
+
+  return transactionBuilder([
+    { instruction: { keys, programId, data }, signers, bytesCreatedOnChain },
+  ]);
+}