@shunt-network/sdk 1.0.0

package/src/clients/typescript/src/generated/instructions/withdrawPayer.ts

@@ -0,0 +1,246 @@
+/**
+ * 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,
+  getStructDecoder,
+  getStructEncoder,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+  SolanaError,
+  transformEncoder,
+  type AccountMeta,
+  type AccountSignerMeta,
+  type Address,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
+  type Instruction,
+  type InstructionWithAccounts,
+  type InstructionWithData,
+  type ReadonlyAccount,
+  type ReadonlySignerAccount,
+  type ReadonlyUint8Array,
+  type TransactionSigner,
+  type WritableAccount,
+} from "@solana/kit";
+import {
+  getAccountMetaFactory,
+  type ResolvedInstructionAccount,
+} from "@solana/program-client-core";
+import { getU8Decoder, getU8Encoder } from "../../safe-codecs.js";
+import { PAYMENT_CHANNELS_PROGRAM_ADDRESS } from "../programs";
+
+export const WITHDRAW_PAYER_DISCRIMINATOR = 8;
+
+export function getWithdrawPayerDiscriminatorBytes(): ReadonlyUint8Array {
+  return getU8Encoder().encode(WITHDRAW_PAYER_DISCRIMINATOR);
+}
+
+export type WithdrawPayerInstruction<
+  TProgram extends string = typeof PAYMENT_CHANNELS_PROGRAM_ADDRESS,
+  TAccountPayer extends string | AccountMeta<string> = string,
+  TAccountChannel extends string | AccountMeta<string> = string,
+  TAccountChannelTokenAccount extends string | AccountMeta<string> = string,
+  TAccountPayerTokenAccount extends string | AccountMeta<string> = string,
+  TAccountMint extends string | AccountMeta<string> = string,
+  TAccountTokenProgram extends string | AccountMeta<string> = string,
+  TRemainingAccounts extends readonly AccountMeta<string>[] = [],
+> = Instruction<TProgram> &
+  InstructionWithData<ReadonlyUint8Array> &
+  InstructionWithAccounts<
+    [
+      TAccountPayer extends string
+        ? ReadonlySignerAccount<TAccountPayer> &
+            AccountSignerMeta<TAccountPayer>
+        : TAccountPayer,
+      TAccountChannel extends string
+        ? WritableAccount<TAccountChannel>
+        : TAccountChannel,
+      TAccountChannelTokenAccount extends string
+        ? WritableAccount<TAccountChannelTokenAccount>
+        : TAccountChannelTokenAccount,
+      TAccountPayerTokenAccount extends string
+        ? WritableAccount<TAccountPayerTokenAccount>
+        : TAccountPayerTokenAccount,
+      TAccountMint extends string
+        ? ReadonlyAccount<TAccountMint>
+        : TAccountMint,
+      TAccountTokenProgram extends string
+        ? ReadonlyAccount<TAccountTokenProgram>
+        : TAccountTokenProgram,
+      ...TRemainingAccounts,
+    ]
+  >;
+
+export type WithdrawPayerInstructionData = { discriminator: number };
+
+export type WithdrawPayerInstructionDataArgs = {};
+
+export function getWithdrawPayerInstructionDataEncoder(): FixedSizeEncoder<WithdrawPayerInstructionDataArgs> {
+  return transformEncoder(
+    getStructEncoder([["discriminator", getU8Encoder()]]),
+    (value) => ({ ...value, discriminator: WITHDRAW_PAYER_DISCRIMINATOR }),
+  );
+}
+
+export function getWithdrawPayerInstructionDataDecoder(): FixedSizeDecoder<WithdrawPayerInstructionData> {
+  return getStructDecoder([["discriminator", getU8Decoder()]]);
+}
+
+export function getWithdrawPayerInstructionDataCodec(): FixedSizeCodec<
+  WithdrawPayerInstructionDataArgs,
+  WithdrawPayerInstructionData
+> {
+  return combineCodec(
+    getWithdrawPayerInstructionDataEncoder(),
+    getWithdrawPayerInstructionDataDecoder(),
+  );
+}
+
+export type WithdrawPayerInput<
+  TAccountPayer extends string = string,
+  TAccountChannel extends string = string,
+  TAccountChannelTokenAccount extends string = string,
+  TAccountPayerTokenAccount extends string = string,
+  TAccountMint extends string = string,
+  TAccountTokenProgram extends string = string,
+> = {
+  payer: TransactionSigner<TAccountPayer>;
+  channel: Address<TAccountChannel>;
+  channelTokenAccount: Address<TAccountChannelTokenAccount>;
+  payerTokenAccount: Address<TAccountPayerTokenAccount>;
+  mint: Address<TAccountMint>;
+  tokenProgram: Address<TAccountTokenProgram>;
+};
+
+export function getWithdrawPayerInstruction<
+  TAccountPayer extends string,
+  TAccountChannel extends string,
+  TAccountChannelTokenAccount extends string,
+  TAccountPayerTokenAccount extends string,
+  TAccountMint extends string,
+  TAccountTokenProgram extends string,
+  TProgramAddress extends Address = typeof PAYMENT_CHANNELS_PROGRAM_ADDRESS,
+>(
+  input: WithdrawPayerInput<
+    TAccountPayer,
+    TAccountChannel,
+    TAccountChannelTokenAccount,
+    TAccountPayerTokenAccount,
+    TAccountMint,
+    TAccountTokenProgram
+  >,
+  config?: { programAddress?: TProgramAddress },
+): WithdrawPayerInstruction<
+  TProgramAddress,
+  TAccountPayer,
+  TAccountChannel,
+  TAccountChannelTokenAccount,
+  TAccountPayerTokenAccount,
+  TAccountMint,
+  TAccountTokenProgram
+> {
+  // Program address.
+  const programAddress =
+    config?.programAddress ?? PAYMENT_CHANNELS_PROGRAM_ADDRESS;
+
+  // Original accounts.
+  const originalAccounts = {
+    payer: { value: input.payer ?? null, isWritable: false },
+    channel: { value: input.channel ?? null, isWritable: true },
+    channelTokenAccount: {
+      value: input.channelTokenAccount ?? null,
+      isWritable: true,
+    },
+    payerTokenAccount: {
+      value: input.payerTokenAccount ?? null,
+      isWritable: true,
+    },
+    mint: { value: input.mint ?? null, isWritable: false },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+  };
+  const accounts = originalAccounts as Record<
+    keyof typeof originalAccounts,
+    ResolvedInstructionAccount
+  >;
+
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta("payer", accounts.payer),
+      getAccountMeta("channel", accounts.channel),
+      getAccountMeta("channelTokenAccount", accounts.channelTokenAccount),
+      getAccountMeta("payerTokenAccount", accounts.payerTokenAccount),
+      getAccountMeta("mint", accounts.mint),
+      getAccountMeta("tokenProgram", accounts.tokenProgram),
+    ],
+    data: getWithdrawPayerInstructionDataEncoder().encode({}),
+    programAddress,
+  } as WithdrawPayerInstruction<
+    TProgramAddress,
+    TAccountPayer,
+    TAccountChannel,
+    TAccountChannelTokenAccount,
+    TAccountPayerTokenAccount,
+    TAccountMint,
+    TAccountTokenProgram
+  >);
+}
+
+export type ParsedWithdrawPayerInstruction<
+  TProgram extends string = typeof PAYMENT_CHANNELS_PROGRAM_ADDRESS,
+  TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[],
+> = {
+  programAddress: Address<TProgram>;
+  accounts: {
+    payer: TAccountMetas[0];
+    channel: TAccountMetas[1];
+    channelTokenAccount: TAccountMetas[2];
+    payerTokenAccount: TAccountMetas[3];
+    mint: TAccountMetas[4];
+    tokenProgram: TAccountMetas[5];
+  };
+  data: WithdrawPayerInstructionData;
+};
+
+export function parseWithdrawPayerInstruction<
+  TProgram extends string,
+  TAccountMetas extends readonly AccountMeta[],
+>(
+  instruction: Instruction<TProgram> &
+    InstructionWithAccounts<TAccountMetas> &
+    InstructionWithData<ReadonlyUint8Array>,
+): ParsedWithdrawPayerInstruction<TProgram, TAccountMetas> {
+  if (instruction.accounts.length !== 6) {
+    throw new SolanaError(
+      SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+      {
+        actualAccountMetas: instruction.accounts.length,
+        expectedAccountMetas: 6,
+      },
+    );
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      payer: getNextAccount(),
+      channel: getNextAccount(),
+      channelTokenAccount: getNextAccount(),
+      payerTokenAccount: getNextAccount(),
+      mint: getNextAccount(),
+      tokenProgram: getNextAccount(),
+    },
+    data: getWithdrawPayerInstructionDataDecoder().decode(instruction.data),
+  };
+}

package/src/clients/typescript/src/generated/pdas/eventAuthority.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 {
+  getProgramDerivedAddress,
+  getUtf8Encoder,
+  type Address,
+  type ProgramDerivedAddress,
+} from "@solana/kit";
+
+export async function findEventAuthorityPda(
+  config: { programAddress?: Address | undefined } = {},
+): Promise<ProgramDerivedAddress> {
+  const {
+    programAddress = "CHNLxYvVA28MJP9PrFuDXccuoGXAx7jBacfLEkahyGsX" as Address<"CHNLxYvVA28MJP9PrFuDXccuoGXAx7jBacfLEkahyGsX">,
+  } = config;
+  return await getProgramDerivedAddress({
+    programAddress,
+    seeds: [getUtf8Encoder().encode("event_authority")],
+  });
+}

package/src/clients/typescript/src/generated/pdas/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 "./eventAuthority";

package/src/clients/typescript/src/generated/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 "./paymentChannels";

package/src/clients/typescript/src/generated/programs/paymentChannels.ts

@@ -0,0 +1,366 @@
+/**
+ * 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 {
+  assertIsInstructionWithAccounts,
+  containsBytes,
+  extendClient,
+  SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
+  SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
+  SolanaError,
+  type Address,
+  type ClientWithRpc,
+  type ClientWithTransactionPlanning,
+  type ClientWithTransactionSending,
+  type GetAccountInfoApi,
+  type GetMultipleAccountsApi,
+  type Instruction,
+  type InstructionWithData,
+  type ReadonlyUint8Array,
+} from "@solana/kit";
+import {
+  addSelfFetchFunctions,
+  addSelfPlanAndSendFunctions,
+  type SelfFetchFunctions,
+  type SelfPlanAndSendFunctions,
+} from "@solana/program-client-core";
+import { getU8Encoder } from "../../safe-codecs.js";
+import { getChannelCodec, type Channel, type ChannelArgs } from "../accounts";
+import {
+  getDistributeInstructionAsync,
+  getEmitEventInstructionAsync,
+  getOpenInstructionAsync,
+  getReclaimInstruction,
+  getRequestCloseInstruction,
+  getSealInstruction,
+  getSettleAndSealInstruction,
+  getSettleInstruction,
+  getTopUpInstruction,
+  getWithdrawPayerInstruction,
+  parseDistributeInstruction,
+  parseEmitEventInstruction,
+  parseOpenInstruction,
+  parseReclaimInstruction,
+  parseRequestCloseInstruction,
+  parseSealInstruction,
+  parseSettleAndSealInstruction,
+  parseSettleInstruction,
+  parseTopUpInstruction,
+  parseWithdrawPayerInstruction,
+  type DistributeAsyncInput,
+  type EmitEventAsyncInput,
+  type OpenAsyncInput,
+  type ParsedDistributeInstruction,
+  type ParsedEmitEventInstruction,
+  type ParsedOpenInstruction,
+  type ParsedReclaimInstruction,
+  type ParsedRequestCloseInstruction,
+  type ParsedSealInstruction,
+  type ParsedSettleAndSealInstruction,
+  type ParsedSettleInstruction,
+  type ParsedTopUpInstruction,
+  type ParsedWithdrawPayerInstruction,
+  type ReclaimInput,
+  type RequestCloseInput,
+  type SealInput,
+  type SettleAndSealInput,
+  type SettleInput,
+  type TopUpInput,
+  type WithdrawPayerInput,
+} from "../instructions";
+import { findEventAuthorityPda } from "../pdas";
+
+export const PAYMENT_CHANNELS_PROGRAM_ADDRESS =
+  "CHNLxYvVA28MJP9PrFuDXccuoGXAx7jBacfLEkahyGsX" as Address<"CHNLxYvVA28MJP9PrFuDXccuoGXAx7jBacfLEkahyGsX">;
+
+export enum PaymentChannelsAccount {
+  Channel,
+}
+
+export enum PaymentChannelsInstruction {
+  Open,
+  Settle,
+  TopUp,
+  SettleAndSeal,
+  RequestClose,
+  Seal,
+  Distribute,
+  WithdrawPayer,
+  Reclaim,
+  EmitEvent,
+}
+
+export function identifyPaymentChannelsInstruction(
+  instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
+): PaymentChannelsInstruction {
+  const data = "data" in instruction ? instruction.data : instruction;
+  if (containsBytes(data, getU8Encoder().encode(1), 0)) {
+    return PaymentChannelsInstruction.Open;
+  }
+  if (containsBytes(data, getU8Encoder().encode(2), 0)) {
+    return PaymentChannelsInstruction.Settle;
+  }
+  if (containsBytes(data, getU8Encoder().encode(3), 0)) {
+    return PaymentChannelsInstruction.TopUp;
+  }
+  if (containsBytes(data, getU8Encoder().encode(4), 0)) {
+    return PaymentChannelsInstruction.SettleAndSeal;
+  }
+  if (containsBytes(data, getU8Encoder().encode(5), 0)) {
+    return PaymentChannelsInstruction.RequestClose;
+  }
+  if (containsBytes(data, getU8Encoder().encode(6), 0)) {
+    return PaymentChannelsInstruction.Seal;
+  }
+  if (containsBytes(data, getU8Encoder().encode(7), 0)) {
+    return PaymentChannelsInstruction.Distribute;
+  }
+  if (containsBytes(data, getU8Encoder().encode(8), 0)) {
+    return PaymentChannelsInstruction.WithdrawPayer;
+  }
+  if (containsBytes(data, getU8Encoder().encode(9), 0)) {
+    return PaymentChannelsInstruction.Reclaim;
+  }
+  if (containsBytes(data, getU8Encoder().encode(228), 0)) {
+    return PaymentChannelsInstruction.EmitEvent;
+  }
+  throw new SolanaError(
+    SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
+    { instructionData: data, programName: "paymentChannels" },
+  );
+}
+
+export type ParsedPaymentChannelsInstruction<
+  TProgram extends string = "CHNLxYvVA28MJP9PrFuDXccuoGXAx7jBacfLEkahyGsX",
+> =
+  | ({
+      instructionType: PaymentChannelsInstruction.Open;
+    } & ParsedOpenInstruction<TProgram>)
+  | ({
+      instructionType: PaymentChannelsInstruction.Settle;
+    } & ParsedSettleInstruction<TProgram>)
+  | ({
+      instructionType: PaymentChannelsInstruction.TopUp;
+    } & ParsedTopUpInstruction<TProgram>)
+  | ({
+      instructionType: PaymentChannelsInstruction.SettleAndSeal;
+    } & ParsedSettleAndSealInstruction<TProgram>)
+  | ({
+      instructionType: PaymentChannelsInstruction.RequestClose;
+    } & ParsedRequestCloseInstruction<TProgram>)
+  | ({
+      instructionType: PaymentChannelsInstruction.Seal;
+    } & ParsedSealInstruction<TProgram>)
+  | ({
+      instructionType: PaymentChannelsInstruction.Distribute;
+    } & ParsedDistributeInstruction<TProgram>)
+  | ({
+      instructionType: PaymentChannelsInstruction.WithdrawPayer;
+    } & ParsedWithdrawPayerInstruction<TProgram>)
+  | ({
+      instructionType: PaymentChannelsInstruction.Reclaim;
+    } & ParsedReclaimInstruction<TProgram>)
+  | ({
+      instructionType: PaymentChannelsInstruction.EmitEvent;
+    } & ParsedEmitEventInstruction<TProgram>);
+
+export function parsePaymentChannelsInstruction<TProgram extends string>(
+  instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
+): ParsedPaymentChannelsInstruction<TProgram> {
+  const instructionType = identifyPaymentChannelsInstruction(instruction);
+  switch (instructionType) {
+    case PaymentChannelsInstruction.Open: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: PaymentChannelsInstruction.Open,
+        ...parseOpenInstruction(instruction),
+      };
+    }
+    case PaymentChannelsInstruction.Settle: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: PaymentChannelsInstruction.Settle,
+        ...parseSettleInstruction(instruction),
+      };
+    }
+    case PaymentChannelsInstruction.TopUp: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: PaymentChannelsInstruction.TopUp,
+        ...parseTopUpInstruction(instruction),
+      };
+    }
+    case PaymentChannelsInstruction.SettleAndSeal: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: PaymentChannelsInstruction.SettleAndSeal,
+        ...parseSettleAndSealInstruction(instruction),
+      };
+    }
+    case PaymentChannelsInstruction.RequestClose: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: PaymentChannelsInstruction.RequestClose,
+        ...parseRequestCloseInstruction(instruction),
+      };
+    }
+    case PaymentChannelsInstruction.Seal: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: PaymentChannelsInstruction.Seal,
+        ...parseSealInstruction(instruction),
+      };
+    }
+    case PaymentChannelsInstruction.Distribute: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: PaymentChannelsInstruction.Distribute,
+        ...parseDistributeInstruction(instruction),
+      };
+    }
+    case PaymentChannelsInstruction.WithdrawPayer: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: PaymentChannelsInstruction.WithdrawPayer,
+        ...parseWithdrawPayerInstruction(instruction),
+      };
+    }
+    case PaymentChannelsInstruction.Reclaim: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: PaymentChannelsInstruction.Reclaim,
+        ...parseReclaimInstruction(instruction),
+      };
+    }
+    case PaymentChannelsInstruction.EmitEvent: {
+      assertIsInstructionWithAccounts(instruction);
+      return {
+        instructionType: PaymentChannelsInstruction.EmitEvent,
+        ...parseEmitEventInstruction(instruction),
+      };
+    }
+    default:
+      throw new SolanaError(
+        SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
+        {
+          instructionType: instructionType as string,
+          programName: "paymentChannels",
+        },
+      );
+  }
+}
+
+export type PaymentChannelsPlugin = {
+  accounts: PaymentChannelsPluginAccounts;
+  instructions: PaymentChannelsPluginInstructions;
+  pdas: PaymentChannelsPluginPdas;
+};
+
+export type PaymentChannelsPluginAccounts = {
+  channel: ReturnType<typeof getChannelCodec> &
+    SelfFetchFunctions<ChannelArgs, Channel>;
+};
+
+export type PaymentChannelsPluginInstructions = {
+  open: (
+    input: OpenAsyncInput,
+  ) => ReturnType<typeof getOpenInstructionAsync> & SelfPlanAndSendFunctions;
+  settle: (
+    input: SettleInput,
+  ) => ReturnType<typeof getSettleInstruction> & SelfPlanAndSendFunctions;
+  topUp: (
+    input: TopUpInput,
+  ) => ReturnType<typeof getTopUpInstruction> & SelfPlanAndSendFunctions;
+  settleAndSeal: (
+    input: SettleAndSealInput,
+  ) => ReturnType<typeof getSettleAndSealInstruction> &
+    SelfPlanAndSendFunctions;
+  requestClose: (
+    input: RequestCloseInput,
+  ) => ReturnType<typeof getRequestCloseInstruction> & SelfPlanAndSendFunctions;
+  seal: (
+    input: SealInput,
+  ) => ReturnType<typeof getSealInstruction> & SelfPlanAndSendFunctions;
+  distribute: (
+    input: DistributeAsyncInput,
+  ) => ReturnType<typeof getDistributeInstructionAsync> &
+    SelfPlanAndSendFunctions;
+  withdrawPayer: (
+    input: WithdrawPayerInput,
+  ) => ReturnType<typeof getWithdrawPayerInstruction> &
+    SelfPlanAndSendFunctions;
+  reclaim: (
+    input: ReclaimInput,
+  ) => ReturnType<typeof getReclaimInstruction> & SelfPlanAndSendFunctions;
+  emitEvent: (
+    input: EmitEventAsyncInput,
+  ) => ReturnType<typeof getEmitEventInstructionAsync> &
+    SelfPlanAndSendFunctions;
+};
+
+export type PaymentChannelsPluginPdas = {
+  eventAuthority: typeof findEventAuthorityPda;
+};
+
+export type PaymentChannelsPluginRequirements = ClientWithRpc<
+  GetAccountInfoApi & GetMultipleAccountsApi
+> &
+  ClientWithTransactionPlanning &
+  ClientWithTransactionSending;
+
+export function paymentChannelsProgram() {
+  return <T extends PaymentChannelsPluginRequirements>(
+    client: T,
+  ): Omit<T, "paymentChannels"> & {
+    paymentChannels: PaymentChannelsPlugin;
+  } => {
+    return extendClient(client, {
+      paymentChannels: <PaymentChannelsPlugin>{
+        accounts: { channel: addSelfFetchFunctions(client, getChannelCodec()) },
+        instructions: {
+          open: (input) =>
+            addSelfPlanAndSendFunctions(client, getOpenInstructionAsync(input)),
+          settle: (input) =>
+            addSelfPlanAndSendFunctions(client, getSettleInstruction(input)),
+          topUp: (input) =>
+            addSelfPlanAndSendFunctions(client, getTopUpInstruction(input)),
+          settleAndSeal: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getSettleAndSealInstruction(input),
+            ),
+          requestClose: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getRequestCloseInstruction(input),
+            ),
+          seal: (input) =>
+            addSelfPlanAndSendFunctions(client, getSealInstruction(input)),
+          distribute: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getDistributeInstructionAsync(input),
+            ),
+          withdrawPayer: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getWithdrawPayerInstruction(input),
+            ),
+          reclaim: (input) =>
+            addSelfPlanAndSendFunctions(client, getReclaimInstruction(input)),
+          emitEvent: (input) =>
+            addSelfPlanAndSendFunctions(
+              client,
+              getEmitEventInstructionAsync(input),
+            ),
+        },
+        pdas: { eventAuthority: findEventAuthorityPda },
+      },
+    }) as any;
+  };
+}

package/src/clients/typescript/src/generated/types/accountDiscriminator.ts

@@ -0,0 +1,41 @@
+/**
+ * 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,
+  getEnumDecoder,
+  getEnumEncoder,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
+} from "@solana/kit";
+
+export enum AccountDiscriminator {
+  Channel,
+  ClosedChannel,
+}
+
+export type AccountDiscriminatorArgs = AccountDiscriminator;
+
+export function getAccountDiscriminatorEncoder(): FixedSizeEncoder<AccountDiscriminatorArgs> {
+  return getEnumEncoder(AccountDiscriminator);
+}
+
+export function getAccountDiscriminatorDecoder(): FixedSizeDecoder<AccountDiscriminator> {
+  return getEnumDecoder(AccountDiscriminator);
+}
+
+export function getAccountDiscriminatorCodec(): FixedSizeCodec<
+  AccountDiscriminatorArgs,
+  AccountDiscriminator
+> {
+  return combineCodec(
+    getAccountDiscriminatorEncoder(),
+    getAccountDiscriminatorDecoder(),
+  );
+}