@shogun-sdk/intents-sdk 1.0.2 → 1.1.1

package/src/core/solana/generated/single-chain/accounts/guard.ts

@@ -0,0 +1,156 @@
+/**
+ * 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,
+  decodeAccount,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  type Account,
+  type EncodedAccount,
+  type FetchAccountConfig,
+  type FetchAccountsConfig,
+  type MaybeAccount,
+  type MaybeEncodedAccount,
+} from '@solana/kit';
+import { getAddressDecoder, getAddressEncoder, type Address } from '@solana/kit';
+import {
+  combineCodec,
+  fixDecoderSize,
+  fixEncoderSize,
+  getBytesDecoder,
+  getBytesEncoder,
+  getStructDecoder,
+  getStructEncoder,
+  getU64Decoder,
+  getU64Encoder,
+  getU8Decoder,
+  getU8Encoder,
+  transformEncoder,
+  type Codec,
+  type Decoder,
+  type Encoder,
+  type ReadonlyUint8Array,
+} from '@solana/kit';
+
+export const GUARD_DISCRIMINATOR = new Uint8Array([54, 187, 84, 137, 192, 15, 74, 248]);
+
+export function getGuardDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(GUARD_DISCRIMINATOR);
+}
+
+export type Guard = {
+  discriminator: ReadonlyUint8Array;
+  /** Token that is used for collected protocol fees */
+  feeToken: Address;
+  /** Version that allows having multiple Guards with same `fee_token` */
+  version: number;
+  /** PDA bump */
+  bump: number;
+  /** Public key of auctioneer that signs permissions and confirmations */
+  auctioneerPubKey: Address;
+  /** Amount of collected fees, in collateral tokens */
+  collectedFees: bigint;
+};
+
+export type GuardArgs = {
+  /** Token that is used for collected protocol fees */
+  feeToken: Address;
+  /** Version that allows having multiple Guards with same `fee_token` */
+  version: number;
+  /** PDA bump */
+  bump: number;
+  /** Public key of auctioneer that signs permissions and confirmations */
+  auctioneerPubKey: Address;
+  /** Amount of collected fees, in collateral tokens */
+  collectedFees: number | bigint;
+};
+
+export function getGuardEncoder(): Encoder<GuardArgs> {
+  return transformEncoder(
+    getStructEncoder([
+      ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
+      ['feeToken', getAddressEncoder()],
+      ['version', getU8Encoder()],
+      ['bump', getU8Encoder()],
+      ['auctioneerPubKey', getAddressEncoder()],
+      ['collectedFees', getU64Encoder()],
+    ]),
+    (value) => ({ ...value, discriminator: GUARD_DISCRIMINATOR }),
+  );
+}
+
+export function getGuardDecoder(): Decoder<Guard> {
+  return getStructDecoder([
+    ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
+    ['feeToken', getAddressDecoder()],
+    ['version', getU8Decoder()],
+    ['bump', getU8Decoder()],
+    ['auctioneerPubKey', getAddressDecoder()],
+    ['collectedFees', getU64Decoder()],
+  ]);
+}
+
+export function getGuardCodec(): Codec<GuardArgs, Guard> {
+  return combineCodec(getGuardEncoder(), getGuardDecoder());
+}
+
+export function decodeGuard<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress>,
+): Account<Guard, TAddress>;
+export function decodeGuard<TAddress extends string = string>(
+  encodedAccount: MaybeEncodedAccount<TAddress>,
+): MaybeAccount<Guard, TAddress>;
+export function decodeGuard<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+): Account<Guard, TAddress> | MaybeAccount<Guard, TAddress> {
+  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getGuardDecoder());
+}
+
+export async function fetchGuard<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<Guard, TAddress>> {
+  const maybeAccount = await fetchMaybeGuard(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybeGuard<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<Guard, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeGuard(maybeAccount);
+}
+
+export async function fetchAllGuard(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<Guard>[]> {
+  const maybeAccounts = await fetchAllMaybeGuard(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function fetchAllMaybeGuard(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<Guard>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeGuard(maybeAccount));
+}
+
+export function getGuardSize(): number {
+  return 82;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * 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 './adminSingleton.js';
+export * from './dcaOrder.js';
+export * from './guard.js';
+export * from './limitOrder.js';

package/src/core/solana/generated/single-chain/accounts/limitOrder.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,
+  decodeAccount,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  type Account,
+  type EncodedAccount,
+  type FetchAccountConfig,
+  type FetchAccountsConfig,
+  type MaybeAccount,
+  type MaybeEncodedAccount,
+} from '@solana/kit';
+import { getAddressDecoder, getAddressEncoder, type Address } from '@solana/kit';
+import {
+  combineCodec,
+  fixDecoderSize,
+  fixEncoderSize,
+  getArrayDecoder,
+  getArrayEncoder,
+  getBytesDecoder,
+  getBytesEncoder,
+  getStructDecoder,
+  getStructEncoder,
+  getU32Decoder,
+  getU32Encoder,
+  getU64Decoder,
+  getU64Encoder,
+  transformEncoder,
+  type Codec,
+  type Decoder,
+  type Encoder,
+  type ReadonlyUint8Array,
+} from '@solana/kit';
+
+export const LIMIT_ORDER_DISCRIMINATOR = new Uint8Array([137, 183, 212, 91, 115, 29, 141, 227]);
+
+export function getLimitOrderDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(LIMIT_ORDER_DISCRIMINATOR);
+}
+
+export type LimitOrder = {
+  discriminator: ReadonlyUint8Array;
+  /** User address, that created this order */
+  user: Address;
+  /** Guard address, that will protect this order execution */
+  guard: Address;
+  /** Token IN that user wants to spend */
+  tokenInMint: Address;
+  /** Amount of tokens In locked */
+  amountIn: bigint;
+  /** Minimum amount of tokens OUT to receive */
+  amountOutMin: bigint;
+  /**
+   * Keccak256 hash of (token_out,receiver,extra_transfers_tokens_and_receivers,secret_number)
+   * Since we want to hide tokens OUT right until execution moment to protect user from
+   * any sort of MEV attack
+   */
+  secretHash: ReadonlyUint8Array;
+  /**
+   * Array of requested extra transfers amounts
+   * Since we want to hide tokens OUT and receivers right until execution moment
+   * to protect user from any sort of MEV attack
+   * Tokens and receivers will be collected from `remaining_accounts`
+   * during fulfillment and checked against `secret_hash` value
+   */
+  extraTransfersAmounts: Array<bigint>;
+  /** Deadline for the operation, in Unix timestamp format, in SECONDS */
+  deadline: number;
+};
+
+export type LimitOrderArgs = {
+  /** User address, that created this order */
+  user: Address;
+  /** Guard address, that will protect this order execution */
+  guard: Address;
+  /** Token IN that user wants to spend */
+  tokenInMint: Address;
+  /** Amount of tokens In locked */
+  amountIn: number | bigint;
+  /** Minimum amount of tokens OUT to receive */
+  amountOutMin: number | bigint;
+  /**
+   * Keccak256 hash of (token_out,receiver,extra_transfers_tokens_and_receivers,secret_number)
+   * Since we want to hide tokens OUT right until execution moment to protect user from
+   * any sort of MEV attack
+   */
+  secretHash: ReadonlyUint8Array;
+  /**
+   * Array of requested extra transfers amounts
+   * Since we want to hide tokens OUT and receivers right until execution moment
+   * to protect user from any sort of MEV attack
+   * Tokens and receivers will be collected from `remaining_accounts`
+   * during fulfillment and checked against `secret_hash` value
+   */
+  extraTransfersAmounts: Array<number | bigint>;
+  /** Deadline for the operation, in Unix timestamp format, in SECONDS */
+  deadline: number;
+};
+
+export function getLimitOrderEncoder(): Encoder<LimitOrderArgs> {
+  return transformEncoder(
+    getStructEncoder([
+      ['discriminator', fixEncoderSize(getBytesEncoder(), 8)],
+      ['user', getAddressEncoder()],
+      ['guard', getAddressEncoder()],
+      ['tokenInMint', getAddressEncoder()],
+      ['amountIn', getU64Encoder()],
+      ['amountOutMin', getU64Encoder()],
+      ['secretHash', fixEncoderSize(getBytesEncoder(), 32)],
+      ['extraTransfersAmounts', getArrayEncoder(getU64Encoder())],
+      ['deadline', getU32Encoder()],
+    ]),
+    (value) => ({ ...value, discriminator: LIMIT_ORDER_DISCRIMINATOR }),
+  );
+}
+
+export function getLimitOrderDecoder(): Decoder<LimitOrder> {
+  return getStructDecoder([
+    ['discriminator', fixDecoderSize(getBytesDecoder(), 8)],
+    ['user', getAddressDecoder()],
+    ['guard', getAddressDecoder()],
+    ['tokenInMint', getAddressDecoder()],
+    ['amountIn', getU64Decoder()],
+    ['amountOutMin', getU64Decoder()],
+    ['secretHash', fixDecoderSize(getBytesDecoder(), 32)],
+    ['extraTransfersAmounts', getArrayDecoder(getU64Decoder())],
+    ['deadline', getU32Decoder()],
+  ]);
+}
+
+export function getLimitOrderCodec(): Codec<LimitOrderArgs, LimitOrder> {
+  return combineCodec(getLimitOrderEncoder(), getLimitOrderDecoder());
+}
+
+export function decodeLimitOrder<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress>,
+): Account<LimitOrder, TAddress>;
+export function decodeLimitOrder<TAddress extends string = string>(
+  encodedAccount: MaybeEncodedAccount<TAddress>,
+): MaybeAccount<LimitOrder, TAddress>;
+export function decodeLimitOrder<TAddress extends string = string>(
+  encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>,
+): Account<LimitOrder, TAddress> | MaybeAccount<LimitOrder, TAddress> {
+  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getLimitOrderDecoder());
+}
+
+export async function fetchLimitOrder<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<LimitOrder, TAddress>> {
+  const maybeAccount = await fetchMaybeLimitOrder(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybeLimitOrder<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<LimitOrder, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeLimitOrder(maybeAccount);
+}
+
+export async function fetchAllLimitOrder(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<LimitOrder>[]> {
+  const maybeAccounts = await fetchAllMaybeLimitOrder(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function fetchAllMaybeLimitOrder(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<LimitOrder>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeLimitOrder(maybeAccount));
+}

package/src/core/solana/generated/single-chain/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 './singleChainGuard.js';

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

@@ -0,0 +1,140 @@
+/**
+ * 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 { type SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM, type SolanaError } from '@solana/kit';
+import { isProgramError } from '@solana/kit';
+import { SINGLE_CHAIN_GUARD_PROGRAM_ADDRESS } from '../programs/index.js';
+
+/** NotUpgradeAuthority: Account is not upgrade authority */
+export const SINGLE_CHAIN_GUARD_ERROR__NOT_UPGRADE_AUTHORITY = 0x1770; // 6000
+/** NotAdmin: Account is not Admin */
+export const SINGLE_CHAIN_GUARD_ERROR__NOT_ADMIN = 0x1771; // 6001
+/** NotPendingAdmin: Account is not Pending Admin */
+export const SINGLE_CHAIN_GUARD_ERROR__NOT_PENDING_ADMIN = 0x1772; // 6002
+/** NotASolver: Account is not a Solver */
+export const SINGLE_CHAIN_GUARD_ERROR__NOT_A_SOLVER = 0x1773; // 6003
+/** NotAUser: Account is not a User */
+export const SINGLE_CHAIN_GUARD_ERROR__NOT_A_USER = 0x1774; // 6004
+/** ZeroAmount: Amount must not be zero */
+export const SINGLE_CHAIN_GUARD_ERROR__ZERO_AMOUNT = 0x1775; // 6005
+/** ZeroAmountIn: Amount IN must not be zero */
+export const SINGLE_CHAIN_GUARD_ERROR__ZERO_AMOUNT_IN = 0x1776; // 6006
+/** WrongOrder: Wrong order */
+export const SINGLE_CHAIN_GUARD_ERROR__WRONG_ORDER = 0x1777; // 6007
+/** InvalidGuard: Invalid Guard */
+export const SINGLE_CHAIN_GUARD_ERROR__INVALID_GUARD = 0x1778; // 6008
+/** ExpiredDeadline: Expired deadline */
+export const SINGLE_CHAIN_GUARD_ERROR__EXPIRED_DEADLINE = 0x1779; // 6009
+/** InvalidStartPermission: Invalid permission */
+export const SINGLE_CHAIN_GUARD_ERROR__INVALID_START_PERMISSION = 0x177a; // 6010
+/** SystemProgramNotProvided: System program not provided */
+export const SINGLE_CHAIN_GUARD_ERROR__SYSTEM_PROGRAM_NOT_PROVIDED = 0x177b; // 6011
+/** TokenOutAccountNotProvided: Token OUT account not provided */
+export const SINGLE_CHAIN_GUARD_ERROR__TOKEN_OUT_ACCOUNT_NOT_PROVIDED = 0x177c; // 6012
+/** ExtraTransferAccountNotProvided: Extra transfer account not provided */
+export const SINGLE_CHAIN_GUARD_ERROR__EXTRA_TRANSFER_ACCOUNT_NOT_PROVIDED = 0x177d; // 6013
+/** InvalidExtraTransferAccount: Invalid extra transfer account */
+export const SINGLE_CHAIN_GUARD_ERROR__INVALID_EXTRA_TRANSFER_ACCOUNT = 0x177e; // 6014
+/** CpiCallNotAllowed: CPI call is not allowed */
+export const SINGLE_CHAIN_GUARD_ERROR__CPI_CALL_NOT_ALLOWED = 0x177f; // 6015
+/** FeeTransferNotAllowed: Fee transfer not allowed */
+export const SINGLE_CHAIN_GUARD_ERROR__FEE_TRANSFER_NOT_ALLOWED = 0x1780; // 6016
+/** BelowMinAmountOut: Below minimum amount OUT */
+export const SINGLE_CHAIN_GUARD_ERROR__BELOW_MIN_AMOUNT_OUT = 0x1781; // 6017
+/** SecretHashMismatch: Secret hash mismatch */
+export const SINGLE_CHAIN_GUARD_ERROR__SECRET_HASH_MISMATCH = 0x1782; // 6018
+/** InvalidIntervalDuration: Invalid interval duration */
+export const SINGLE_CHAIN_GUARD_ERROR__INVALID_INTERVAL_DURATION = 0x1783; // 6019
+/** InvalidDcaOrder: Invalid DCA order */
+export const SINGLE_CHAIN_GUARD_ERROR__INVALID_DCA_ORDER = 0x1784; // 6020
+/** IntervalIsFulfilled: Interval is already fulfilled */
+export const SINGLE_CHAIN_GUARD_ERROR__INTERVAL_IS_FULFILLED = 0x1785; // 6021
+/** InstructionNotFound: Ed25519Program instruction */
+export const SINGLE_CHAIN_GUARD_ERROR__INSTRUCTION_NOT_FOUND = 0x1786; // 6022
+/** SigVerificationFailed: Signature verification failed */
+export const SINGLE_CHAIN_GUARD_ERROR__SIG_VERIFICATION_FAILED = 0x1787; // 6023
+/** InvalidSigner: Invalid signer */
+export const SINGLE_CHAIN_GUARD_ERROR__INVALID_SIGNER = 0x1788; // 6024
+
+export type SingleChainGuardError =
+  | typeof SINGLE_CHAIN_GUARD_ERROR__BELOW_MIN_AMOUNT_OUT
+  | typeof SINGLE_CHAIN_GUARD_ERROR__CPI_CALL_NOT_ALLOWED
+  | typeof SINGLE_CHAIN_GUARD_ERROR__EXPIRED_DEADLINE
+  | typeof SINGLE_CHAIN_GUARD_ERROR__EXTRA_TRANSFER_ACCOUNT_NOT_PROVIDED
+  | typeof SINGLE_CHAIN_GUARD_ERROR__FEE_TRANSFER_NOT_ALLOWED
+  | typeof SINGLE_CHAIN_GUARD_ERROR__INSTRUCTION_NOT_FOUND
+  | typeof SINGLE_CHAIN_GUARD_ERROR__INTERVAL_IS_FULFILLED
+  | typeof SINGLE_CHAIN_GUARD_ERROR__INVALID_DCA_ORDER
+  | typeof SINGLE_CHAIN_GUARD_ERROR__INVALID_EXTRA_TRANSFER_ACCOUNT
+  | typeof SINGLE_CHAIN_GUARD_ERROR__INVALID_GUARD
+  | typeof SINGLE_CHAIN_GUARD_ERROR__INVALID_INTERVAL_DURATION
+  | typeof SINGLE_CHAIN_GUARD_ERROR__INVALID_SIGNER
+  | typeof SINGLE_CHAIN_GUARD_ERROR__INVALID_START_PERMISSION
+  | typeof SINGLE_CHAIN_GUARD_ERROR__NOT_ADMIN
+  | typeof SINGLE_CHAIN_GUARD_ERROR__NOT_A_SOLVER
+  | typeof SINGLE_CHAIN_GUARD_ERROR__NOT_A_USER
+  | typeof SINGLE_CHAIN_GUARD_ERROR__NOT_PENDING_ADMIN
+  | typeof SINGLE_CHAIN_GUARD_ERROR__NOT_UPGRADE_AUTHORITY
+  | typeof SINGLE_CHAIN_GUARD_ERROR__SECRET_HASH_MISMATCH
+  | typeof SINGLE_CHAIN_GUARD_ERROR__SIG_VERIFICATION_FAILED
+  | typeof SINGLE_CHAIN_GUARD_ERROR__SYSTEM_PROGRAM_NOT_PROVIDED
+  | typeof SINGLE_CHAIN_GUARD_ERROR__TOKEN_OUT_ACCOUNT_NOT_PROVIDED
+  | typeof SINGLE_CHAIN_GUARD_ERROR__WRONG_ORDER
+  | typeof SINGLE_CHAIN_GUARD_ERROR__ZERO_AMOUNT
+  | typeof SINGLE_CHAIN_GUARD_ERROR__ZERO_AMOUNT_IN;
+
+let singleChainGuardErrorMessages: Record<SingleChainGuardError, string> | undefined;
+if (process.env.NODE_ENV !== 'production') {
+  singleChainGuardErrorMessages = {
+    [SINGLE_CHAIN_GUARD_ERROR__BELOW_MIN_AMOUNT_OUT]: `Below minimum amount OUT`,
+    [SINGLE_CHAIN_GUARD_ERROR__CPI_CALL_NOT_ALLOWED]: `CPI call is not allowed`,
+    [SINGLE_CHAIN_GUARD_ERROR__EXPIRED_DEADLINE]: `Expired deadline`,
+    [SINGLE_CHAIN_GUARD_ERROR__EXTRA_TRANSFER_ACCOUNT_NOT_PROVIDED]: `Extra transfer account not provided`,
+    [SINGLE_CHAIN_GUARD_ERROR__FEE_TRANSFER_NOT_ALLOWED]: `Fee transfer not allowed`,
+    [SINGLE_CHAIN_GUARD_ERROR__INSTRUCTION_NOT_FOUND]: `Ed25519Program instruction`,
+    [SINGLE_CHAIN_GUARD_ERROR__INTERVAL_IS_FULFILLED]: `Interval is already fulfilled`,
+    [SINGLE_CHAIN_GUARD_ERROR__INVALID_DCA_ORDER]: `Invalid DCA order`,
+    [SINGLE_CHAIN_GUARD_ERROR__INVALID_EXTRA_TRANSFER_ACCOUNT]: `Invalid extra transfer account`,
+    [SINGLE_CHAIN_GUARD_ERROR__INVALID_GUARD]: `Invalid Guard`,
+    [SINGLE_CHAIN_GUARD_ERROR__INVALID_INTERVAL_DURATION]: `Invalid interval duration`,
+    [SINGLE_CHAIN_GUARD_ERROR__INVALID_SIGNER]: `Invalid signer`,
+    [SINGLE_CHAIN_GUARD_ERROR__INVALID_START_PERMISSION]: `Invalid permission`,
+    [SINGLE_CHAIN_GUARD_ERROR__NOT_ADMIN]: `Account is not Admin`,
+    [SINGLE_CHAIN_GUARD_ERROR__NOT_A_SOLVER]: `Account is not a Solver`,
+    [SINGLE_CHAIN_GUARD_ERROR__NOT_A_USER]: `Account is not a User`,
+    [SINGLE_CHAIN_GUARD_ERROR__NOT_PENDING_ADMIN]: `Account is not Pending Admin`,
+    [SINGLE_CHAIN_GUARD_ERROR__NOT_UPGRADE_AUTHORITY]: `Account is not upgrade authority`,
+    [SINGLE_CHAIN_GUARD_ERROR__SECRET_HASH_MISMATCH]: `Secret hash mismatch`,
+    [SINGLE_CHAIN_GUARD_ERROR__SIG_VERIFICATION_FAILED]: `Signature verification failed`,
+    [SINGLE_CHAIN_GUARD_ERROR__SYSTEM_PROGRAM_NOT_PROVIDED]: `System program not provided`,
+    [SINGLE_CHAIN_GUARD_ERROR__TOKEN_OUT_ACCOUNT_NOT_PROVIDED]: `Token OUT account not provided`,
+    [SINGLE_CHAIN_GUARD_ERROR__WRONG_ORDER]: `Wrong order`,
+    [SINGLE_CHAIN_GUARD_ERROR__ZERO_AMOUNT]: `Amount must not be zero`,
+    [SINGLE_CHAIN_GUARD_ERROR__ZERO_AMOUNT_IN]: `Amount IN must not be zero`,
+  };
+}
+
+export function getSingleChainGuardErrorMessage(code: SingleChainGuardError): string {
+  if (process.env.NODE_ENV !== 'production') {
+    return (singleChainGuardErrorMessages as Record<SingleChainGuardError, string>)[code];
+  }
+
+  return 'Error message not available in production bundles.';
+}
+
+export function isSingleChainGuardError<TProgramErrorCode extends SingleChainGuardError>(
+  error: unknown,
+  transactionMessage: {
+    instructions: Record<number, { programAddress: Address }>;
+  },
+  code?: TProgramErrorCode,
+): error is SolanaError<typeof SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM> &
+  Readonly<{ context: Readonly<{ code: TProgramErrorCode }> }> {
+  return isProgramError<TProgramErrorCode>(error, transactionMessage, SINGLE_CHAIN_GUARD_PROGRAM_ADDRESS, code);
+}

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

@@ -0,0 +1,13 @@
+/**
+ * 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 './accounts/index.js';
+export * from './errors/index.js';
+export * from './instructions/index.js';
+export * from './programs/index.js';
+export * from './types/index.js';