@shogun-sdk/intents-sdk 1.0.1 → 1.1.0

package/src/core/solana/generated/single-chain/instructions/setAuctioneerPubKey.ts

@@ -0,0 +1,241 @@
+/**
+ * This code was AUTOGENERATED using the codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import { getAddressDecoder, getAddressEncoder, getProgramDerivedAddress, type Address } from '@solana/kit';
+import {
+  combineCodec,
+  fixDecoderSize,
+  fixEncoderSize,
+  getBytesDecoder,
+  getBytesEncoder,
+  getStructDecoder,
+  getStructEncoder,
+  transformEncoder,
+  type Codec,
+  type Decoder,
+  type Encoder,
+  type ReadonlyUint8Array,
+} from '@solana/kit';
+import {
+  type IAccountMeta,
+  type IInstruction,
+  type IInstructionWithAccounts,
+  type IInstructionWithData,
+  type ReadonlyAccount,
+  type WritableAccount,
+  type WritableSignerAccount,
+} from '@solana/kit';
+import { type IAccountSignerMeta, type TransactionSigner } from '@solana/kit';
+import { SINGLE_CHAIN_GUARD_PROGRAM_ADDRESS } from '../programs/index.js';
+import { getAccountMetaFactory, type ResolvedAccount } from '../shared/index.js';
+
+export const SET_AUCTIONEER_PUB_KEY_DISCRIMINATOR = new Uint8Array([153, 39, 10, 108, 220, 0, 84, 47]);
+
+export function getSetAuctioneerPubKeyDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(SET_AUCTIONEER_PUB_KEY_DISCRIMINATOR);
+}
+
+export type SetAuctioneerPubKeyInstruction<
+  TProgram extends string = typeof SINGLE_CHAIN_GUARD_PROGRAM_ADDRESS,
+  TAccountAdmin extends string | IAccountMeta<string> = string,
+  TAccountAdminSingleton extends string | IAccountMeta<string> = string,
+  TAccountGuard extends string | IAccountMeta<string> = string,
+  TRemainingAccounts extends readonly IAccountMeta<string>[] = [],
+> = IInstruction<TProgram> &
+  IInstructionWithData<Uint8Array> &
+  IInstructionWithAccounts<
+    [
+      TAccountAdmin extends string
+        ? WritableSignerAccount<TAccountAdmin> & IAccountSignerMeta<TAccountAdmin>
+        : TAccountAdmin,
+      TAccountAdminSingleton extends string ? ReadonlyAccount<TAccountAdminSingleton> : TAccountAdminSingleton,
+      TAccountGuard extends string ? WritableAccount<TAccountGuard> : TAccountGuard,
+      ...TRemainingAccounts,
+    ]
+  >;
+
+export type SetAuctioneerPubKeyInstructionData = {
+  discriminator: ReadonlyUint8Array;
+  auctioneerPubKey: Address;
+};
+
+export type SetAuctioneerPubKeyInstructionDataArgs = {
+  auctioneerPubKey: Address;
+};
+
+export function getSetAuctioneerPubKeyInstructionDataEncoder(): Encoder<SetAuctioneerPubKeyInstructionDataArgs> {
+  return transformEncoder(
+    getStructEncoder([
+      ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
+      ['auctioneerPubKey', getAddressEncoder()],
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: SET_AUCTIONEER_PUB_KEY_DISCRIMINATOR,
+    }),
+  );
+}
+
+export function getSetAuctioneerPubKeyInstructionDataDecoder(): Decoder<SetAuctioneerPubKeyInstructionData> {
+  return getStructDecoder([
+    ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
+    ['auctioneerPubKey', getAddressDecoder()],
+  ]);
+}
+
+export function getSetAuctioneerPubKeyInstructionDataCodec(): Codec<
+  SetAuctioneerPubKeyInstructionDataArgs,
+  SetAuctioneerPubKeyInstructionData
+> {
+  return combineCodec(getSetAuctioneerPubKeyInstructionDataEncoder(), getSetAuctioneerPubKeyInstructionDataDecoder());
+}
+
+export type SetAuctioneerPubKeyAsyncInput<
+  TAccountAdmin extends string = string,
+  TAccountAdminSingleton extends string = string,
+  TAccountGuard extends string = string,
+> = {
+  /** Admin signer */
+  admin: TransactionSigner<TAccountAdmin>;
+  /** Admin singleton account that grants access to admin functions */
+  adminSingleton?: Address<TAccountAdminSingleton>;
+  /** Guard account */
+  guard: Address<TAccountGuard>;
+  auctioneerPubKey: SetAuctioneerPubKeyInstructionDataArgs['auctioneerPubKey'];
+};
+
+export async function getSetAuctioneerPubKeyInstructionAsync<
+  TAccountAdmin extends string,
+  TAccountAdminSingleton extends string,
+  TAccountGuard extends string,
+  TProgramAddress extends Address = typeof SINGLE_CHAIN_GUARD_PROGRAM_ADDRESS,
+>(
+  input: SetAuctioneerPubKeyAsyncInput<TAccountAdmin, TAccountAdminSingleton, TAccountGuard>,
+  config?: { programAddress?: TProgramAddress },
+): Promise<SetAuctioneerPubKeyInstruction<TProgramAddress, TAccountAdmin, TAccountAdminSingleton, TAccountGuard>> {
+  // Program address.
+  const programAddress = config?.programAddress ?? SINGLE_CHAIN_GUARD_PROGRAM_ADDRESS;
+
+  // Original accounts.
+  const originalAccounts = {
+    admin: { value: input.admin ?? null, isWritable: true },
+    adminSingleton: { value: input.adminSingleton ?? null, isWritable: false },
+    guard: { value: input.guard ?? null, isWritable: true },
+  };
+  const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedAccount>;
+
+  // Original args.
+  const args = { ...input };
+
+  // Resolve default values.
+  if (!accounts.adminSingleton.value) {
+    accounts.adminSingleton.value = await getProgramDerivedAddress({
+      programAddress,
+      seeds: [getBytesEncoder().encode(new Uint8Array([97, 100, 109, 105, 110]))],
+    });
+  }
+
+  const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+  const instruction = {
+    accounts: [getAccountMeta(accounts.admin), getAccountMeta(accounts.adminSingleton), getAccountMeta(accounts.guard)],
+    programAddress,
+    data: getSetAuctioneerPubKeyInstructionDataEncoder().encode(args as SetAuctioneerPubKeyInstructionDataArgs),
+  } as SetAuctioneerPubKeyInstruction<TProgramAddress, TAccountAdmin, TAccountAdminSingleton, TAccountGuard>;
+
+  return instruction;
+}
+
+export type SetAuctioneerPubKeyInput<
+  TAccountAdmin extends string = string,
+  TAccountAdminSingleton extends string = string,
+  TAccountGuard extends string = string,
+> = {
+  /** Admin signer */
+  admin: TransactionSigner<TAccountAdmin>;
+  /** Admin singleton account that grants access to admin functions */
+  adminSingleton: Address<TAccountAdminSingleton>;
+  /** Guard account */
+  guard: Address<TAccountGuard>;
+  auctioneerPubKey: SetAuctioneerPubKeyInstructionDataArgs['auctioneerPubKey'];
+};
+
+export function getSetAuctioneerPubKeyInstruction<
+  TAccountAdmin extends string,
+  TAccountAdminSingleton extends string,
+  TAccountGuard extends string,
+  TProgramAddress extends Address = typeof SINGLE_CHAIN_GUARD_PROGRAM_ADDRESS,
+>(
+  input: SetAuctioneerPubKeyInput<TAccountAdmin, TAccountAdminSingleton, TAccountGuard>,
+  config?: { programAddress?: TProgramAddress },
+): SetAuctioneerPubKeyInstruction<TProgramAddress, TAccountAdmin, TAccountAdminSingleton, TAccountGuard> {
+  // Program address.
+  const programAddress = config?.programAddress ?? SINGLE_CHAIN_GUARD_PROGRAM_ADDRESS;
+
+  // Original accounts.
+  const originalAccounts = {
+    admin: { value: input.admin ?? null, isWritable: true },
+    adminSingleton: { value: input.adminSingleton ?? null, isWritable: false },
+    guard: { value: input.guard ?? null, isWritable: true },
+  };
+  const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedAccount>;
+
+  // Original args.
+  const args = { ...input };
+
+  const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+  const instruction = {
+    accounts: [getAccountMeta(accounts.admin), getAccountMeta(accounts.adminSingleton), getAccountMeta(accounts.guard)],
+    programAddress,
+    data: getSetAuctioneerPubKeyInstructionDataEncoder().encode(args as SetAuctioneerPubKeyInstructionDataArgs),
+  } as SetAuctioneerPubKeyInstruction<TProgramAddress, TAccountAdmin, TAccountAdminSingleton, TAccountGuard>;
+
+  return instruction;
+}
+
+export type ParsedSetAuctioneerPubKeyInstruction<
+  TProgram extends string = typeof SINGLE_CHAIN_GUARD_PROGRAM_ADDRESS,
+  TAccountMetas extends readonly IAccountMeta[] = readonly IAccountMeta[],
+> = {
+  programAddress: Address<TProgram>;
+  accounts: {
+    /** Admin signer */
+    admin: TAccountMetas[0];
+    /** Admin singleton account that grants access to admin functions */
+    adminSingleton: TAccountMetas[1];
+    /** Guard account */
+    guard: TAccountMetas[2];
+  };
+  data: SetAuctioneerPubKeyInstructionData;
+};
+
+export function parseSetAuctioneerPubKeyInstruction<
+  TProgram extends string,
+  TAccountMetas extends readonly IAccountMeta[],
+>(
+  instruction: IInstruction<TProgram> & IInstructionWithAccounts<TAccountMetas> & IInstructionWithData<Uint8Array>,
+): ParsedSetAuctioneerPubKeyInstruction<TProgram, TAccountMetas> {
+  if (instruction.accounts.length < 3) {
+    // TODO: Coded error.
+    throw new Error('Not enough accounts');
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts![accountIndex]!;
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      admin: getNextAccount(),
+      adminSingleton: getNextAccount(),
+      guard: getNextAccount(),
+    },
+    data: getSetAuctioneerPubKeyInstructionDataDecoder().decode(instruction.data),
+  };
+}

package/src/core/solana/generated/single-chain/programs/index.ts

@@ -0,0 +1,9 @@
+/**
+ * This code was AUTOGENERATED using the codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+export * from './singleChainGuard.js';

package/src/core/solana/generated/single-chain/programs/singleChainGuard.ts

@@ -0,0 +1,247 @@
+/**
+ * This code was AUTOGENERATED using the codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import { type Address } from '@solana/kit';
+import { containsBytes, fixEncoderSize, getBytesEncoder, type ReadonlyUint8Array } from '@solana/kit';
+import {
+  type ParsedAcceptAdminInstruction,
+  type ParsedCancelDcaOrderInstruction,
+  type ParsedCancelLimitOrderInstruction,
+  type ParsedCollectProtocolFeesInstruction,
+  type ParsedCreateDcaOrderInstruction,
+  type ParsedCreateGuardInstruction,
+  type ParsedCreateLimitOrderInstruction,
+  type ParsedFulfillDcaOrderIntervalInstruction,
+  type ParsedFulfillLimitOrderInstruction,
+  type ParsedInitializeInstruction,
+  type ParsedSetAdminInstruction,
+  type ParsedSetAuctioneerPubKeyInstruction,
+} from '../instructions/index.js';
+
+export const SINGLE_CHAIN_GUARD_PROGRAM_ADDRESS =
+  'EaSKMioKTLtbFXVaMEmHjSdZDEoZHpSmQBu6NfsND87n' as Address<'EaSKMioKTLtbFXVaMEmHjSdZDEoZHpSmQBu6NfsND87n'>;
+
+export enum SingleChainGuardAccount {
+  AdminSingleton,
+  DcaOrder,
+  Guard,
+  LimitOrder,
+}
+
+export function identifySingleChainGuardAccount(
+  account: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
+): SingleChainGuardAccount {
+  const data = 'data' in account ? account.data : account;
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([179, 22, 254, 245, 204, 230, 222, 194])),
+      0,
+    )
+  ) {
+    return SingleChainGuardAccount.AdminSingleton;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([55, 1, 103, 253, 215, 66, 27, 57])),
+      0,
+    )
+  ) {
+    return SingleChainGuardAccount.DcaOrder;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([54, 187, 84, 137, 192, 15, 74, 248])),
+      0,
+    )
+  ) {
+    return SingleChainGuardAccount.Guard;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([137, 183, 212, 91, 115, 29, 141, 227])),
+      0,
+    )
+  ) {
+    return SingleChainGuardAccount.LimitOrder;
+  }
+  throw new Error('The provided account could not be identified as a singleChainGuard account.');
+}
+
+export enum SingleChainGuardInstruction {
+  AcceptAdmin,
+  CancelDcaOrder,
+  CancelLimitOrder,
+  CollectProtocolFees,
+  CreateDcaOrder,
+  CreateGuard,
+  CreateLimitOrder,
+  FulfillDcaOrderInterval,
+  FulfillLimitOrder,
+  Initialize,
+  SetAdmin,
+  SetAuctioneerPubKey,
+}
+
+export function identifySingleChainGuardInstruction(
+  instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
+): SingleChainGuardInstruction {
+  const data = 'data' in instruction ? instruction.data : instruction;
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([112, 42, 45, 90, 116, 181, 13, 170])),
+      0,
+    )
+  ) {
+    return SingleChainGuardInstruction.AcceptAdmin;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([60, 161, 130, 157, 181, 55, 218, 163])),
+      0,
+    )
+  ) {
+    return SingleChainGuardInstruction.CancelDcaOrder;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([132, 156, 132, 31, 67, 40, 232, 97])),
+      0,
+    )
+  ) {
+    return SingleChainGuardInstruction.CancelLimitOrder;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([22, 67, 23, 98, 150, 178, 70, 220])),
+      0,
+    )
+  ) {
+    return SingleChainGuardInstruction.CollectProtocolFees;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([95, 66, 166, 38, 170, 3, 150, 169])),
+      0,
+    )
+  ) {
+    return SingleChainGuardInstruction.CreateDcaOrder;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([251, 254, 17, 198, 219, 218, 154, 99])),
+      0,
+    )
+  ) {
+    return SingleChainGuardInstruction.CreateGuard;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([76, 161, 70, 122, 82, 20, 142, 75])),
+      0,
+    )
+  ) {
+    return SingleChainGuardInstruction.CreateLimitOrder;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([15, 118, 183, 60, 46, 43, 243, 244])),
+      0,
+    )
+  ) {
+    return SingleChainGuardInstruction.FulfillDcaOrderInterval;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([70, 1, 151, 197, 125, 110, 46, 244])),
+      0,
+    )
+  ) {
+    return SingleChainGuardInstruction.FulfillLimitOrder;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([175, 175, 109, 31, 13, 152, 155, 237])),
+      0,
+    )
+  ) {
+    return SingleChainGuardInstruction.Initialize;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([251, 163, 0, 52, 91, 194, 187, 92])),
+      0,
+    )
+  ) {
+    return SingleChainGuardInstruction.SetAdmin;
+  }
+  if (
+    containsBytes(
+      data,
+      fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([153, 39, 10, 108, 220, 0, 84, 47])),
+      0,
+    )
+  ) {
+    return SingleChainGuardInstruction.SetAuctioneerPubKey;
+  }
+  throw new Error('The provided instruction could not be identified as a singleChainGuard instruction.');
+}
+
+export type ParsedSingleChainGuardInstruction<
+  TProgram extends string = 'EaSKMioKTLtbFXVaMEmHjSdZDEoZHpSmQBu6NfsND87n',
+> =
+  | ({
+      instructionType: SingleChainGuardInstruction.AcceptAdmin;
+    } & ParsedAcceptAdminInstruction<TProgram>)
+  | ({
+      instructionType: SingleChainGuardInstruction.CancelDcaOrder;
+    } & ParsedCancelDcaOrderInstruction<TProgram>)
+  | ({
+      instructionType: SingleChainGuardInstruction.CancelLimitOrder;
+    } & ParsedCancelLimitOrderInstruction<TProgram>)
+  | ({
+      instructionType: SingleChainGuardInstruction.CollectProtocolFees;
+    } & ParsedCollectProtocolFeesInstruction<TProgram>)
+  | ({
+      instructionType: SingleChainGuardInstruction.CreateDcaOrder;
+    } & ParsedCreateDcaOrderInstruction<TProgram>)
+  | ({
+      instructionType: SingleChainGuardInstruction.CreateGuard;
+    } & ParsedCreateGuardInstruction<TProgram>)
+  | ({
+      instructionType: SingleChainGuardInstruction.CreateLimitOrder;
+    } & ParsedCreateLimitOrderInstruction<TProgram>)
+  | ({
+      instructionType: SingleChainGuardInstruction.FulfillDcaOrderInterval;
+    } & ParsedFulfillDcaOrderIntervalInstruction<TProgram>)
+  | ({
+      instructionType: SingleChainGuardInstruction.FulfillLimitOrder;
+    } & ParsedFulfillLimitOrderInstruction<TProgram>)
+  | ({
+      instructionType: SingleChainGuardInstruction.Initialize;
+    } & ParsedInitializeInstruction<TProgram>)
+  | ({
+      instructionType: SingleChainGuardInstruction.SetAdmin;
+    } & ParsedSetAdminInstruction<TProgram>)
+  | ({
+      instructionType: SingleChainGuardInstruction.SetAuctioneerPubKey;
+    } & ParsedSetAuctioneerPubKeyInstruction<TProgram>);

package/src/core/solana/generated/single-chain/shared/index.ts

@@ -0,0 +1,124 @@
+/**
+ * This code was AUTOGENERATED using the codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import { isProgramDerivedAddress, type Address, type ProgramDerivedAddress } from '@solana/kit';
+import { AccountRole, type IAccountMeta, upgradeRoleToSigner } from '@solana/kit';
+import {
+  isTransactionSigner as kitIsTransactionSigner,
+  type IAccountSignerMeta,
+  type TransactionSigner,
+} from '@solana/kit';
+
+/**
+ * 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 expectAddress<T extends string = string>(
+  value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined,
+): Address<T> {
+  if (!value) {
+    throw new Error('Expected a Address.');
+  }
+  if (typeof value === 'object' && 'address' in value) {
+    return value.address;
+  }
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return value as Address<T>;
+}
+
+/**
+ * Asserts that the given value is a PDA.
+ * @internal
+ */
+export function expectProgramDerivedAddress<T extends string = string>(
+  value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined,
+): ProgramDerivedAddress<T> {
+  if (!value || !Array.isArray(value) || !isProgramDerivedAddress(value)) {
+    throw new Error('Expected a ProgramDerivedAddress.');
+  }
+  return value;
+}
+
+/**
+ * Asserts that the given value is a TransactionSigner.
+ * @internal
+ */
+export function expectTransactionSigner<T extends string = string>(
+  value: Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null | undefined,
+): TransactionSigner<T> {
+  if (!value || !isTransactionSigner(value)) {
+    throw new Error('Expected a TransactionSigner.');
+  }
+  return value;
+}
+
+/**
+ * Defines an instruction account to resolve.
+ * @internal
+ */
+export type ResolvedAccount<
+  T extends string = string,
+  U extends Address<T> | ProgramDerivedAddress<T> | TransactionSigner<T> | null =
+    | Address<T>
+    | ProgramDerivedAddress<T>
+    | TransactionSigner<T>
+    | null,
+> = {
+  isWritable: boolean;
+  value: U;
+};
+
+/**
+ * Defines an instruction that stores additional bytes on-chain.
+ * @internal
+ */
+export type IInstructionWithByteDelta = {
+  byteDelta: number;
+};
+
+/**
+ * Get account metas and signers from resolved accounts.
+ * @internal
+ */
+export function getAccountMetaFactory(programAddress: Address, optionalAccountStrategy: 'omitted' | 'programId') {
+  return (account: ResolvedAccount): IAccountMeta | IAccountSignerMeta | undefined => {
+    if (!account.value) {
+      if (optionalAccountStrategy === 'omitted') return;
+      return Object.freeze({
+        address: programAddress,
+        role: AccountRole.READONLY,
+      });
+    }
+
+    const writableRole = account.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY;
+    return Object.freeze({
+      address: expectAddress(account.value),
+      role: isTransactionSigner(account.value) ? upgradeRoleToSigner(writableRole) : writableRole,
+      ...(isTransactionSigner(account.value) ? { signer: account.value } : {}),
+    });
+  };
+}
+
+export function isTransactionSigner<TAddress extends string = string>(
+  value: Address<TAddress> | ProgramDerivedAddress<TAddress> | TransactionSigner<TAddress>,
+): value is TransactionSigner<TAddress> {
+  return !!value && typeof value === 'object' && 'address' in value && kitIsTransactionSigner(value);
+}

package/src/core/solana/generated/single-chain/types/adminUpdateStarted.ts

@@ -0,0 +1,35 @@
+/**
+ * This code was AUTOGENERATED using the codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+  combineCodec,
+  getAddressDecoder,
+  getAddressEncoder,
+  getStructDecoder,
+  getStructEncoder,
+  type Address,
+  type Codec,
+  type Decoder,
+  type Encoder,
+} from '@solana/kit';
+
+export type AdminUpdateStarted = { newAdmin: Address };
+
+export type AdminUpdateStartedArgs = AdminUpdateStarted;
+
+export function getAdminUpdateStartedEncoder(): Encoder<AdminUpdateStartedArgs> {
+  return getStructEncoder([['newAdmin', getAddressEncoder()]]);
+}
+
+export function getAdminUpdateStartedDecoder(): Decoder<AdminUpdateStarted> {
+  return getStructDecoder([['newAdmin', getAddressDecoder()]]);
+}
+
+export function getAdminUpdateStartedCodec(): Codec<AdminUpdateStartedArgs, AdminUpdateStarted> {
+  return combineCodec(getAdminUpdateStartedEncoder(), getAdminUpdateStartedDecoder());
+}

package/src/core/solana/generated/single-chain/types/adminUpdated.ts

@@ -0,0 +1,35 @@
+/**
+ * This code was AUTOGENERATED using the codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import {
+  combineCodec,
+  getAddressDecoder,
+  getAddressEncoder,
+  getStructDecoder,
+  getStructEncoder,
+  type Address,
+  type Codec,
+  type Decoder,
+  type Encoder,
+} from '@solana/kit';
+
+export type AdminUpdated = { newAdmin: Address };
+
+export type AdminUpdatedArgs = AdminUpdated;
+
+export function getAdminUpdatedEncoder(): Encoder<AdminUpdatedArgs> {
+  return getStructEncoder([['newAdmin', getAddressEncoder()]]);
+}
+
+export function getAdminUpdatedDecoder(): Decoder<AdminUpdated> {
+  return getStructDecoder([['newAdmin', getAddressDecoder()]]);
+}
+
+export function getAdminUpdatedCodec(): Codec<AdminUpdatedArgs, AdminUpdated> {
+  return combineCodec(getAdminUpdatedEncoder(), getAdminUpdatedDecoder());
+}