@solana/program-client-core 0.0.0 → 6.1.0

package/dist/index.node.cjs

@@ -0,0 +1,117 @@
+'use strict';
+
+var addresses = require('@solana/addresses');
+var errors = require('@solana/errors');
+var instructions = require('@solana/instructions');
+var signers = require('@solana/signers');
+var accounts = require('@solana/accounts');
+
+// src/instruction-input-resolution.ts
+function getNonNullResolvedInstructionInput(inputName, value) {
+  if (value === null || value === void 0) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__PROGRAM_CLIENTS__RESOLVED_INSTRUCTION_INPUT_MUST_BE_NON_NULL, {
+      inputName
+    });
+  }
+  return value;
+}
+function getAddressFromResolvedInstructionAccount(inputName, value) {
+  const nonNullValue = getNonNullResolvedInstructionInput(inputName, value);
+  if (typeof value === "object" && "address" in nonNullValue) {
+    return nonNullValue.address;
+  }
+  if (Array.isArray(nonNullValue)) {
+    return nonNullValue[0];
+  }
+  return nonNullValue;
+}
+function getResolvedInstructionAccountAsProgramDerivedAddress(inputName, value) {
+  if (!addresses.isProgramDerivedAddress(value)) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__PROGRAM_CLIENTS__UNEXPECTED_RESOLVED_INSTRUCTION_INPUT_TYPE, {
+      expectedType: "ProgramDerivedAddress",
+      inputName
+    });
+  }
+  return value;
+}
+function getResolvedInstructionAccountAsTransactionSigner(inputName, value) {
+  if (!isResolvedInstructionAccountSigner(value)) {
+    throw new errors.SolanaError(errors.SOLANA_ERROR__PROGRAM_CLIENTS__UNEXPECTED_RESOLVED_INSTRUCTION_INPUT_TYPE, {
+      expectedType: "TransactionSigner",
+      inputName
+    });
+  }
+  return value;
+}
+function getAccountMetaFactory(programAddress, optionalAccountStrategy) {
+  return (inputName, account) => {
+    if (!account.value) {
+      if (optionalAccountStrategy === "omitted") return;
+      return Object.freeze({ address: programAddress, role: instructions.AccountRole.READONLY });
+    }
+    const writableRole = account.isWritable ? instructions.AccountRole.WRITABLE : instructions.AccountRole.READONLY;
+    const isSigner = isResolvedInstructionAccountSigner(account.value);
+    return Object.freeze({
+      address: getAddressFromResolvedInstructionAccount(inputName, account.value),
+      role: isSigner ? instructions.upgradeRoleToSigner(writableRole) : writableRole,
+      ...isSigner ? { signer: account.value } : {}
+    });
+  };
+}
+function isResolvedInstructionAccountSigner(value) {
+  return !!value && typeof value === "object" && "address" in value && typeof value.address === "string" && signers.isTransactionSigner(value);
+}
+function addSelfFetchFunctions(client, codec) {
+  const fetchMaybe = async (address, config) => {
+    const maybeAccount = await accounts.fetchEncodedAccount(client.rpc, address, config);
+    return accounts.decodeAccount(maybeAccount, codec);
+  };
+  const fetchAllMaybe = async (addresses, config) => {
+    const maybeAccounts = await accounts.fetchEncodedAccounts(client.rpc, addresses, config);
+    return maybeAccounts.map((maybeAccount) => accounts.decodeAccount(maybeAccount, codec));
+  };
+  const fetch = async (address, config) => {
+    const maybeAccount = await fetchMaybe(address, config);
+    accounts.assertAccountExists(maybeAccount);
+    return maybeAccount;
+  };
+  const fetchAll = async (addresses, config) => {
+    const maybeAccounts = await fetchAllMaybe(addresses, config);
+    accounts.assertAccountsExist(maybeAccounts);
+    return maybeAccounts;
+  };
+  const out = { ...codec, fetch, fetchAll, fetchAllMaybe, fetchMaybe };
+  return Object.freeze(out);
+}
+
+// src/self-plan-and-send-functions.ts
+function addSelfPlanAndSendFunctions(client, input) {
+  if (isPromiseLike(input)) {
+    const newInput = input;
+    newInput.planTransaction = async (config) => await client.planTransaction(await input, config);
+    newInput.planTransactions = async (config) => await client.planTransactions(await input, config);
+    newInput.sendTransaction = async (config) => await client.sendTransaction(await input, config);
+    newInput.sendTransactions = async (config) => await client.sendTransactions(await input, config);
+    return newInput;
+  }
+  return Object.freeze({
+    ...input,
+    planTransaction: (config) => client.planTransaction(input, config),
+    planTransactions: (config) => client.planTransactions(input, config),
+    sendTransaction: (config) => client.sendTransaction(input, config),
+    sendTransactions: (config) => client.sendTransactions(input, config)
+  });
+}
+function isPromiseLike(item) {
+  return !!item && (typeof item === "object" || typeof item === "function") && typeof item.then === "function";
+}
+
+exports.addSelfFetchFunctions = addSelfFetchFunctions;
+exports.addSelfPlanAndSendFunctions = addSelfPlanAndSendFunctions;
+exports.getAccountMetaFactory = getAccountMetaFactory;
+exports.getAddressFromResolvedInstructionAccount = getAddressFromResolvedInstructionAccount;
+exports.getNonNullResolvedInstructionInput = getNonNullResolvedInstructionInput;
+exports.getResolvedInstructionAccountAsProgramDerivedAddress = getResolvedInstructionAccountAsProgramDerivedAddress;
+exports.getResolvedInstructionAccountAsTransactionSigner = getResolvedInstructionAccountAsTransactionSigner;
+//# sourceMappingURL=index.node.cjs.map
+//# sourceMappingURL=index.node.cjs.map

package/dist/index.node.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/instruction-input-resolution.ts","../src/self-fetch-functions.ts","../src/self-plan-and-send-functions.ts"],"names":["SolanaError","SOLANA_ERROR__PROGRAM_CLIENTS__RESOLVED_INSTRUCTION_INPUT_MUST_BE_NON_NULL","isProgramDerivedAddress","SOLANA_ERROR__PROGRAM_CLIENTS__UNEXPECTED_RESOLVED_INSTRUCTION_INPUT_TYPE","AccountRole","upgradeRoleToSigner","isTransactionSigner","fetchEncodedAccount","decodeAccount","fetchEncodedAccounts","assertAccountExists","assertAccountsExist"],"mappings":"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","file":"index.node.cjs","sourcesContent":["import { type Address, isProgramDerivedAddress, type ProgramDerivedAddress } from '@solana/addresses';\nimport {\n    SOLANA_ERROR__PROGRAM_CLIENTS__RESOLVED_INSTRUCTION_INPUT_MUST_BE_NON_NULL,\n    SOLANA_ERROR__PROGRAM_CLIENTS__UNEXPECTED_RESOLVED_INSTRUCTION_INPUT_TYPE,\n    SolanaError,\n} from '@solana/errors';\nimport { type AccountMeta, AccountRole, upgradeRoleToSigner } from '@solana/instructions';\nimport { type AccountSignerMeta, isTransactionSigner, type TransactionSigner } from '@solana/signers';\n\n/**\n * Ensures a resolved instruction input is not null or undefined.\n *\n * This function is used during instruction resolution to validate that\n * required inputs have been properly resolved to a non-null value.\n *\n * @typeParam T - The expected type of the resolved input value.\n *\n * @param inputName - The name of the instruction input, used in error messages.\n * @param value - The resolved value to validate.\n * @returns The validated non-null value.\n *\n * @throws Throws a {@link SolanaError} if the value is null or undefined.\n *\n * @example\n * ```ts\n * const resolvedAuthority = getNonNullResolvedInstructionInput(\n *   'authority',\n *   maybeAuthority\n * );\n * // resolvedAuthority is guaranteed to be non-null here.\n * ```\n */\nexport function getNonNullResolvedInstructionInput<T>(inputName: string, value: T | null | undefined): T {\n    if (value === null || value === undefined) {\n        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__RESOLVED_INSTRUCTION_INPUT_MUST_BE_NON_NULL, {\n            inputName,\n        });\n    }\n    return value;\n}\n\n/**\n * Extracts the address from a resolved instruction account.\n *\n * A resolved instruction account can be an {@link Address}, a {@link ProgramDerivedAddress},\n * or a {@link TransactionSigner}. This function extracts the underlying address from\n * any of these types.\n *\n * @typeParam T - The address type, defaults to `string`.\n *\n * @param inputName - The name of the instruction input, used in error messages.\n * @param value - The resolved account value to extract the address from.\n * @returns The extracted address.\n *\n * @throws Throws a {@link SolanaError} if the value is null or undefined.\n *\n * @example\n * ```ts\n * const address = getAddressFromResolvedInstructionAccount('mint', resolvedMint);\n * ```\n */\nexport function getAddressFromResolvedInstructionAccount<T extends string = string>(\n    inputName: string,\n    value: ResolvedInstructionAccount<T>['value'] | undefined,\n): Address<T> {\n    const nonNullValue = getNonNullResolvedInstructionInput(inputName, value);\n    if (typeof value === 'object' && 'address' in nonNullValue) {\n        return nonNullValue.address;\n    }\n    if (Array.isArray(nonNullValue)) {\n        return nonNullValue[0] as Address<T>;\n    }\n    return nonNullValue as Address<T>;\n}\n\n/**\n * Extracts a {@link ProgramDerivedAddress} from a resolved instruction account.\n *\n * This function validates that the resolved account is a PDA and returns it.\n * Use this when you need access to both the address and the bump seed of a PDA.\n *\n * @typeParam T - The address type, defaults to `string`.\n *\n * @param inputName - The name of the instruction input, used in error messages.\n * @param value - The resolved account value expected to be a PDA.\n * @returns The program-derived address.\n *\n * @throws Throws a {@link SolanaError} if the value is not a {@link ProgramDerivedAddress}.\n *\n * @example\n * ```ts\n * const pda = getResolvedInstructionAccountAsProgramDerivedAddress('metadata', resolvedMetadata);\n * const [address, bump] = pda;\n * ```\n */\nexport function getResolvedInstructionAccountAsProgramDerivedAddress<T extends string = string>(\n    inputName: string,\n    value: ResolvedInstructionAccount<T>['value'] | undefined,\n): ProgramDerivedAddress<T> {\n    if (!isProgramDerivedAddress(value)) {\n        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNEXPECTED_RESOLVED_INSTRUCTION_INPUT_TYPE, {\n            expectedType: 'ProgramDerivedAddress',\n            inputName,\n        });\n    }\n    return value;\n}\n\n/**\n * Extracts a {@link TransactionSigner} from a resolved instruction account.\n *\n * This function validates that the resolved account is a transaction signer and returns it.\n * Use this when you need the resolved account to be a signer.\n *\n * @typeParam T - The address type, defaults to `string`.\n *\n * @param inputName - The name of the instruction input, used in error messages.\n * @param value - The resolved account value expected to be a signer.\n * @returns The transaction signer.\n *\n * @throws Throws a {@link SolanaError} if the value is not a {@link TransactionSigner}.\n *\n * @example\n * ```ts\n * const signer = getResolvedInstructionAccountAsTransactionSigner('authority', resolvedAuthority);\n * ```\n */\nexport function getResolvedInstructionAccountAsTransactionSigner<T extends string = string>(\n    inputName: string,\n    value: ResolvedInstructionAccount<T>['value'] | undefined,\n): TransactionSigner<T> {\n    if (!isResolvedInstructionAccountSigner(value)) {\n        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNEXPECTED_RESOLVED_INSTRUCTION_INPUT_TYPE, {\n            expectedType: 'TransactionSigner',\n            inputName,\n        });\n    }\n    return value;\n}\n\n/**\n * Represents a resolved account input for an instruction.\n *\n * During instruction building, account inputs are resolved to this type which\n * captures both the account value and whether it should be marked as writable.\n * The value can be an {@link Address}, a {@link ProgramDerivedAddress}, a\n * {@link TransactionSigner}, or `null` for optional accounts.\n *\n * @typeParam TAddress - The address type, defaults to `string`.\n * @typeParam TValue - The type of the resolved value.\n *\n * @example\n * ```ts\n * const mintAccount: ResolvedInstructionAccount = {\n *   value: mintAddress,\n *   isWritable: true,\n * };\n * ```\n */\nexport type ResolvedInstructionAccount<\n    TAddress extends string = string,\n    TValue extends Address<TAddress> | ProgramDerivedAddress<TAddress> | TransactionSigner<TAddress> | null =\n        | Address<TAddress>\n        | ProgramDerivedAddress<TAddress>\n        | TransactionSigner<TAddress>\n        | null,\n> = {\n    isWritable: boolean;\n    value: TValue;\n};\n\n/**\n * Creates a factory function that converts resolved instruction accounts to account metas.\n *\n * The factory handles the conversion of {@link ResolvedInstructionAccount} objects into\n * {@link AccountMeta} or {@link AccountSignerMeta} objects suitable for building instructions.\n * It also determines how to handle optional accounts based on the provided strategy.\n *\n * @param programAddress - The program address, used when optional accounts use the `programId` strategy.\n * @param optionalAccountStrategy - How to handle null account values:\n *   - `'omitted'`: Optional accounts are excluded from the instruction entirely.\n *   - `'programId'`: Optional accounts are replaced with the program address as a read-only account.\n * @returns A factory function that converts a resolved account to an account meta.\n *\n * @example\n * ```ts\n * const toAccountMeta = getAccountMetaFactory(programAddress, 'programId');\n * const mintMeta = toAccountMeta('mint', resolvedMint);\n * ```\n */\nexport function getAccountMetaFactory(programAddress: Address, optionalAccountStrategy: 'omitted' | 'programId') {\n    return (inputName: string, account: ResolvedInstructionAccount): AccountMeta | AccountSignerMeta | undefined => {\n        if (!account.value) {\n            if (optionalAccountStrategy === 'omitted') return;\n            return Object.freeze({ address: programAddress, role: AccountRole.READONLY });\n        }\n\n        const writableRole = account.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY;\n        const isSigner = isResolvedInstructionAccountSigner(account.value);\n        return Object.freeze({\n            address: getAddressFromResolvedInstructionAccount(inputName, account.value),\n            role: isSigner ? upgradeRoleToSigner(writableRole) : writableRole,\n            ...(isSigner ? { signer: account.value } : {}),\n        });\n    };\n}\n\nfunction isResolvedInstructionAccountSigner(value: unknown): value is TransactionSigner {\n    return (\n        !!value &&\n        typeof value === 'object' &&\n        'address' in value &&\n        typeof value.address === 'string' &&\n        isTransactionSigner(value as { address: Address })\n    );\n}\n","import {\n    type Account,\n    assertAccountExists,\n    assertAccountsExist,\n    decodeAccount,\n    type FetchAccountConfig,\n    type FetchAccountsConfig,\n    fetchEncodedAccount,\n    fetchEncodedAccounts,\n    type MaybeAccount,\n} from '@solana/accounts';\nimport type { Address } from '@solana/addresses';\nimport type { Codec } from '@solana/codecs-core';\nimport type { ClientWithRpc } from '@solana/plugin-interfaces';\nimport type { GetAccountInfoApi, GetMultipleAccountsApi } from '@solana/rpc-api';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype AnyObjectCodec = Codec<any, object>;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype InferTFrom<T> = T extends Codec<infer TFrom, any> ? TFrom : never;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype InferTTo<T> = T extends Codec<any, infer TTo> ? TTo : never;\n\n/**\n * Methods that allow a codec to fetch and decode accounts directly.\n *\n * These methods are added to codec objects via {@link addSelfFetchFunctions},\n * enabling a fluent API where you can call `.fetch()` directly on a codec\n * to retrieve and decode accounts in one step.\n *\n * @typeParam TFrom - The type that the codec encodes from.\n * @typeParam TTo - The type that the codec decodes to.\n *\n * @example\n * Fetching a single account and asserting it exists.\n * ```ts\n * const account = await myAccountCodec.fetch(address);\n * // account.data is of type TTo.\n * ```\n *\n * @example\n * Fetching a single account that may not exist.\n * ```ts\n * const maybeAccount = await myAccountCodec.fetchMaybe(address);\n * if (maybeAccount.exists) {\n *     // maybeAccount.data is of type TTo.\n * }\n * ```\n *\n * @example\n * Fetching multiple accounts at once.\n * ```ts\n * const accounts = await myAccountCodec.fetchAll([addressA, addressB]);\n * // All accounts exist.\n * ```\n *\n * @see {@link addSelfFetchFunctions}\n */\nexport type SelfFetchFunctions<TFrom extends object, TTo extends TFrom> = {\n    /** Fetches and decodes a single account, throwing if it does not exist. */\n    readonly fetch: <TAddress extends string>(\n        address: Address<TAddress>,\n        config?: FetchAccountConfig,\n    ) => Promise<Account<TTo, TAddress>>;\n    /** Fetches and decodes multiple accounts, throwing if any do not exist. */\n    readonly fetchAll: (addresses: Address[], config?: FetchAccountsConfig) => Promise<Account<TTo>[]>;\n    /** Fetches and decodes multiple accounts, returning {@link MaybeAccount} for each. */\n    readonly fetchAllMaybe: (addresses: Address[], config?: FetchAccountsConfig) => Promise<MaybeAccount<TTo>[]>;\n    /** Fetches and decodes a single account, returning a {@link MaybeAccount}. */\n    readonly fetchMaybe: <TAddress extends string>(\n        address: Address<TAddress>,\n        config?: FetchAccountConfig,\n    ) => Promise<MaybeAccount<TTo, TAddress>>;\n};\n\n/**\n * Adds self-fetching methods to a codec for retrieving and decoding accounts.\n *\n * This function augments the provided codec with methods that allow it to fetch\n * accounts from the network and decode them in one step. It enables a fluent API\n * where you can call methods like `.fetch()` directly on the codec.\n *\n * @typeParam TFrom - The type that the codec encodes from.\n * @typeParam TTo - The type that the codec decodes to.\n * @typeParam TCodec - The codec type being augmented.\n *\n * @param client - A client that provides RPC access for fetching accounts.\n * @param codec - The codec to augment with self-fetch methods.\n * @returns The codec augmented with {@link SelfFetchFunctions} methods.\n *\n * @example\n * Adding self-fetch functions to an account codec.\n * ```ts\n * import { addSelfFetchFunctions } from '@solana/program-client-core';\n *\n * const myAccountCodec = addSelfFetchFunctions(client, getMyAccountCodec());\n *\n * // Fetch and decode an account in one step.\n * const account = await myAccountCodec.fetch(accountAddress);\n * ```\n *\n * @example\n * Handling accounts that may not exist.\n * ```ts\n * const myAccountCodec = addSelfFetchFunctions(client, getMyAccountCodec());\n *\n * const maybeAccount = await myAccountCodec.fetchMaybe(accountAddress);\n * if (maybeAccount.exists) {\n *     console.log('Account data:', maybeAccount.data);\n * } else {\n *     console.log(`Account ${maybeAccount.address} does not exist`);\n * }\n * ```\n *\n * @example\n * Fetching multiple accounts at once.\n * ```ts\n * const myAccountCodec = addSelfFetchFunctions(client, getMyAccountCodec());\n *\n * // Throws if any account does not exist.\n * const accounts = await myAccountCodec.fetchAll([addressA, addressB, addressC]);\n *\n * // Returns MaybeAccount for each, allowing some to not exist.\n * const maybeAccounts = await myAccountCodec.fetchAllMaybe([addressA, addressB]);\n * ```\n *\n * @see {@link SelfFetchFunctions}\n */\nexport function addSelfFetchFunctions<TCodec extends AnyObjectCodec>(\n    client: ClientWithRpc<GetAccountInfoApi & GetMultipleAccountsApi>,\n    codec: TCodec,\n): SelfFetchFunctions<InferTFrom<TCodec>, InferTTo<TCodec>> & TCodec {\n    type Functions = SelfFetchFunctions<InferTFrom<TCodec>, InferTTo<TCodec>>;\n    type InferredCodec = Codec<InferTFrom<TCodec>, InferTTo<TCodec>>;\n    const fetchMaybe: Functions['fetchMaybe'] = async (address, config?) => {\n        const maybeAccount = await fetchEncodedAccount(client.rpc, address, config);\n        return decodeAccount(maybeAccount, codec as InferredCodec);\n    };\n    const fetchAllMaybe: Functions['fetchAllMaybe'] = async (addresses, config?) => {\n        const maybeAccounts = await fetchEncodedAccounts(client.rpc, addresses, config);\n        return maybeAccounts.map(maybeAccount => decodeAccount(maybeAccount, codec as InferredCodec));\n    };\n    const fetch: Functions['fetch'] = async (address, config?) => {\n        const maybeAccount = await fetchMaybe(address, config);\n        assertAccountExists(maybeAccount);\n        return maybeAccount;\n    };\n    const fetchAll: Functions['fetchAll'] = async (addresses, config?) => {\n        const maybeAccounts = await fetchAllMaybe(addresses, config);\n        assertAccountsExist(maybeAccounts);\n        return maybeAccounts;\n    };\n\n    const out = { ...codec, fetch, fetchAll, fetchAllMaybe, fetchMaybe };\n    return Object.freeze<typeof out>(out);\n}\n","import type { InstructionPlan } from '@solana/instruction-plans';\nimport type { Instruction } from '@solana/instructions';\nimport type { ClientWithTransactionPlanning, ClientWithTransactionSending } from '@solana/plugin-interfaces';\n\ntype PlanTransaction = ClientWithTransactionPlanning['planTransaction'];\ntype PlanTransactions = ClientWithTransactionPlanning['planTransactions'];\ntype SendTransaction = ClientWithTransactionSending['sendTransaction'];\ntype SendTransactions = ClientWithTransactionSending['sendTransactions'];\n\n/**\n * Methods that allow an instruction or instruction plan to plan and send itself.\n *\n * These methods are added to instruction or instruction plan objects via\n * {@link addSelfPlanAndSendFunctions}, enabling a fluent API where you can call\n * `.sendTransaction()` directly on an instruction without passing it to a separate function.\n *\n * @example\n * Sending a transfer instruction directly.\n * ```ts\n * const result = await getTransferInstruction({ source, destination, amount }).sendTransaction();\n * ```\n *\n * @example\n * Planning multiple transactions from an instruction plan.\n * ```ts\n * const plan = await getComplexInstructionPlan(/* ... *\\/).planTransactions();\n * ```\n *\n * @see {@link addSelfPlanAndSendFunctions}\n */\nexport type SelfPlanAndSendFunctions = {\n    /** Plans a single transaction. */\n    planTransaction: (config?: Parameters<PlanTransaction>[1]) => ReturnType<PlanTransaction>;\n    /** Plans one or more transactions. */\n    planTransactions: (config?: Parameters<PlanTransactions>[1]) => ReturnType<PlanTransactions>;\n    /** Sends a single transaction. */\n    sendTransaction: (config?: Parameters<SendTransaction>[1]) => ReturnType<SendTransaction>;\n    /** Sends one or more transactions. */\n    sendTransactions: (config?: Parameters<SendTransactions>[1]) => ReturnType<SendTransactions>;\n};\n\n/**\n * Adds self-planning and self-sending methods to an instruction or instruction plan.\n *\n * This function augments the provided instruction or instruction plan with methods\n * that allow it to plan and send itself using the provided client. It enables a fluent API\n * where you can call methods like `.sendTransaction()` directly on the instruction.\n *\n * The function supports both synchronous inputs (instructions, instruction plans) and\n * promise-like inputs, making it suitable for use with async instruction builders.\n *\n * @typeParam TItem - The type of the instruction, instruction plan, or a promise resolving to one.\n *\n * @param client - A client that provides transaction planning and sending capabilities.\n * @param input - The instruction, instruction plan, or promise to augment with self-plan/send methods.\n * @returns The input augmented with {@link SelfPlanAndSendFunctions} methods.\n *\n * @example\n * Adding self-plan and send to a transfer instruction.\n * ```ts\n * import { addSelfPlanAndSendFunctions } from '@solana/program-client-core';\n *\n * const transferInstruction = addSelfPlanAndSendFunctions(\n *     client,\n *     getTransferInstruction({ payer, source, destination, amount })\n * );\n *\n * // Now you can send directly from the instruction.\n * const result = await transferInstruction.sendTransaction();\n * ```\n *\n * @example\n * Using with an async instruction builder.\n * ```ts\n * const asyncInstruction = addSelfPlanAndSendFunctions(\n *     client,\n *     fetchAndBuildInstruction(/* ... *\\/)\n * );\n *\n * // The promise is augmented with self-plan/send methods.\n * const result = await asyncInstruction.sendTransaction();\n * ```\n *\n * @see {@link SelfPlanAndSendFunctions}\n */\nexport function addSelfPlanAndSendFunctions<\n    TItem extends Instruction | InstructionPlan | PromiseLike<Instruction> | PromiseLike<InstructionPlan>,\n>(\n    client: ClientWithTransactionPlanning & ClientWithTransactionSending,\n    input: TItem,\n): SelfPlanAndSendFunctions & TItem {\n    if (isPromiseLike(input)) {\n        const newInput = input as SelfPlanAndSendFunctions & TItem;\n        newInput.planTransaction = async config => await client.planTransaction(await input, config);\n        newInput.planTransactions = async config => await client.planTransactions(await input, config);\n        newInput.sendTransaction = async config => await client.sendTransaction(await input, config);\n        newInput.sendTransactions = async config => await client.sendTransactions(await input, config);\n        return newInput;\n    }\n\n    return Object.freeze(<SelfPlanAndSendFunctions & (Instruction | InstructionPlan)>{\n        ...input,\n        planTransaction: config => client.planTransaction(input, config),\n        planTransactions: config => client.planTransactions(input, config),\n        sendTransaction: config => client.sendTransaction(input, config),\n        sendTransactions: config => client.sendTransactions(input, config),\n    }) as unknown as SelfPlanAndSendFunctions & TItem;\n}\n\nfunction isPromiseLike(\n    item: Instruction | InstructionPlan | PromiseLike<Instruction> | PromiseLike<InstructionPlan>,\n): item is PromiseLike<Instruction> | PromiseLike<InstructionPlan> {\n    return (\n        !!item &&\n        (typeof item === 'object' || typeof item === 'function') &&\n        typeof (item as PromiseLike<unknown>).then === 'function'\n    );\n}\n"]}

package/dist/index.node.mjs

@@ -0,0 +1,109 @@
+import { isProgramDerivedAddress } from '@solana/addresses';
+import { SolanaError, SOLANA_ERROR__PROGRAM_CLIENTS__RESOLVED_INSTRUCTION_INPUT_MUST_BE_NON_NULL, SOLANA_ERROR__PROGRAM_CLIENTS__UNEXPECTED_RESOLVED_INSTRUCTION_INPUT_TYPE } from '@solana/errors';
+import { AccountRole, upgradeRoleToSigner } from '@solana/instructions';
+import { isTransactionSigner } from '@solana/signers';
+import { fetchEncodedAccount, decodeAccount, fetchEncodedAccounts, assertAccountExists, assertAccountsExist } from '@solana/accounts';
+
+// src/instruction-input-resolution.ts
+function getNonNullResolvedInstructionInput(inputName, value) {
+  if (value === null || value === void 0) {
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__RESOLVED_INSTRUCTION_INPUT_MUST_BE_NON_NULL, {
+      inputName
+    });
+  }
+  return value;
+}
+function getAddressFromResolvedInstructionAccount(inputName, value) {
+  const nonNullValue = getNonNullResolvedInstructionInput(inputName, value);
+  if (typeof value === "object" && "address" in nonNullValue) {
+    return nonNullValue.address;
+  }
+  if (Array.isArray(nonNullValue)) {
+    return nonNullValue[0];
+  }
+  return nonNullValue;
+}
+function getResolvedInstructionAccountAsProgramDerivedAddress(inputName, value) {
+  if (!isProgramDerivedAddress(value)) {
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNEXPECTED_RESOLVED_INSTRUCTION_INPUT_TYPE, {
+      expectedType: "ProgramDerivedAddress",
+      inputName
+    });
+  }
+  return value;
+}
+function getResolvedInstructionAccountAsTransactionSigner(inputName, value) {
+  if (!isResolvedInstructionAccountSigner(value)) {
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNEXPECTED_RESOLVED_INSTRUCTION_INPUT_TYPE, {
+      expectedType: "TransactionSigner",
+      inputName
+    });
+  }
+  return value;
+}
+function getAccountMetaFactory(programAddress, optionalAccountStrategy) {
+  return (inputName, account) => {
+    if (!account.value) {
+      if (optionalAccountStrategy === "omitted") return;
+      return Object.freeze({ address: programAddress, role: AccountRole.READONLY });
+    }
+    const writableRole = account.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY;
+    const isSigner = isResolvedInstructionAccountSigner(account.value);
+    return Object.freeze({
+      address: getAddressFromResolvedInstructionAccount(inputName, account.value),
+      role: isSigner ? upgradeRoleToSigner(writableRole) : writableRole,
+      ...isSigner ? { signer: account.value } : {}
+    });
+  };
+}
+function isResolvedInstructionAccountSigner(value) {
+  return !!value && typeof value === "object" && "address" in value && typeof value.address === "string" && isTransactionSigner(value);
+}
+function addSelfFetchFunctions(client, codec) {
+  const fetchMaybe = async (address, config) => {
+    const maybeAccount = await fetchEncodedAccount(client.rpc, address, config);
+    return decodeAccount(maybeAccount, codec);
+  };
+  const fetchAllMaybe = async (addresses, config) => {
+    const maybeAccounts = await fetchEncodedAccounts(client.rpc, addresses, config);
+    return maybeAccounts.map((maybeAccount) => decodeAccount(maybeAccount, codec));
+  };
+  const fetch = async (address, config) => {
+    const maybeAccount = await fetchMaybe(address, config);
+    assertAccountExists(maybeAccount);
+    return maybeAccount;
+  };
+  const fetchAll = async (addresses, config) => {
+    const maybeAccounts = await fetchAllMaybe(addresses, config);
+    assertAccountsExist(maybeAccounts);
+    return maybeAccounts;
+  };
+  const out = { ...codec, fetch, fetchAll, fetchAllMaybe, fetchMaybe };
+  return Object.freeze(out);
+}
+
+// src/self-plan-and-send-functions.ts
+function addSelfPlanAndSendFunctions(client, input) {
+  if (isPromiseLike(input)) {
+    const newInput = input;
+    newInput.planTransaction = async (config) => await client.planTransaction(await input, config);
+    newInput.planTransactions = async (config) => await client.planTransactions(await input, config);
+    newInput.sendTransaction = async (config) => await client.sendTransaction(await input, config);
+    newInput.sendTransactions = async (config) => await client.sendTransactions(await input, config);
+    return newInput;
+  }
+  return Object.freeze({
+    ...input,
+    planTransaction: (config) => client.planTransaction(input, config),
+    planTransactions: (config) => client.planTransactions(input, config),
+    sendTransaction: (config) => client.sendTransaction(input, config),
+    sendTransactions: (config) => client.sendTransactions(input, config)
+  });
+}
+function isPromiseLike(item) {
+  return !!item && (typeof item === "object" || typeof item === "function") && typeof item.then === "function";
+}
+
+export { addSelfFetchFunctions, addSelfPlanAndSendFunctions, getAccountMetaFactory, getAddressFromResolvedInstructionAccount, getNonNullResolvedInstructionInput, getResolvedInstructionAccountAsProgramDerivedAddress, getResolvedInstructionAccountAsTransactionSigner };
+//# sourceMappingURL=index.node.mjs.map
+//# sourceMappingURL=index.node.mjs.map

package/dist/index.node.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/instruction-input-resolution.ts","../src/self-fetch-functions.ts","../src/self-plan-and-send-functions.ts"],"names":[],"mappings":"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","file":"index.node.mjs","sourcesContent":["import { type Address, isProgramDerivedAddress, type ProgramDerivedAddress } from '@solana/addresses';\nimport {\n    SOLANA_ERROR__PROGRAM_CLIENTS__RESOLVED_INSTRUCTION_INPUT_MUST_BE_NON_NULL,\n    SOLANA_ERROR__PROGRAM_CLIENTS__UNEXPECTED_RESOLVED_INSTRUCTION_INPUT_TYPE,\n    SolanaError,\n} from '@solana/errors';\nimport { type AccountMeta, AccountRole, upgradeRoleToSigner } from '@solana/instructions';\nimport { type AccountSignerMeta, isTransactionSigner, type TransactionSigner } from '@solana/signers';\n\n/**\n * Ensures a resolved instruction input is not null or undefined.\n *\n * This function is used during instruction resolution to validate that\n * required inputs have been properly resolved to a non-null value.\n *\n * @typeParam T - The expected type of the resolved input value.\n *\n * @param inputName - The name of the instruction input, used in error messages.\n * @param value - The resolved value to validate.\n * @returns The validated non-null value.\n *\n * @throws Throws a {@link SolanaError} if the value is null or undefined.\n *\n * @example\n * ```ts\n * const resolvedAuthority = getNonNullResolvedInstructionInput(\n *   'authority',\n *   maybeAuthority\n * );\n * // resolvedAuthority is guaranteed to be non-null here.\n * ```\n */\nexport function getNonNullResolvedInstructionInput<T>(inputName: string, value: T | null | undefined): T {\n    if (value === null || value === undefined) {\n        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__RESOLVED_INSTRUCTION_INPUT_MUST_BE_NON_NULL, {\n            inputName,\n        });\n    }\n    return value;\n}\n\n/**\n * Extracts the address from a resolved instruction account.\n *\n * A resolved instruction account can be an {@link Address}, a {@link ProgramDerivedAddress},\n * or a {@link TransactionSigner}. This function extracts the underlying address from\n * any of these types.\n *\n * @typeParam T - The address type, defaults to `string`.\n *\n * @param inputName - The name of the instruction input, used in error messages.\n * @param value - The resolved account value to extract the address from.\n * @returns The extracted address.\n *\n * @throws Throws a {@link SolanaError} if the value is null or undefined.\n *\n * @example\n * ```ts\n * const address = getAddressFromResolvedInstructionAccount('mint', resolvedMint);\n * ```\n */\nexport function getAddressFromResolvedInstructionAccount<T extends string = string>(\n    inputName: string,\n    value: ResolvedInstructionAccount<T>['value'] | undefined,\n): Address<T> {\n    const nonNullValue = getNonNullResolvedInstructionInput(inputName, value);\n    if (typeof value === 'object' && 'address' in nonNullValue) {\n        return nonNullValue.address;\n    }\n    if (Array.isArray(nonNullValue)) {\n        return nonNullValue[0] as Address<T>;\n    }\n    return nonNullValue as Address<T>;\n}\n\n/**\n * Extracts a {@link ProgramDerivedAddress} from a resolved instruction account.\n *\n * This function validates that the resolved account is a PDA and returns it.\n * Use this when you need access to both the address and the bump seed of a PDA.\n *\n * @typeParam T - The address type, defaults to `string`.\n *\n * @param inputName - The name of the instruction input, used in error messages.\n * @param value - The resolved account value expected to be a PDA.\n * @returns The program-derived address.\n *\n * @throws Throws a {@link SolanaError} if the value is not a {@link ProgramDerivedAddress}.\n *\n * @example\n * ```ts\n * const pda = getResolvedInstructionAccountAsProgramDerivedAddress('metadata', resolvedMetadata);\n * const [address, bump] = pda;\n * ```\n */\nexport function getResolvedInstructionAccountAsProgramDerivedAddress<T extends string = string>(\n    inputName: string,\n    value: ResolvedInstructionAccount<T>['value'] | undefined,\n): ProgramDerivedAddress<T> {\n    if (!isProgramDerivedAddress(value)) {\n        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNEXPECTED_RESOLVED_INSTRUCTION_INPUT_TYPE, {\n            expectedType: 'ProgramDerivedAddress',\n            inputName,\n        });\n    }\n    return value;\n}\n\n/**\n * Extracts a {@link TransactionSigner} from a resolved instruction account.\n *\n * This function validates that the resolved account is a transaction signer and returns it.\n * Use this when you need the resolved account to be a signer.\n *\n * @typeParam T - The address type, defaults to `string`.\n *\n * @param inputName - The name of the instruction input, used in error messages.\n * @param value - The resolved account value expected to be a signer.\n * @returns The transaction signer.\n *\n * @throws Throws a {@link SolanaError} if the value is not a {@link TransactionSigner}.\n *\n * @example\n * ```ts\n * const signer = getResolvedInstructionAccountAsTransactionSigner('authority', resolvedAuthority);\n * ```\n */\nexport function getResolvedInstructionAccountAsTransactionSigner<T extends string = string>(\n    inputName: string,\n    value: ResolvedInstructionAccount<T>['value'] | undefined,\n): TransactionSigner<T> {\n    if (!isResolvedInstructionAccountSigner(value)) {\n        throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNEXPECTED_RESOLVED_INSTRUCTION_INPUT_TYPE, {\n            expectedType: 'TransactionSigner',\n            inputName,\n        });\n    }\n    return value;\n}\n\n/**\n * Represents a resolved account input for an instruction.\n *\n * During instruction building, account inputs are resolved to this type which\n * captures both the account value and whether it should be marked as writable.\n * The value can be an {@link Address}, a {@link ProgramDerivedAddress}, a\n * {@link TransactionSigner}, or `null` for optional accounts.\n *\n * @typeParam TAddress - The address type, defaults to `string`.\n * @typeParam TValue - The type of the resolved value.\n *\n * @example\n * ```ts\n * const mintAccount: ResolvedInstructionAccount = {\n *   value: mintAddress,\n *   isWritable: true,\n * };\n * ```\n */\nexport type ResolvedInstructionAccount<\n    TAddress extends string = string,\n    TValue extends Address<TAddress> | ProgramDerivedAddress<TAddress> | TransactionSigner<TAddress> | null =\n        | Address<TAddress>\n        | ProgramDerivedAddress<TAddress>\n        | TransactionSigner<TAddress>\n        | null,\n> = {\n    isWritable: boolean;\n    value: TValue;\n};\n\n/**\n * Creates a factory function that converts resolved instruction accounts to account metas.\n *\n * The factory handles the conversion of {@link ResolvedInstructionAccount} objects into\n * {@link AccountMeta} or {@link AccountSignerMeta} objects suitable for building instructions.\n * It also determines how to handle optional accounts based on the provided strategy.\n *\n * @param programAddress - The program address, used when optional accounts use the `programId` strategy.\n * @param optionalAccountStrategy - How to handle null account values:\n *   - `'omitted'`: Optional accounts are excluded from the instruction entirely.\n *   - `'programId'`: Optional accounts are replaced with the program address as a read-only account.\n * @returns A factory function that converts a resolved account to an account meta.\n *\n * @example\n * ```ts\n * const toAccountMeta = getAccountMetaFactory(programAddress, 'programId');\n * const mintMeta = toAccountMeta('mint', resolvedMint);\n * ```\n */\nexport function getAccountMetaFactory(programAddress: Address, optionalAccountStrategy: 'omitted' | 'programId') {\n    return (inputName: string, account: ResolvedInstructionAccount): AccountMeta | AccountSignerMeta | undefined => {\n        if (!account.value) {\n            if (optionalAccountStrategy === 'omitted') return;\n            return Object.freeze({ address: programAddress, role: AccountRole.READONLY });\n        }\n\n        const writableRole = account.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY;\n        const isSigner = isResolvedInstructionAccountSigner(account.value);\n        return Object.freeze({\n            address: getAddressFromResolvedInstructionAccount(inputName, account.value),\n            role: isSigner ? upgradeRoleToSigner(writableRole) : writableRole,\n            ...(isSigner ? { signer: account.value } : {}),\n        });\n    };\n}\n\nfunction isResolvedInstructionAccountSigner(value: unknown): value is TransactionSigner {\n    return (\n        !!value &&\n        typeof value === 'object' &&\n        'address' in value &&\n        typeof value.address === 'string' &&\n        isTransactionSigner(value as { address: Address })\n    );\n}\n","import {\n    type Account,\n    assertAccountExists,\n    assertAccountsExist,\n    decodeAccount,\n    type FetchAccountConfig,\n    type FetchAccountsConfig,\n    fetchEncodedAccount,\n    fetchEncodedAccounts,\n    type MaybeAccount,\n} from '@solana/accounts';\nimport type { Address } from '@solana/addresses';\nimport type { Codec } from '@solana/codecs-core';\nimport type { ClientWithRpc } from '@solana/plugin-interfaces';\nimport type { GetAccountInfoApi, GetMultipleAccountsApi } from '@solana/rpc-api';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype AnyObjectCodec = Codec<any, object>;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype InferTFrom<T> = T extends Codec<infer TFrom, any> ? TFrom : never;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype InferTTo<T> = T extends Codec<any, infer TTo> ? TTo : never;\n\n/**\n * Methods that allow a codec to fetch and decode accounts directly.\n *\n * These methods are added to codec objects via {@link addSelfFetchFunctions},\n * enabling a fluent API where you can call `.fetch()` directly on a codec\n * to retrieve and decode accounts in one step.\n *\n * @typeParam TFrom - The type that the codec encodes from.\n * @typeParam TTo - The type that the codec decodes to.\n *\n * @example\n * Fetching a single account and asserting it exists.\n * ```ts\n * const account = await myAccountCodec.fetch(address);\n * // account.data is of type TTo.\n * ```\n *\n * @example\n * Fetching a single account that may not exist.\n * ```ts\n * const maybeAccount = await myAccountCodec.fetchMaybe(address);\n * if (maybeAccount.exists) {\n *     // maybeAccount.data is of type TTo.\n * }\n * ```\n *\n * @example\n * Fetching multiple accounts at once.\n * ```ts\n * const accounts = await myAccountCodec.fetchAll([addressA, addressB]);\n * // All accounts exist.\n * ```\n *\n * @see {@link addSelfFetchFunctions}\n */\nexport type SelfFetchFunctions<TFrom extends object, TTo extends TFrom> = {\n    /** Fetches and decodes a single account, throwing if it does not exist. */\n    readonly fetch: <TAddress extends string>(\n        address: Address<TAddress>,\n        config?: FetchAccountConfig,\n    ) => Promise<Account<TTo, TAddress>>;\n    /** Fetches and decodes multiple accounts, throwing if any do not exist. */\n    readonly fetchAll: (addresses: Address[], config?: FetchAccountsConfig) => Promise<Account<TTo>[]>;\n    /** Fetches and decodes multiple accounts, returning {@link MaybeAccount} for each. */\n    readonly fetchAllMaybe: (addresses: Address[], config?: FetchAccountsConfig) => Promise<MaybeAccount<TTo>[]>;\n    /** Fetches and decodes a single account, returning a {@link MaybeAccount}. */\n    readonly fetchMaybe: <TAddress extends string>(\n        address: Address<TAddress>,\n        config?: FetchAccountConfig,\n    ) => Promise<MaybeAccount<TTo, TAddress>>;\n};\n\n/**\n * Adds self-fetching methods to a codec for retrieving and decoding accounts.\n *\n * This function augments the provided codec with methods that allow it to fetch\n * accounts from the network and decode them in one step. It enables a fluent API\n * where you can call methods like `.fetch()` directly on the codec.\n *\n * @typeParam TFrom - The type that the codec encodes from.\n * @typeParam TTo - The type that the codec decodes to.\n * @typeParam TCodec - The codec type being augmented.\n *\n * @param client - A client that provides RPC access for fetching accounts.\n * @param codec - The codec to augment with self-fetch methods.\n * @returns The codec augmented with {@link SelfFetchFunctions} methods.\n *\n * @example\n * Adding self-fetch functions to an account codec.\n * ```ts\n * import { addSelfFetchFunctions } from '@solana/program-client-core';\n *\n * const myAccountCodec = addSelfFetchFunctions(client, getMyAccountCodec());\n *\n * // Fetch and decode an account in one step.\n * const account = await myAccountCodec.fetch(accountAddress);\n * ```\n *\n * @example\n * Handling accounts that may not exist.\n * ```ts\n * const myAccountCodec = addSelfFetchFunctions(client, getMyAccountCodec());\n *\n * const maybeAccount = await myAccountCodec.fetchMaybe(accountAddress);\n * if (maybeAccount.exists) {\n *     console.log('Account data:', maybeAccount.data);\n * } else {\n *     console.log(`Account ${maybeAccount.address} does not exist`);\n * }\n * ```\n *\n * @example\n * Fetching multiple accounts at once.\n * ```ts\n * const myAccountCodec = addSelfFetchFunctions(client, getMyAccountCodec());\n *\n * // Throws if any account does not exist.\n * const accounts = await myAccountCodec.fetchAll([addressA, addressB, addressC]);\n *\n * // Returns MaybeAccount for each, allowing some to not exist.\n * const maybeAccounts = await myAccountCodec.fetchAllMaybe([addressA, addressB]);\n * ```\n *\n * @see {@link SelfFetchFunctions}\n */\nexport function addSelfFetchFunctions<TCodec extends AnyObjectCodec>(\n    client: ClientWithRpc<GetAccountInfoApi & GetMultipleAccountsApi>,\n    codec: TCodec,\n): SelfFetchFunctions<InferTFrom<TCodec>, InferTTo<TCodec>> & TCodec {\n    type Functions = SelfFetchFunctions<InferTFrom<TCodec>, InferTTo<TCodec>>;\n    type InferredCodec = Codec<InferTFrom<TCodec>, InferTTo<TCodec>>;\n    const fetchMaybe: Functions['fetchMaybe'] = async (address, config?) => {\n        const maybeAccount = await fetchEncodedAccount(client.rpc, address, config);\n        return decodeAccount(maybeAccount, codec as InferredCodec);\n    };\n    const fetchAllMaybe: Functions['fetchAllMaybe'] = async (addresses, config?) => {\n        const maybeAccounts = await fetchEncodedAccounts(client.rpc, addresses, config);\n        return maybeAccounts.map(maybeAccount => decodeAccount(maybeAccount, codec as InferredCodec));\n    };\n    const fetch: Functions['fetch'] = async (address, config?) => {\n        const maybeAccount = await fetchMaybe(address, config);\n        assertAccountExists(maybeAccount);\n        return maybeAccount;\n    };\n    const fetchAll: Functions['fetchAll'] = async (addresses, config?) => {\n        const maybeAccounts = await fetchAllMaybe(addresses, config);\n        assertAccountsExist(maybeAccounts);\n        return maybeAccounts;\n    };\n\n    const out = { ...codec, fetch, fetchAll, fetchAllMaybe, fetchMaybe };\n    return Object.freeze<typeof out>(out);\n}\n","import type { InstructionPlan } from '@solana/instruction-plans';\nimport type { Instruction } from '@solana/instructions';\nimport type { ClientWithTransactionPlanning, ClientWithTransactionSending } from '@solana/plugin-interfaces';\n\ntype PlanTransaction = ClientWithTransactionPlanning['planTransaction'];\ntype PlanTransactions = ClientWithTransactionPlanning['planTransactions'];\ntype SendTransaction = ClientWithTransactionSending['sendTransaction'];\ntype SendTransactions = ClientWithTransactionSending['sendTransactions'];\n\n/**\n * Methods that allow an instruction or instruction plan to plan and send itself.\n *\n * These methods are added to instruction or instruction plan objects via\n * {@link addSelfPlanAndSendFunctions}, enabling a fluent API where you can call\n * `.sendTransaction()` directly on an instruction without passing it to a separate function.\n *\n * @example\n * Sending a transfer instruction directly.\n * ```ts\n * const result = await getTransferInstruction({ source, destination, amount }).sendTransaction();\n * ```\n *\n * @example\n * Planning multiple transactions from an instruction plan.\n * ```ts\n * const plan = await getComplexInstructionPlan(/* ... *\\/).planTransactions();\n * ```\n *\n * @see {@link addSelfPlanAndSendFunctions}\n */\nexport type SelfPlanAndSendFunctions = {\n    /** Plans a single transaction. */\n    planTransaction: (config?: Parameters<PlanTransaction>[1]) => ReturnType<PlanTransaction>;\n    /** Plans one or more transactions. */\n    planTransactions: (config?: Parameters<PlanTransactions>[1]) => ReturnType<PlanTransactions>;\n    /** Sends a single transaction. */\n    sendTransaction: (config?: Parameters<SendTransaction>[1]) => ReturnType<SendTransaction>;\n    /** Sends one or more transactions. */\n    sendTransactions: (config?: Parameters<SendTransactions>[1]) => ReturnType<SendTransactions>;\n};\n\n/**\n * Adds self-planning and self-sending methods to an instruction or instruction plan.\n *\n * This function augments the provided instruction or instruction plan with methods\n * that allow it to plan and send itself using the provided client. It enables a fluent API\n * where you can call methods like `.sendTransaction()` directly on the instruction.\n *\n * The function supports both synchronous inputs (instructions, instruction plans) and\n * promise-like inputs, making it suitable for use with async instruction builders.\n *\n * @typeParam TItem - The type of the instruction, instruction plan, or a promise resolving to one.\n *\n * @param client - A client that provides transaction planning and sending capabilities.\n * @param input - The instruction, instruction plan, or promise to augment with self-plan/send methods.\n * @returns The input augmented with {@link SelfPlanAndSendFunctions} methods.\n *\n * @example\n * Adding self-plan and send to a transfer instruction.\n * ```ts\n * import { addSelfPlanAndSendFunctions } from '@solana/program-client-core';\n *\n * const transferInstruction = addSelfPlanAndSendFunctions(\n *     client,\n *     getTransferInstruction({ payer, source, destination, amount })\n * );\n *\n * // Now you can send directly from the instruction.\n * const result = await transferInstruction.sendTransaction();\n * ```\n *\n * @example\n * Using with an async instruction builder.\n * ```ts\n * const asyncInstruction = addSelfPlanAndSendFunctions(\n *     client,\n *     fetchAndBuildInstruction(/* ... *\\/)\n * );\n *\n * // The promise is augmented with self-plan/send methods.\n * const result = await asyncInstruction.sendTransaction();\n * ```\n *\n * @see {@link SelfPlanAndSendFunctions}\n */\nexport function addSelfPlanAndSendFunctions<\n    TItem extends Instruction | InstructionPlan | PromiseLike<Instruction> | PromiseLike<InstructionPlan>,\n>(\n    client: ClientWithTransactionPlanning & ClientWithTransactionSending,\n    input: TItem,\n): SelfPlanAndSendFunctions & TItem {\n    if (isPromiseLike(input)) {\n        const newInput = input as SelfPlanAndSendFunctions & TItem;\n        newInput.planTransaction = async config => await client.planTransaction(await input, config);\n        newInput.planTransactions = async config => await client.planTransactions(await input, config);\n        newInput.sendTransaction = async config => await client.sendTransaction(await input, config);\n        newInput.sendTransactions = async config => await client.sendTransactions(await input, config);\n        return newInput;\n    }\n\n    return Object.freeze(<SelfPlanAndSendFunctions & (Instruction | InstructionPlan)>{\n        ...input,\n        planTransaction: config => client.planTransaction(input, config),\n        planTransactions: config => client.planTransactions(input, config),\n        sendTransaction: config => client.sendTransaction(input, config),\n        sendTransactions: config => client.sendTransactions(input, config),\n    }) as unknown as SelfPlanAndSendFunctions & TItem;\n}\n\nfunction isPromiseLike(\n    item: Instruction | InstructionPlan | PromiseLike<Instruction> | PromiseLike<InstructionPlan>,\n): item is PromiseLike<Instruction> | PromiseLike<InstructionPlan> {\n    return (\n        !!item &&\n        (typeof item === 'object' || typeof item === 'function') &&\n        typeof (item as PromiseLike<unknown>).then === 'function'\n    );\n}\n"]}

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This package contains types and utilities for building Solana program clients.
+ * This is mainly used by the JavaScript Codama renderer to generate
+ * Kit-compatible program clients.
+ *
+ * @packageDocumentation
+ */
+export * from './instruction-input-resolution';
+export * from './instructions';
+export * from './self-fetch-functions';
+export * from './self-plan-and-send-functions';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,gCAAgC,CAAC"}

package/dist/types/instruction-input-resolution.d.ts

@@ -0,0 +1,133 @@
+import { type Address, type ProgramDerivedAddress } from '@solana/addresses';
+import { type AccountMeta } from '@solana/instructions';
+import { type AccountSignerMeta, type TransactionSigner } from '@solana/signers';
+/**
+ * Ensures a resolved instruction input is not null or undefined.
+ *
+ * This function is used during instruction resolution to validate that
+ * required inputs have been properly resolved to a non-null value.
+ *
+ * @typeParam T - The expected type of the resolved input value.
+ *
+ * @param inputName - The name of the instruction input, used in error messages.
+ * @param value - The resolved value to validate.
+ * @returns The validated non-null value.
+ *
+ * @throws Throws a {@link SolanaError} if the value is null or undefined.
+ *
+ * @example
+ * ```ts
+ * const resolvedAuthority = getNonNullResolvedInstructionInput(
+ *   'authority',
+ *   maybeAuthority
+ * );
+ * // resolvedAuthority is guaranteed to be non-null here.
+ * ```
+ */
+export declare function getNonNullResolvedInstructionInput<T>(inputName: string, value: T | null | undefined): T;
+/**
+ * Extracts the address from a resolved instruction account.
+ *
+ * A resolved instruction account can be an {@link Address}, a {@link ProgramDerivedAddress},
+ * or a {@link TransactionSigner}. This function extracts the underlying address from
+ * any of these types.
+ *
+ * @typeParam T - The address type, defaults to `string`.
+ *
+ * @param inputName - The name of the instruction input, used in error messages.
+ * @param value - The resolved account value to extract the address from.
+ * @returns The extracted address.
+ *
+ * @throws Throws a {@link SolanaError} if the value is null or undefined.
+ *
+ * @example
+ * ```ts
+ * const address = getAddressFromResolvedInstructionAccount('mint', resolvedMint);
+ * ```
+ */
+export declare function getAddressFromResolvedInstructionAccount<T extends string = string>(inputName: string, value: ResolvedInstructionAccount<T>['value'] | undefined): Address<T>;
+/**
+ * Extracts a {@link ProgramDerivedAddress} from a resolved instruction account.
+ *
+ * This function validates that the resolved account is a PDA and returns it.
+ * Use this when you need access to both the address and the bump seed of a PDA.
+ *
+ * @typeParam T - The address type, defaults to `string`.
+ *
+ * @param inputName - The name of the instruction input, used in error messages.
+ * @param value - The resolved account value expected to be a PDA.
+ * @returns The program-derived address.
+ *
+ * @throws Throws a {@link SolanaError} if the value is not a {@link ProgramDerivedAddress}.
+ *
+ * @example
+ * ```ts
+ * const pda = getResolvedInstructionAccountAsProgramDerivedAddress('metadata', resolvedMetadata);
+ * const [address, bump] = pda;
+ * ```
+ */
+export declare function getResolvedInstructionAccountAsProgramDerivedAddress<T extends string = string>(inputName: string, value: ResolvedInstructionAccount<T>['value'] | undefined): ProgramDerivedAddress<T>;
+/**
+ * Extracts a {@link TransactionSigner} from a resolved instruction account.
+ *
+ * This function validates that the resolved account is a transaction signer and returns it.
+ * Use this when you need the resolved account to be a signer.
+ *
+ * @typeParam T - The address type, defaults to `string`.
+ *
+ * @param inputName - The name of the instruction input, used in error messages.
+ * @param value - The resolved account value expected to be a signer.
+ * @returns The transaction signer.
+ *
+ * @throws Throws a {@link SolanaError} if the value is not a {@link TransactionSigner}.
+ *
+ * @example
+ * ```ts
+ * const signer = getResolvedInstructionAccountAsTransactionSigner('authority', resolvedAuthority);
+ * ```
+ */
+export declare function getResolvedInstructionAccountAsTransactionSigner<T extends string = string>(inputName: string, value: ResolvedInstructionAccount<T>['value'] | undefined): TransactionSigner<T>;
+/**
+ * Represents a resolved account input for an instruction.
+ *
+ * During instruction building, account inputs are resolved to this type which
+ * captures both the account value and whether it should be marked as writable.
+ * The value can be an {@link Address}, a {@link ProgramDerivedAddress}, a
+ * {@link TransactionSigner}, or `null` for optional accounts.
+ *
+ * @typeParam TAddress - The address type, defaults to `string`.
+ * @typeParam TValue - The type of the resolved value.
+ *
+ * @example
+ * ```ts
+ * const mintAccount: ResolvedInstructionAccount = {
+ *   value: mintAddress,
+ *   isWritable: true,
+ * };
+ * ```
+ */
+export type ResolvedInstructionAccount<TAddress extends string = string, TValue extends Address<TAddress> | ProgramDerivedAddress<TAddress> | TransactionSigner<TAddress> | null = Address<TAddress> | ProgramDerivedAddress<TAddress> | TransactionSigner<TAddress> | null> = {
+    isWritable: boolean;
+    value: TValue;
+};
+/**
+ * Creates a factory function that converts resolved instruction accounts to account metas.
+ *
+ * The factory handles the conversion of {@link ResolvedInstructionAccount} objects into
+ * {@link AccountMeta} or {@link AccountSignerMeta} objects suitable for building instructions.
+ * It also determines how to handle optional accounts based on the provided strategy.
+ *
+ * @param programAddress - The program address, used when optional accounts use the `programId` strategy.
+ * @param optionalAccountStrategy - How to handle null account values:
+ *   - `'omitted'`: Optional accounts are excluded from the instruction entirely.
+ *   - `'programId'`: Optional accounts are replaced with the program address as a read-only account.
+ * @returns A factory function that converts a resolved account to an account meta.
+ *
+ * @example
+ * ```ts
+ * const toAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+ * const mintMeta = toAccountMeta('mint', resolvedMint);
+ * ```
+ */
+export declare function getAccountMetaFactory(programAddress: Address, optionalAccountStrategy: 'omitted' | 'programId'): (inputName: string, account: ResolvedInstructionAccount) => AccountMeta | AccountSignerMeta | undefined;
+//# sourceMappingURL=instruction-input-resolution.d.ts.map

package/dist/types/instruction-input-resolution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instruction-input-resolution.d.ts","sourceRoot":"","sources":["../../src/instruction-input-resolution.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAA2B,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAMtG,OAAO,EAAE,KAAK,WAAW,EAAoC,MAAM,sBAAsB,CAAC;AAC1F,OAAO,EAAE,KAAK,iBAAiB,EAAuB,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEtG;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kCAAkC,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,GAAG,CAAC,CAOvG;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,wCAAwC,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAC9E,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,0BAA0B,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,SAAS,GAC1D,OAAO,CAAC,CAAC,CAAC,CASZ;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oDAAoD,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAC1F,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,0BAA0B,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,SAAS,GAC1D,qBAAqB,CAAC,CAAC,CAAC,CAQ1B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gDAAgD,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EACtF,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,0BAA0B,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,SAAS,GAC1D,iBAAiB,CAAC,CAAC,CAAC,CAQtB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,0BAA0B,CAClC,QAAQ,SAAS,MAAM,GAAG,MAAM,EAChC,MAAM,SAAS,OAAO,CAAC,QAAQ,CAAC,GAAG,qBAAqB,CAAC,QAAQ,CAAC,GAAG,iBAAiB,CAAC,QAAQ,CAAC,GAAG,IAAI,GACjG,OAAO,CAAC,QAAQ,CAAC,GACjB,qBAAqB,CAAC,QAAQ,CAAC,GAC/B,iBAAiB,CAAC,QAAQ,CAAC,GAC3B,IAAI,IACV;IACA,UAAU,EAAE,OAAO,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,OAAO,EAAE,uBAAuB,EAAE,SAAS,GAAG,WAAW,IACnG,WAAW,MAAM,EAAE,SAAS,0BAA0B,KAAG,WAAW,GAAG,iBAAiB,GAAG,SAAS,CAc/G"}

package/dist/types/instructions.d.ts

@@ -0,0 +1,12 @@
+/**
+ * An instruction that tracks how many bytes it adds or removes from on-chain accounts.
+ *
+ * The `byteDelta` indicates the net change in account storage size. A positive value
+ * means bytes are being allocated, while a negative value means bytes are being freed.
+ * This is useful for calculating how much balance a storage payer must have for a
+ * transaction to succeed.
+ */
+export type InstructionWithByteDelta = {
+    byteDelta: number;
+};
+//# sourceMappingURL=instructions.d.ts.map

package/dist/types/instructions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instructions.d.ts","sourceRoot":"","sources":["../../src/instructions.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACnC,SAAS,EAAE,MAAM,CAAC;CACrB,CAAC"}

package/dist/types/self-fetch-functions.d.ts

@@ -0,0 +1,109 @@
+import { type Account, type FetchAccountConfig, type FetchAccountsConfig, type MaybeAccount } from '@solana/accounts';
+import type { Address } from '@solana/addresses';
+import type { Codec } from '@solana/codecs-core';
+import type { ClientWithRpc } from '@solana/plugin-interfaces';
+import type { GetAccountInfoApi, GetMultipleAccountsApi } from '@solana/rpc-api';
+type AnyObjectCodec = Codec<any, object>;
+type InferTFrom<T> = T extends Codec<infer TFrom, any> ? TFrom : never;
+type InferTTo<T> = T extends Codec<any, infer TTo> ? TTo : never;
+/**
+ * Methods that allow a codec to fetch and decode accounts directly.
+ *
+ * These methods are added to codec objects via {@link addSelfFetchFunctions},
+ * enabling a fluent API where you can call `.fetch()` directly on a codec
+ * to retrieve and decode accounts in one step.
+ *
+ * @typeParam TFrom - The type that the codec encodes from.
+ * @typeParam TTo - The type that the codec decodes to.
+ *
+ * @example
+ * Fetching a single account and asserting it exists.
+ * ```ts
+ * const account = await myAccountCodec.fetch(address);
+ * // account.data is of type TTo.
+ * ```
+ *
+ * @example
+ * Fetching a single account that may not exist.
+ * ```ts
+ * const maybeAccount = await myAccountCodec.fetchMaybe(address);
+ * if (maybeAccount.exists) {
+ *     // maybeAccount.data is of type TTo.
+ * }
+ * ```
+ *
+ * @example
+ * Fetching multiple accounts at once.
+ * ```ts
+ * const accounts = await myAccountCodec.fetchAll([addressA, addressB]);
+ * // All accounts exist.
+ * ```
+ *
+ * @see {@link addSelfFetchFunctions}
+ */
+export type SelfFetchFunctions<TFrom extends object, TTo extends TFrom> = {
+    /** Fetches and decodes a single account, throwing if it does not exist. */
+    readonly fetch: <TAddress extends string>(address: Address<TAddress>, config?: FetchAccountConfig) => Promise<Account<TTo, TAddress>>;
+    /** Fetches and decodes multiple accounts, throwing if any do not exist. */
+    readonly fetchAll: (addresses: Address[], config?: FetchAccountsConfig) => Promise<Account<TTo>[]>;
+    /** Fetches and decodes multiple accounts, returning {@link MaybeAccount} for each. */
+    readonly fetchAllMaybe: (addresses: Address[], config?: FetchAccountsConfig) => Promise<MaybeAccount<TTo>[]>;
+    /** Fetches and decodes a single account, returning a {@link MaybeAccount}. */
+    readonly fetchMaybe: <TAddress extends string>(address: Address<TAddress>, config?: FetchAccountConfig) => Promise<MaybeAccount<TTo, TAddress>>;
+};
+/**
+ * Adds self-fetching methods to a codec for retrieving and decoding accounts.
+ *
+ * This function augments the provided codec with methods that allow it to fetch
+ * accounts from the network and decode them in one step. It enables a fluent API
+ * where you can call methods like `.fetch()` directly on the codec.
+ *
+ * @typeParam TFrom - The type that the codec encodes from.
+ * @typeParam TTo - The type that the codec decodes to.
+ * @typeParam TCodec - The codec type being augmented.
+ *
+ * @param client - A client that provides RPC access for fetching accounts.
+ * @param codec - The codec to augment with self-fetch methods.
+ * @returns The codec augmented with {@link SelfFetchFunctions} methods.
+ *
+ * @example
+ * Adding self-fetch functions to an account codec.
+ * ```ts
+ * import { addSelfFetchFunctions } from '@solana/program-client-core';
+ *
+ * const myAccountCodec = addSelfFetchFunctions(client, getMyAccountCodec());
+ *
+ * // Fetch and decode an account in one step.
+ * const account = await myAccountCodec.fetch(accountAddress);
+ * ```
+ *
+ * @example
+ * Handling accounts that may not exist.
+ * ```ts
+ * const myAccountCodec = addSelfFetchFunctions(client, getMyAccountCodec());
+ *
+ * const maybeAccount = await myAccountCodec.fetchMaybe(accountAddress);
+ * if (maybeAccount.exists) {
+ *     console.log('Account data:', maybeAccount.data);
+ * } else {
+ *     console.log(`Account ${maybeAccount.address} does not exist`);
+ * }
+ * ```
+ *
+ * @example
+ * Fetching multiple accounts at once.
+ * ```ts
+ * const myAccountCodec = addSelfFetchFunctions(client, getMyAccountCodec());
+ *
+ * // Throws if any account does not exist.
+ * const accounts = await myAccountCodec.fetchAll([addressA, addressB, addressC]);
+ *
+ * // Returns MaybeAccount for each, allowing some to not exist.
+ * const maybeAccounts = await myAccountCodec.fetchAllMaybe([addressA, addressB]);
+ * ```
+ *
+ * @see {@link SelfFetchFunctions}
+ */
+export declare function addSelfFetchFunctions<TCodec extends AnyObjectCodec>(client: ClientWithRpc<GetAccountInfoApi & GetMultipleAccountsApi>, codec: TCodec): SelfFetchFunctions<InferTFrom<TCodec>, InferTTo<TCodec>> & TCodec;
+export {};
+//# sourceMappingURL=self-fetch-functions.d.ts.map

package/dist/types/self-fetch-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"self-fetch-functions.d.ts","sourceRoot":"","sources":["../../src/self-fetch-functions.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,OAAO,EAIZ,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EAGxB,KAAK,YAAY,EACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAGjF,KAAK,cAAc,GAAG,KAAK,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;AAEzC,KAAK,UAAU,CAAC,CAAC,IAAI,CAAC,SAAS,KAAK,CAAC,MAAM,KAAK,EAAE,GAAG,CAAC,GAAG,KAAK,GAAG,KAAK,CAAC;AAEvE,KAAK,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,GAAG,GAAG,KAAK,CAAC;AAEjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,MAAM,kBAAkB,CAAC,KAAK,SAAS,MAAM,EAAE,GAAG,SAAS,KAAK,IAAI;IACtE,2EAA2E;IAC3E,QAAQ,CAAC,KAAK,EAAE,CAAC,QAAQ,SAAS,MAAM,EACpC,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,EAC1B,MAAM,CAAC,EAAE,kBAAkB,KAC1B,OAAO,CAAC,OAAO,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC;IACrC,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,CAAC,SAAS,EAAE,OAAO,EAAE,EAAE,MAAM,CAAC,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACnG,sFAAsF;IACtF,QAAQ,CAAC,aAAa,EAAE,CAAC,SAAS,EAAE,OAAO,EAAE,EAAE,MAAM,CAAC,EAAE,mBAAmB,KAAK,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC7G,8EAA8E;IAC9E,QAAQ,CAAC,UAAU,EAAE,CAAC,QAAQ,SAAS,MAAM,EACzC,OAAO,EAAE,OAAO,CAAC,QAAQ,CAAC,EAC1B,MAAM,CAAC,EAAE,kBAAkB,KAC1B,OAAO,CAAC,YAAY,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC;CAC7C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,SAAS,cAAc,EAC/D,MAAM,EAAE,aAAa,CAAC,iBAAiB,GAAG,sBAAsB,CAAC,EACjE,KAAK,EAAE,MAAM,GACd,kBAAkB,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAwBnE"}