@shunt-network/sdk 1.0.0

package/dist/sdk/channel.d.ts

@@ -0,0 +1,10 @@
+import { type ShuntClient } from "./client.js";
+import { type Address } from "@solana/kit";
+export declare function openPaymentChannel(client: ShuntClient, depositAmount: bigint): Promise<{
+    channel: Address;
+    signature: string;
+}>;
+export declare function topUpPaymentChannel(client: ShuntClient, channelAddress: Address, topUpAmount: bigint): Promise<{
+    channel: Address;
+    signature: string;
+}>;

package/dist/sdk/client.d.ts

@@ -0,0 +1,31 @@
+export declare const devnet = true;
+export declare function createShuntClient(signerFilePath: string): Promise<import("@solana/plugin-core").Client<{
+    planTransaction: (input: import("@solana/instruction-plans").InstructionPlanInput, config?: {
+        abortSignal?: AbortSignal;
+    }) => Promise<import("@solana/instruction-plans").SingleTransactionPlan['message']>;
+    planTransactions: (input: import("@solana/instruction-plans").InstructionPlanInput, config?: {
+        abortSignal?: AbortSignal;
+    }) => Promise<import("@solana/instruction-plans").TransactionPlan>;
+    sendTransaction: (input: import("@solana/instruction-plans").InstructionPlanInput | import("@solana/instruction-plans").SingleTransactionPlan | import("@solana/instruction-plans").SingleTransactionPlan['message'], config?: {
+        abortSignal?: AbortSignal;
+    }) => Promise<import("@solana/instruction-plans").SuccessfulSingleTransactionPlanResult<import("@solana/kit-plugin-rpc").RpcSendContext>>;
+    sendTransactions: (input: import("@solana/instruction-plans").InstructionPlanInput | import("@solana/instruction-plans").TransactionPlanInput, config?: {
+        abortSignal?: AbortSignal;
+    }) => Promise<import("@solana/instruction-plans").TransactionPlanResult<import("@solana/kit-plugin-rpc").RpcSendContext>>;
+    signTransaction: (input: import("@solana/instruction-plans").InstructionPlanInput | import("@solana/instruction-plans").SingleTransactionPlan | import("@solana/instruction-plans").SingleTransactionPlan['message'], config?: {
+        abortSignal?: AbortSignal;
+    }) => Promise<import("@solana/instruction-plans").SuccessfulSingleTransactionPlanResult<import("@solana/kit-plugin-rpc").RpcSignContext>>;
+    signTransactions: (input: import("@solana/instruction-plans").InstructionPlanInput | import("@solana/instruction-plans").TransactionPlanInput, config?: {
+        abortSignal?: AbortSignal;
+    }) => Promise<import("@solana/instruction-plans").TransactionPlanResult<import("@solana/kit-plugin-rpc").RpcSignContext>>;
+    getMinimumBalance: (space: number, config?: import("@solana/plugin-interfaces").GetMinimumBalanceConfig) => Promise<import("@solana/rpc-types").Lamports>;
+    payer: import("@solana/signers").TransactionSigner;
+    rpc: import("@solana/rpc-spec").Rpc<import("@solana/rpc-api").GetAccountInfoApi & import("@solana/rpc-api").GetBalanceApi & import("@solana/rpc-api").GetBlockApi & import("@solana/rpc-api").GetBlockCommitmentApi & import("@solana/rpc-api").GetBlockHeightApi & import("@solana/rpc-api").GetBlockProductionApi & import("@solana/rpc-api").GetBlocksApi & import("@solana/rpc-api").GetBlocksWithLimitApi & import("@solana/rpc-api").GetBlockTimeApi & import("@solana/rpc-api").GetClusterNodesApi & import("@solana/rpc-api").GetEpochInfoApi & import("@solana/rpc-api").GetEpochScheduleApi & import("@solana/rpc-api").GetFeeForMessageApi & import("@solana/rpc-api").GetFirstAvailableBlockApi & import("@solana/rpc-api").GetGenesisHashApi & import("@solana/rpc-api").GetHealthApi & import("@solana/rpc-api").GetHighestSnapshotSlotApi & import("@solana/rpc-api").GetIdentityApi & import("@solana/rpc-api").GetInflationGovernorApi & import("@solana/rpc-api").GetInflationRateApi & import("@solana/rpc-api").GetInflationRewardApi & import("@solana/rpc-api").GetLargestAccountsApi & import("@solana/rpc-api").GetLatestBlockhashApi & import("@solana/rpc-api").GetLeaderScheduleApi & import("@solana/rpc-api").GetMaxRetransmitSlotApi & import("@solana/rpc-api").GetMaxShredInsertSlotApi & import("@solana/rpc-api").GetMinimumBalanceForRentExemptionApi & import("@solana/rpc-api").GetMultipleAccountsApi & import("@solana/rpc-api").GetProgramAccountsApi & import("@solana/rpc-api").GetRecentPerformanceSamplesApi & import("@solana/rpc-api").GetRecentPrioritizationFeesApi & import("@solana/rpc-api").GetSignaturesForAddressApi & import("@solana/rpc-api").GetSignatureStatusesApi & import("@solana/rpc-api").GetSlotApi & import("@solana/rpc-api").GetSlotLeaderApi & import("@solana/rpc-api").GetSlotLeadersApi & import("@solana/rpc-api").GetStakeMinimumDelegationApi & import("@solana/rpc-api").GetSupplyApi & import("@solana/rpc-api").GetTokenAccountBalanceApi & import("@solana/rpc-api").GetTokenAccountsByDelegateApi & import("@solana/rpc-api").GetTokenAccountsByOwnerApi & import("@solana/rpc-api").GetTokenLargestAccountsApi & import("@solana/rpc-api").GetTokenSupplyApi & import("@solana/rpc-api").GetTransactionApi & import("@solana/rpc-api").GetTransactionCountApi & import("@solana/rpc-api").GetTransactionsForAddressApi & import("@solana/rpc-api").GetVersionApi & import("@solana/rpc-api").GetVoteAccountsApi & import("@solana/rpc-api").IsBlockhashValidApi & import("@solana/rpc-api").MinimumLedgerSlotApi & import("@solana/rpc-api").SendTransactionApi & import("@solana/rpc-api").SimulateTransactionApi>;
+    rpcSubscriptions: import("@solana/rpc-subscriptions-spec").RpcSubscriptions<import("@solana/rpc-subscriptions-api").SolanaRpcSubscriptionsApi>;
+    transactionPlanner: import("@solana/instruction-plans").TransactionPlanner;
+    transactionPlanExecutor: import("@solana/instruction-plans").TransactionPlanExecutor<import("@solana/kit-plugin-rpc").RpcSendContext>;
+    system: import("@solana-program/system").SystemPlugin;
+    token: import("@solana-program/token").TokenPlugin;
+}>>;
+export type ShuntClient = Awaited<ReturnType<typeof createShuntClient>>;
+export declare const SHUNT_TREASURY = "4gNrRt7FKoetTTGbJuzp6WYtgqqmKLpjXybPqY3zbVCh";

package/dist/sdk/utils.d.ts

@@ -0,0 +1,3 @@
+import { type ShuntClient } from "./client.js";
+import { type Instruction } from "@solana/kit";
+export declare function sendInstructions(client: ShuntClient, instructions: Instruction[]): Promise<string>;

package/dist/sdk/voucher.d.ts

@@ -0,0 +1,14 @@
+import { type ShuntClient } from "./client.js";
+import { type Address } from "@solana/kit";
+export declare function createSignedVoucher(client: ShuntClient, channelAddress: Address, cumulativeAmount: bigint, expiresAtUnixTimestamp?: bigint): Promise<{
+    voucher: {
+        voucher: {
+            channelId: Address;
+            cumulativeAmount: string;
+            expiresAt?: string | undefined;
+        };
+        signer: import("@solana/nominal-types").NominalType<"brand", "Address"> & import("@solana/nominal-types").NominalType<"stringEncoding", "base58"> & string;
+        signature: string;
+        signatureType: string;
+    };
+}>;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@shunt-network/sdk",
+  "version": "1.0.0",
+  "description": "",
+  "license": "ISC",
+  "author": "Aditya Patwa",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --clean && tsc --emitDeclarationOnly --declaration --outDir dist --skipLibCheck --module esnext --moduleResolution bundler",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^26.5.0",
+    "tsup": "^8.5.1",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.1"
+  },
+  "dependencies": {
+    "@solana-program/system": "^0.14.1",
+    "@solana-program/token": "^0.16.1",
+    "@solana/kit": "^8.2.0",
+    "@solana/kit-plugin-rpc": "^0.19.0",
+    "@solana/kit-plugin-signer": "^0.19.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/clients/typescript/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@payment-channels/client",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "format": "biome format --write .",
+    "format:check": "biome format .",
+    "clean": "rm -rf dist src/generated"
+  },
+  "dependencies": {
+    "@solana/kit": "^6.1.0",
+    "@solana/program-client-core": "^6.1.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.8",
+    "@types/node": "^25.0.10"
+  }
+}

package/src/clients/typescript/src/__tests__/instruction-parsers.test.ts

@@ -0,0 +1,81 @@
+import {
+  AccountRole,
+  createNoopSigner,
+  getAddressDecoder,
+  isSolanaError,
+  SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS,
+  type AccountMeta,
+  type Address,
+} from '@solana/kit';
+import { describe, expect, it } from 'vitest';
+import {
+  getDistributeInstructionDataEncoder,
+  getRequestCloseInstruction,
+  PAYMENT_CHANNELS_PROGRAM_ADDRESS,
+  parseDistributeInstruction,
+  parseRequestCloseInstruction,
+} from '../generated/index.js';
+
+// Any valid base58 address works; system program is the easiest to grab.
+const SYSTEM_ADDR = '11111111111111111111111111111111' as Address;
+const EXTRA_META: AccountMeta = { address: SYSTEM_ADDR, role: AccountRole.READONLY };
+
+describe('fixed-shape parsers mirror the on-chain exact account lists', () => {
+  const exact = getRequestCloseInstruction({
+    payer: createNoopSigner(SYSTEM_ADDR),
+    channel: SYSTEM_ADDR,
+  });
+
+  it('parses a builder-produced requestClose instruction (exactly 2 accounts)', () => {
+    const parsed = parseRequestCloseInstruction(exact);
+    expect(parsed.accounts.payer.address).toBe(SYSTEM_ADDR);
+    expect(parsed.accounts.channel.address).toBe(SYSTEM_ADDR);
+  });
+
+  it('rejects a requestClose instruction with one extra account', () => {
+    const oversupplied = { ...exact, accounts: [...exact.accounts, EXTRA_META] };
+    let thrown: unknown;
+    try {
+      parseRequestCloseInstruction(oversupplied);
+    } catch (error) {
+      thrown = error;
+    }
+    // The kit has no wrong-account-count error, so the parser reuses the
+    // insufficient-metas one for the too-many direction as well.
+    expect(isSolanaError(thrown, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS)).toBe(
+      true,
+    );
+  });
+
+  it('still parses distribute with a remaining-accounts tail (11 fixed + 2 extra)', () => {
+    // Distinct address per slot so the assertion pins positional mapping.
+    const metas: AccountMeta[] = Array.from({ length: 13 }, (_, i) => ({
+      address: getAddressDecoder().decode(new Uint8Array(32).fill(i + 1)),
+      role: AccountRole.READONLY,
+    }));
+    const distribute = {
+      programAddress: PAYMENT_CHANNELS_PROGRAM_ADDRESS,
+      accounts: metas,
+      data: getDistributeInstructionDataEncoder().encode({
+        distributeArgs: { recipients: [] },
+      }),
+    };
+    const parsed = parseDistributeInstruction(distribute);
+    const named = [
+      parsed.accounts.channel,
+      parsed.accounts.payer,
+      parsed.accounts.rentPayer,
+      parsed.accounts.channelTokenAccount,
+      parsed.accounts.payerTokenAccount,
+      parsed.accounts.payeeTokenAccount,
+      parsed.accounts.treasuryTokenAccount,
+      parsed.accounts.mint,
+      parsed.accounts.tokenProgram,
+      parsed.accounts.eventAuthority,
+      parsed.accounts.selfProgram,
+    ];
+    expect(named.map((meta) => meta.address)).toEqual(
+      metas.slice(0, 11).map((meta) => meta.address),
+    );
+  });
+});

package/src/clients/typescript/src/__tests__/voucher-numeric-safety.test.ts

@@ -0,0 +1,176 @@
+import type { Address } from '@solana/kit';
+import { describe, expect, it } from 'vitest';
+import {
+  getOpenArgsEncoder,
+  getTopUpArgsEncoder,
+  getVoucherArgsDecoder,
+  getVoucherArgsEncoder,
+} from '../generated/index.js';
+import { getI64Encoder, getU64Encoder } from '../safe-codecs.js';
+
+// Any valid base58 address works; system program is the easiest to grab.
+const SYSTEM_ADDR = '11111111111111111111111111111111' as Address;
+
+// Domain-separation prefix of the voucher payload: tag 'V' + version 0x01.
+const MAGIC = [0x56, 0x01];
+
+describe('safe u64/i64 encoders runtime-reject lossy JS numbers', () => {
+  it('throws TypeError on cumulativeAmount above 2^53-1 passed as number', () => {
+    const encoder = getVoucherArgsEncoder();
+    // TS blocks this, but JS callers can still pass a raw number.
+    // The error message should mention bigint so the caller knows what to do.
+    expect(() =>
+      encoder.encode({
+        magic: MAGIC,
+        channelId: SYSTEM_ADDR,
+        cumulativeAmount: 9007199254740993 as unknown as bigint,
+        expiresAt: 0n,
+      }),
+    ).toThrow(
+      expect.objectContaining({
+        constructor: TypeError,
+        message: expect.stringMatching(/bigint/i),
+      }),
+    );
+  });
+
+  it('produces distinct images for 2^53 and 2^53 + 1 (regression for the SOLA4-2 root cause)', () => {
+    const encoder = getVoucherArgsEncoder();
+    const a = encoder.encode({
+      magic: MAGIC,
+      channelId: SYSTEM_ADDR,
+      cumulativeAmount: 2n ** 53n,
+      expiresAt: 0n,
+    });
+    const b = encoder.encode({
+      magic: MAGIC,
+      channelId: SYSTEM_ADDR,
+      cumulativeAmount: 2n ** 53n + 1n,
+      expiresAt: 0n,
+    });
+    expect(a.length).toBe(50);
+    expect(b.length).toBe(50);
+    expect(Buffer.from(a).equals(Buffer.from(b))).toBe(false);
+  });
+
+  it('round-trips bigint cumulativeAmount through encoder/decoder as bigint', () => {
+    const bytes = getVoucherArgsEncoder().encode({
+      magic: MAGIC,
+      channelId: SYSTEM_ADDR,
+      cumulativeAmount: 100n,
+      expiresAt: 0n,
+    });
+    const decoded = getVoucherArgsDecoder().decode(bytes);
+    expect(decoded.cumulativeAmount).toBe(100n);
+    // Should come back as bigint, not number.
+    expect(typeof decoded.cumulativeAmount).toBe('bigint');
+  });
+
+  it('accepts safe-integer JS number at runtime and matches bigint encoding', () => {
+    const encoder = getVoucherArgsEncoder();
+    const fromNumber = encoder.encode({
+      magic: MAGIC,
+      channelId: SYSTEM_ADDR,
+      cumulativeAmount: 100 as unknown as bigint,
+      expiresAt: 0n,
+    });
+    const fromBigint = encoder.encode({
+      magic: MAGIC,
+      channelId: SYSTEM_ADDR,
+      cumulativeAmount: 100n,
+      expiresAt: 0n,
+    });
+    expect(Buffer.from(fromNumber).equals(Buffer.from(fromBigint))).toBe(true);
+  });
+
+  it('accepts negative i64 expiresAt and rejects overflow', () => {
+    const encoder = getVoucherArgsEncoder();
+    // -1n is valid i64
+    expect(() =>
+      encoder.encode({
+        magic: MAGIC,
+        channelId: SYSTEM_ADDR,
+        cumulativeAmount: 0n,
+        expiresAt: -1n,
+      }),
+    ).not.toThrow();
+    // 2^63 overflows signed i64
+    expect(() =>
+      encoder.encode({
+        magic: MAGIC,
+        channelId: SYSTEM_ADDR,
+        cumulativeAmount: 0n,
+        expiresAt: 2n ** 63n,
+      }),
+    ).toThrow(RangeError);
+  });
+
+  it('rejects negative u64 and u64 overflow at the raw encoder', () => {
+    const u64 = getU64Encoder();
+    expect(() => u64.encode(-1n)).toThrow(RangeError);
+    expect(() => u64.encode(2n ** 64n)).toThrow(RangeError);
+  });
+
+  it('accepts the inclusive u64 boundaries (0n and 2^64 - 1)', () => {
+    // Both endpoints inclusive; catches off-by-one in the range check.
+    const u64 = getU64Encoder();
+    expect(() => u64.encode(0n)).not.toThrow();
+    expect(() => u64.encode(2n ** 64n - 1n)).not.toThrow();
+  });
+
+  it('also reaches the i64 raw encoder for direct callers', () => {
+    const i64 = getI64Encoder();
+    // sanity check
+    expect(() => i64.encode(0n)).not.toThrow();
+    // unsafe number
+    expect(() => i64.encode(9007199254740993 as unknown as bigint)).toThrow(TypeError);
+  });
+
+  it('accepts the inclusive i64 boundaries and rejects one past either side', () => {
+    const i64 = getI64Encoder();
+    // Both i64 endpoints valid; one past either side overflows.
+    expect(() => i64.encode(-(2n ** 63n))).not.toThrow();
+    expect(() => i64.encode(2n ** 63n - 1n)).not.toThrow();
+    expect(() => i64.encode(-(2n ** 63n) - 1n)).toThrow(RangeError);
+    expect(() => i64.encode(2n ** 63n)).toThrow(RangeError);
+  });
+
+  it('rejects unsafe-integer numbers in OpenArgs.deposit (u64-rich coverage)', () => {
+    const encoder = getOpenArgsEncoder();
+    expect(() =>
+      encoder.encode({
+        salt: 0n,
+        deposit: 9007199254740993 as unknown as bigint,
+        gracePeriod: 0,
+        openSlot: 0n,
+        recipients: [],
+      }),
+    ).toThrow(TypeError);
+  });
+
+  it('rejects unsafe-integer salt in OpenArgs', () => {
+    const encoder = getOpenArgsEncoder();
+    expect(() =>
+      encoder.encode({
+        salt: 9007199254740993 as unknown as bigint,
+        deposit: 0n,
+        gracePeriod: 0,
+        openSlot: 0n,
+        recipients: [],
+      }),
+    ).toThrow(TypeError);
+  });
+
+  it('rejects unsafe-integer TopUpArgs.amount', () => {
+    const encoder = getTopUpArgsEncoder();
+    expect(() => encoder.encode({ amount: 9007199254740993 as unknown as bigint })).toThrow(
+      TypeError,
+    );
+  });
+
+  // (The former SettleAndSealArgs voucher-embedding tests were removed:
+  // `settleAndSeal` no longer carries a voucher in its instruction data —
+  // the voucher rides in the bundled Ed25519 precompile ix. Voucher numeric
+  // safety is covered directly via getVoucherArgsEncoder above, which is the
+  // encoder the off-chain signer uses to build that precompile payload.)
+});

package/src/clients/typescript/src/__tests__/voucher-types.test-d.ts

@@ -0,0 +1,8 @@
+// SOLA4-2 type regression: 64-bit VoucherArgs fields must be `bigint`,
+// not `number | bigint`. Checked by `tsc --noEmit` (vitest skips .test-d.ts).
+import { expectTypeOf } from 'vitest';
+
+import type { VoucherArgsArgs } from '../generated/types/voucherArgs.js';
+
+expectTypeOf<VoucherArgsArgs['cumulativeAmount']>().toEqualTypeOf<bigint>();
+expectTypeOf<VoucherArgsArgs['expiresAt']>().toEqualTypeOf<bigint>();

package/src/clients/typescript/src/generated/accounts/channel.ts

@@ -0,0 +1,192 @@
+/**
+ * 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 {
+  assertAccountExists,
+  assertAccountsExist,
+  combineCodec,
+  decodeAccount,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  getAddressDecoder,
+  getAddressEncoder,
+  getArrayDecoder,
+  getArrayEncoder,
+  getStructDecoder,
+  getStructEncoder,
+  type Account,
+  type Address,
+  type EncodedAccount,
+  type FetchAccountConfig,
+  type FetchAccountsConfig,
+  type FixedSizeCodec,
+  type FixedSizeDecoder,
+  type FixedSizeEncoder,
+  type MaybeAccount,
+  type MaybeEncodedAccount,
+} from "@solana/kit";
+import {
+  getI64Decoder,
+  getI64Encoder,
+  getU32Decoder,
+  getU32Encoder,
+  getU64Decoder,
+  getU64Encoder,
+  getU8Decoder,
+  getU8Encoder,
+} from "../../safe-codecs.js";
+import {
+  getSettlementWatermarksDecoder,
+  getSettlementWatermarksEncoder,
+  type SettlementWatermarks,
+  type SettlementWatermarksArgs,
+} from "../types";
+
+export type Channel = {
+  discriminator: number;
+  version: number;
+  bump: number;
+  status: number;
+  salt: bigint;
+  deposit: bigint;
+  settlement: SettlementWatermarks;
+  closureStartedAt: bigint;
+  payerWithdrawnAt: bigint;
+  gracePeriod: number;
+  distributionHash: Array<number>;
+  payer: Address;
+  payee: Address;
+  authorizedSigner: Address;
+  mint: Address;
+  rentPayer: Address;
+  openSlot: bigint;
+};
+
+export type ChannelArgs = {
+  discriminator: number;
+  version: number;
+  bump: number;
+  status: number;
+  salt: bigint;
+  deposit: bigint;
+  settlement: SettlementWatermarksArgs;
+  closureStartedAt: bigint;
+  payerWithdrawnAt: bigint;
+  gracePeriod: number;
+  distributionHash: Array<number>;
+  payer: Address;
+  payee: Address;
+  authorizedSigner: Address;
+  mint: Address;
+  rentPayer: Address;
+  openSlot: bigint;
+};
+
+/** Gets the encoder for {@link ChannelArgs} account data. */
+export function getChannelEncoder(): FixedSizeEncoder<ChannelArgs> {
+  return getStructEncoder([
+    ["discriminator", getU8Encoder()],
+    ["version", getU8Encoder()],
+    ["bump", getU8Encoder()],
+    ["status", getU8Encoder()],
+    ["salt", getU64Encoder()],
+    ["deposit", getU64Encoder()],
+    ["settlement", getSettlementWatermarksEncoder()],
+    ["closureStartedAt", getI64Encoder()],
+    ["payerWithdrawnAt", getI64Encoder()],
+    ["gracePeriod", getU32Encoder()],
+    ["distributionHash", getArrayEncoder(getU8Encoder(), { size: 32 })],
+    ["payer", getAddressEncoder()],
+    ["payee", getAddressEncoder()],
+    ["authorizedSigner", getAddressEncoder()],
+    ["mint", getAddressEncoder()],
+    ["rentPayer", getAddressEncoder()],
+    ["openSlot", getU64Encoder()],
+  ]);
+}
+
+/** Gets the decoder for {@link Channel} account data. */
+export function getChannelDecoder(): FixedSizeDecoder<Channel> {
+  return getStructDecoder([
+    ["discriminator", getU8Decoder()],
+    ["version", getU8Decoder()],
+    ["bump", getU8Decoder()],
+    ["status", getU8Decoder()],
+    ["salt", getU64Decoder()],
+    ["deposit", getU64Decoder()],
+    ["settlement", getSettlementWatermarksDecoder()],
+    ["closureStartedAt", getI64Decoder()],
+    ["payerWithdrawnAt", getI64Decoder()],
+    ["gracePeriod", getU32Decoder()],
+    ["distributionHash", getArrayDecoder(getU8Decoder(), { size: 32 })],
+    ["payer", getAddressDecoder()],
+    ["payee", getAddressDecoder()],
+    ["authorizedSigner", getAddressDecoder()],
+    ["mint", getAddressDecoder()],
+    ["rentPayer", getAddressDecoder()],
+    ["openSlot", getU64Decoder()],
+  ]);
+}
+
+/** Gets the codec for {@link Channel} account data. */
+export function getChannelCodec(): FixedSizeCodec<ChannelArgs, Channel> {
+  return combineCodec(getChannelEncoder(), getChannelDecoder());
+}
+
+export function decodeChannel<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress>,
+): Account<Channel, TAddress>;
+export function decodeChannel<TAddress extends string = string>(
+  encodedAccount: MaybeEncodedAccount<TAddress>,
+): MaybeAccount<Channel, TAddress>;
+export function decodeChannel<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+): Account<Channel, TAddress> | MaybeAccount<Channel, TAddress> {
+  return decodeAccount(
+    encodedAccount as MaybeEncodedAccount<TAddress>,
+    getChannelDecoder(),
+  );
+}
+
+export async function fetchChannel<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<Channel, TAddress>> {
+  const maybeAccount = await fetchMaybeChannel(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybeChannel<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<Channel, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeChannel(maybeAccount);
+}
+
+export async function fetchAllChannel(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<Channel>[]> {
+  const maybeAccounts = await fetchAllMaybeChannel(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function fetchAllMaybeChannel(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<Channel>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeChannel(maybeAccount));
+}

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

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