@codama/dynamic-instructions 0.2.0

package/dist/index.browser.mjs

@@ -0,0 +1,741 @@
+import { toAddress, resolveInstructionAccountAddress, isAddressConvertible, createDefaultValueEncoderVisitor, DEFAULT_VALUE_ENCODER_SUPPORTED_NODE_KINDS, createCodecInputTransformer, OPTIONAL_NODE_KINDS, isPublicKeyLike } from '@codama/dynamic-address-resolution';
+export { isPublicKeyLike, toAddress } from '@codama/dynamic-address-resolution';
+import { CodamaError, CODAMA_ERROR__UNEXPECTED_NODE_KIND, CODAMA_ERROR__DYNAMIC_CLIENT__ARGUMENT_MISSING, CODAMA_ERROR__DYNAMIC_CLIENT__INVALID_ARGUMENT_INPUT, CODAMA_ERROR__DYNAMIC_CLIENT__UNEXPECTED_ADDRESS_TYPE, CODAMA_ERROR__DYNAMIC_CLIENT__DEFAULT_VALUE_MISSING, CODAMA_ERROR__DYNAMIC_CLIENT__FAILED_TO_ENCODE_ARGUMENT, CODAMA_ERROR__DYNAMIC_CLIENT__FAILED_TO_VALIDATE_INPUT, CODAMA_ERROR__DYNAMIC_CLIENT__ACCOUNT_MISSING, CODAMA_ERROR__DYNAMIC_CLIENT__INVALID_ACCOUNT_ADDRESS, CODAMA_ERROR__DYNAMIC_CLIENT__FAILED_TO_EXECUTE_RESOLVER } from '@codama/errors';
+import { AccountRole } from '@solana/instructions';
+import { isNode, visitOrElse, camelCase } from 'codama';
+import { assert, StructError, object, define, tuple, intersection, string, number, boolean, array, size } from 'superstruct';
+import { address, isAddress } from '@solana/addresses';
+import { mergeBytes, getUtf8Encoder } from '@solana/codecs';
+import { getNodeCodec } from '@codama/dynamic-codecs';
+
+// src/accounts/create-account-meta.ts
+
+// src/shared/util.ts
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype;
+}
+function getMaybeNodeKind(node) {
+  if (!isObjectRecord(node)) return null;
+  return node.kind ?? null;
+}
+function formatValueType(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return `array (length ${value.length})`;
+  if (value instanceof Uint8Array) return `Uint8Array (length ${value.length})`;
+  if (typeof value === "object") return "object";
+  return typeof value;
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value, (_key, v) => typeof v === "bigint" ? String(v) : v);
+  } catch {
+    return `non-serializable ${formatValueType(value)}`;
+  }
+}
+
+// src/accounts/create-account-meta.ts
+async function createAccountMeta(root, ixNode, argumentsInput, accountsInput, signers = [], resolversInput) {
+  const programAddress = toAddress(root.program.publicKey);
+  const resolvedAccounts = await Promise.all(
+    ixNode.accounts.map(async (ixAccountNode) => {
+      const finalAddress = await resolveInstructionAccountAddress({
+        accountsInput,
+        argumentsInput,
+        ixAccountNode,
+        ixNode,
+        resolversInput,
+        root
+      });
+      const accountAddressInput = accountsInput?.[ixAccountNode.name];
+      const isAccountProvided = accountAddressInput !== void 0 && accountAddressInput !== null;
+      const role = ixAccountNode.isOptional && !isAccountProvided && ixNode.optionalAccountStrategy === "programId" && finalAddress === programAddress ? getReadonlyAccountRole(ixAccountNode, signers) : getAccountRole(ixAccountNode, signers);
+      return {
+        address: finalAddress,
+        optional: Boolean(ixAccountNode.isOptional),
+        role
+      };
+    })
+  );
+  const accountMetas = resolvedAccounts.filter((acc) => acc.address !== null).map((acc) => ({
+    address: acc.address,
+    role: acc.role
+  }));
+  for (const remainingNode of ixNode.remainingAccounts ?? []) {
+    if (!isNode(remainingNode.value, "argumentValueNode")) {
+      throw new CodamaError(CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+        expectedKinds: ["argumentValueNode"],
+        kind: remainingNode.value.kind,
+        node: remainingNode.value
+      });
+    }
+    const addresses = argumentsInput?.[remainingNode.value.name];
+    if (addresses === void 0) {
+      if (!remainingNode.isOptional) {
+        throw new CodamaError(CODAMA_ERROR__DYNAMIC_CLIENT__ARGUMENT_MISSING, {
+          argumentName: remainingNode.value.name,
+          instructionName: ixNode.name
+        });
+      }
+      continue;
+    }
+    if (!Array.isArray(addresses)) {
+      throw new CodamaError(CODAMA_ERROR__DYNAMIC_CLIENT__INVALID_ARGUMENT_INPUT, {
+        argumentName: remainingNode.value.name,
+        expectedType: "Address[]",
+        value: safeStringify(addresses)
+      });
+    }
+    const role = getRemainingAccountRole(remainingNode.isSigner, remainingNode.isWritable);
+    for (let i = 0; i < addresses.length; i++) {
+      const addr = addresses[i];
+      if (!isAddressConvertible(addr)) {
+        throw new CodamaError(CODAMA_ERROR__DYNAMIC_CLIENT__UNEXPECTED_ADDRESS_TYPE, {
+          accountName: `${remainingNode.value.name}[${i}]`,
+          actualType: formatValueType(addr),
+          expectedType: "Address | PublicKey"
+        });
+      }
+      accountMetas.push({ address: toAddress(addr), role });
+    }
+  }
+  return accountMetas;
+}
+function getRemainingAccountRole(isSigner, isWritable) {
+  const signer = isSigner === true || isSigner === "either";
+  const writable = isWritable === true;
+  if (writable && signer) return AccountRole.WRITABLE_SIGNER;
+  if (writable) return AccountRole.WRITABLE;
+  if (signer) return AccountRole.READONLY_SIGNER;
+  return AccountRole.READONLY;
+}
+function getAccountRole(acc, signers) {
+  const isSigner = isSignerAccount(acc, signers ?? []);
+  if (acc.isWritable && isSigner) {
+    return AccountRole.WRITABLE_SIGNER;
+  }
+  if (acc.isWritable) {
+    return AccountRole.WRITABLE;
+  }
+  if (isSigner) {
+    return AccountRole.READONLY_SIGNER;
+  }
+  return AccountRole.READONLY;
+}
+function getReadonlyAccountRole(acc, signers) {
+  const isSigner = isSignerAccount(acc, signers ?? []);
+  return isSigner ? AccountRole.READONLY_SIGNER : AccountRole.READONLY;
+}
+function isSignerAccount(acc, signers) {
+  if (acc.isSigner === "either") {
+    return signers.includes(acc.name);
+  }
+  return acc.isSigner === true;
+}
+function createIxAccountsValidator(ixAccountNodes) {
+  const shape = ixAccountNodes.reduce((acc, node) => {
+    acc[node.name] = node.isOptional || node.defaultValue ? OptionalSolanaAddressValidator : SolanaAddressValidator;
+    return acc;
+  }, {});
+  return object(shape);
+}
+function createIxArgumentsValidator(ixNodeName, ixArgumentNodes, definedTypes) {
+  const shape = ixArgumentNodes.reduce((acc, argumentNode, index) => {
+    if (!argumentNode.type) {
+      throw new Error(`Argument ${argumentNode.name} of instruction ${ixNodeName} does not have a type`);
+    }
+    acc[argumentNode.name] = createValidatorForTypeNode(
+      `${ixNodeName}_${argumentNode.name}_${index}`,
+      argumentNode.type,
+      definedTypes
+    );
+    return acc;
+  }, {});
+  return object(shape);
+}
+function createValidatorForTypeNode(nodeName, node, definedTypes) {
+  if (!node) {
+    throw new Error(
+      `Node ${nodeName} is not defined. ${definedTypes.length} defined types were provided: ${definedTypes.map((t) => t.name).join(", ")}`
+    );
+  }
+  switch (node.kind) {
+    case "arrayTypeNode": {
+      return ArrayValidator(`${nodeName}_array`, node, definedTypes);
+    }
+    case "booleanTypeNode": {
+      return boolean();
+    }
+    case "numberTypeNode": {
+      const format = node.format;
+      if (format === "u64" || format === "u128" || format === "i64" || format === "i128") {
+        return NumberOrBigintValidator;
+      }
+      return number();
+    }
+    case "publicKeyTypeNode": {
+      return SolanaAddressValidator;
+    }
+    case "setTypeNode": {
+      return intersection([
+        UniqueItemsValidator,
+        ArrayValidator(`${nodeName}_set`, node, definedTypes)
+      ]);
+    }
+    case "stringTypeNode": {
+      return string();
+    }
+    case "fixedSizeTypeNode": {
+      if (node.type.kind === "stringTypeNode") {
+        return StringValidatorForFixedSize(node.size);
+      }
+      if (node.type.kind === "bytesTypeNode") {
+        return BytesWithSizeValidator(node.size);
+      }
+      return createValidatorForTypeNode(`${nodeName}_fixed_size`, node.type, definedTypes);
+    }
+    case "bytesTypeNode": {
+      return BytesLikeValidator;
+    }
+    case "dateTimeTypeNode": {
+      return createValidatorForTypeNode(`${nodeName}_date_time`, node.number, definedTypes);
+    }
+    case "definedTypeLinkNode": {
+      const definedType = definedTypes.find((d) => d.name === node.name);
+      if (!definedType) {
+        throw new Error(`Undefined type: ${node.name} ${node.kind}`);
+      }
+      return createValidatorForTypeNode(`${nodeName}_defined_type`, definedType.type, definedTypes);
+    }
+    case "mapTypeNode": {
+      const keyValidator = createValidatorForTypeNode(
+        `${nodeName}_map_key_${node.key.kind}`,
+        node.key,
+        definedTypes
+      );
+      const valueValidator = createValidatorForTypeNode(
+        `${nodeName}_map_value_${node.value.kind}`,
+        node.value,
+        definedTypes
+      );
+      const sizeValidator = MapCountValidator(node.count);
+      const keyValueValidator = KeyValueValidator(nodeName, keyValidator, valueValidator);
+      if (sizeValidator) {
+        return intersection([keyValueValidator, sizeValidator]);
+      }
+      return keyValueValidator;
+    }
+    case "structTypeNode": {
+      const structShape = node.fields.reduce((acc, field) => {
+        acc[field.name] = createValidatorForTypeNode(
+          `${nodeName}_struct_${field.name}`,
+          field.type,
+          definedTypes
+        );
+        return acc;
+      }, {});
+      return object(structShape);
+    }
+    case "tupleTypeNode": {
+      const validators = node.items.map(
+        (typeNode, index) => createValidatorForTypeNode(`${nodeName}_tuple${typeNode.kind}_${index}`, typeNode, definedTypes)
+      );
+      return tuple(validators);
+    }
+    case "zeroableOptionTypeNode": {
+      const innerValidator = createValidatorForTypeNode(
+        `${nodeName}_zeroable_option_item`,
+        node.item,
+        definedTypes
+      );
+      return ZeroableOptionValidator(`${nodeName}_zeroable_option`, innerValidator);
+    }
+    case "optionTypeNode": {
+      const SomeValueValidator = createValidatorForTypeNode(`${nodeName}_option_item`, node.item, definedTypes);
+      return OptionValueValidator(`${nodeName}_option`, SomeValueValidator);
+    }
+    case "remainderOptionTypeNode": {
+      const innerValidator = RemainderOptionTypeItemValidator(
+        `${nodeName}_remainder_option_item`,
+        node.item,
+        definedTypes
+      );
+      return OptionValueValidator(`${nodeName}_remainder_option`, innerValidator);
+    }
+    case "hiddenPrefixTypeNode":
+    case "hiddenSuffixTypeNode":
+    case "sentinelTypeNode":
+    case "postOffsetTypeNode":
+    case "preOffsetTypeNode":
+    case "sizePrefixTypeNode": {
+      return createValidatorForTypeNode(`${nodeName}_size_prefix`, node.type, definedTypes);
+    }
+    case "enumTypeNode": {
+      return EnumVariantValidator(nodeName, node.variants, definedTypes);
+    }
+    case "amountTypeNode": {
+      return AmountTypeValidator(nodeName);
+    }
+    case "solAmountTypeNode": {
+      return AmountTypeValidator(nodeName);
+    }
+    default: {
+      node["kind"];
+      throw new Error(`Validator for TypeNode "${nodeName}" kind: ${getMaybeNodeKind(node)} is not implemented!`);
+    }
+  }
+}
+function RemainderOptionTypeItemValidator(nodeName, itemNode, definedTypes) {
+  if (itemNode.kind === "fixedSizeTypeNode" && itemNode.type.kind === "stringTypeNode") {
+    return StringValidatorForFixedSize(itemNode.size);
+  }
+  if (itemNode.kind === "definedTypeLinkNode") {
+    const definedType = definedTypes.find((d) => d.name === itemNode.name);
+    if (definedType?.type.kind === "fixedSizeTypeNode" && definedType.type.type.kind === "stringTypeNode") {
+      return StringValidatorForFixedSize(definedType.type.size);
+    }
+  }
+  return createValidatorForTypeNode(nodeName, itemNode, definedTypes);
+}
+function StringValidatorForFixedSize(maxSize) {
+  return define(`StringForFixedSize_max_${maxSize}`, (value) => {
+    if (typeof value !== "string") {
+      return `Expected a string, received: ${formatValueType(value)}`;
+    }
+    const encoder = getUtf8Encoder();
+    const bytes = encoder.encode(value);
+    return bytes.length <= maxSize || `String exceeds max size: ${bytes.length} bytes (UTF-8), limit is ${maxSize} bytes`;
+  });
+}
+function EnumVariantValidator(nodeName, variants, definedTypes) {
+  const variantMap = new Map(variants.map((v) => [v.name, v]));
+  const variantNames = Array.from(variantMap.keys());
+  const variantValidators = /* @__PURE__ */ new Map();
+  for (const variant of variants) {
+    if (variant.kind === "enumStructVariantTypeNode") {
+      variantValidators.set(
+        variant.name,
+        createValidatorForTypeNode(`${nodeName}_${variant.name}`, variant.struct, definedTypes)
+      );
+    } else if (variant.kind === "enumTupleVariantTypeNode") {
+      variantValidators.set(
+        variant.name,
+        createValidatorForTypeNode(`${nodeName}_${variant.name}`, variant.tuple, definedTypes)
+      );
+    }
+  }
+  return define(`${nodeName}_EnumVariant`, (value) => {
+    if (typeof value === "string")
+      return variantMap.has(value) || `Invalid enum value "${value}". Expected one of: ${variantNames.join(", ")}`;
+    if (typeof value === "object" && value !== null && "__kind" in value) {
+      const kind = value["__kind"];
+      if (typeof kind !== "string") {
+        return `Expected __kind to be a string, received: ${formatValueType(kind)}`;
+      }
+      const variant = variantMap.get(kind);
+      if (!variant) {
+        return `Invalid enum variant "${kind}". Expected one of: ${variantNames.join(", ")}`;
+      }
+      if (variant.kind === "enumEmptyVariantTypeNode") {
+        return true;
+      }
+      const { __kind: _, ...rest } = value;
+      const payloadValidator = variantValidators.get(kind);
+      if (!payloadValidator) {
+        return true;
+      }
+      if (variant.kind === "enumStructVariantTypeNode") {
+        const [structError] = payloadValidator.validate(rest);
+        return structError ? formatErrorForEnumTypeNode(kind, structError) : true;
+      }
+      if (variant.kind === "enumTupleVariantTypeNode") {
+        const fields = rest.fields;
+        const [structError] = payloadValidator.validate(fields);
+        return structError ? formatErrorForEnumTypeNode(kind, structError) : true;
+      }
+    }
+    return `Expected an enum variant (string or object with __kind), received: ${formatValueType(value)}`;
+  });
+}
+function formatErrorForEnumTypeNode(enumVariantKind, error) {
+  const failures = error.failures();
+  const first = failures?.[0];
+  if (first) {
+    return `Enum variant "${enumVariantKind}" has invalid "${String(first.key)}"`;
+  }
+  return `Enum variant "${enumVariantKind}" has invalid payload`;
+}
+var SolanaAddressValidator = /* @__PURE__ */ define("SolanaAddress", (value) => {
+  if (typeof value === "string") {
+    return isAddress(value) || `Expected a valid Solana address (base58), received string: "${value}"`;
+  }
+  if (isPublicKeyLike(value)) {
+    return isAddress(value.toBase58()) || "Expected a valid Solana address, received an invalid PublicKey";
+  }
+  return `Expected a Solana address (base58 string or PublicKey), received: ${formatValueType(value)}`;
+});
+var OptionalSolanaAddressValidator = /* @__PURE__ */ define(
+  "OptionalSolanaAddress",
+  (value) => {
+    if (value === void 0 || value === null) return true;
+    const [error] = SolanaAddressValidator.validate(value);
+    if (!error) return true;
+    return error.failures()[0]?.message ?? "Expected a valid Solana address or null/undefined";
+  }
+);
+var NumberOrBigintValidator = /* @__PURE__ */ define("NumberOrBigint", (value) => {
+  if (typeof value === "number") {
+    return Number.isSafeInteger(value) || `Expected a safe integer, received unsafe number: ${value}`;
+  }
+  if (typeof value === "bigint") return true;
+  return `Expected a number or bigint, received: ${formatValueType(value)}`;
+});
+var BytesLikeValidator = /* @__PURE__ */ define("BytesLike", (value) => {
+  if (value instanceof Uint8Array) return true;
+  if (!Array.isArray(value)) {
+    return `Expected a Uint8Array or number[] (bytes 0-255), received: ${formatValueType(value)}`;
+  }
+  const invalidIndex = value.findIndex((n) => typeof n !== "number" || !Number.isInteger(n) || n < 0 || n > 255);
+  if (invalidIndex !== -1) {
+    return `Expected byte values (integers 0-255), invalid element at index ${invalidIndex}: ${String(value[invalidIndex])}`;
+  }
+  return true;
+});
+function BytesWithSizeValidator(exactSize) {
+  return define(`BytesWithSize_${exactSize}`, (value) => {
+    if (value instanceof Uint8Array) {
+      return value.length === exactSize || `Expected exactly ${exactSize} bytes, received ${value.length} bytes`;
+    }
+    if (!Array.isArray(value)) {
+      return `Expected a Uint8Array or number[] of exactly ${exactSize} bytes, received: ${formatValueType(value)}`;
+    }
+    if (value.length !== exactSize) {
+      return `Expected exactly ${exactSize} bytes, received ${value.length} elements`;
+    }
+    const invalidIndex = value.findIndex((n) => typeof n !== "number" || !Number.isInteger(n) || n < 0 || n > 255);
+    if (invalidIndex !== -1) {
+      return `Expected byte values (integers 0-255), invalid element at index ${invalidIndex}: ${String(value[invalidIndex])}`;
+    }
+    return true;
+  });
+}
+function OptionValueValidator(name, SomeValueValidator) {
+  return define(`${name}_OptionValueValidator`, (value) => {
+    if (value === null || value === void 0) return true;
+    const [error] = SomeValueValidator.validate(value);
+    if (!error) return true;
+    return error.failures()[0]?.message ?? "Invalid value for optional field";
+  });
+}
+function ZeroableOptionValidator(name, innerValidator) {
+  return define(name, (value) => {
+    if (value == null) return true;
+    const [error] = innerValidator.validate(value);
+    if (!error) return true;
+    return error.failures()[0]?.message ?? "Expected a valid value or null for zeroable option";
+  });
+}
+var UniqueItemsValidator = /* @__PURE__ */ define("UniqueItems", (value) => {
+  if (!Array.isArray(value)) {
+    return `Expected an array with unique items, received: ${formatValueType(value)}`;
+  }
+  const unique = /* @__PURE__ */ new Map();
+  for (let i = 0; i < value.length; i++) {
+    const key = safeStringify(value[i]);
+    const index = unique.get(key);
+    if (index !== void 0) {
+      return `Expected all items to be unique, found duplicate at indices ${index} and ${i}`;
+    }
+    unique.set(key, i);
+  }
+  return true;
+});
+function KeyValueValidator(name, KeyValidator, ValueValidator) {
+  return define(`${name}_KeyValueValidator`, (value) => {
+    if (typeof value !== "object" || value === null) {
+      return `Expected a map (object), received: ${formatValueType(value)}`;
+    }
+    const record = value;
+    const invalidKeys = [];
+    const invalidValues = [];
+    for (const key of Object.keys(record)) {
+      if (KeyValidator.validate(key)[0]) invalidKeys.push(key);
+      if (ValueValidator.validate(record[key])[0]) invalidValues.push(key);
+    }
+    if (!invalidKeys.length && !invalidValues.length) return true;
+    const parts = [];
+    if (invalidKeys.length) parts.push(`invalid keys: ${invalidKeys.join(", ")}`);
+    if (invalidValues.length) parts.push(`invalid values: ${invalidValues.join(", ")}`);
+    return `Map validation failed: ${parts.join("; ")}`;
+  });
+}
+function MapCountValidator(node) {
+  switch (node.kind) {
+    case "fixedCountNode":
+      return KeysLengthValidator(node.value);
+    case "remainderCountNode":
+    case "prefixedCountNode":
+      return null;
+    // the number of items is unknown or arbitrary, like vec![]
+    default:
+      throw new Error(`Unsupported map count type: ${getMaybeNodeKind(node)}`);
+  }
+}
+function KeysLengthValidator(count) {
+  return define(`KeysLengthValidator_len_${count}`, (value) => {
+    if (typeof value !== "object" || value === null) {
+      return `Expected a map with exactly ${count} entries, received: ${formatValueType(value)}`;
+    }
+    const actual = Object.keys(value).length;
+    return actual === count || `Expected exactly ${count} map entries, received ${actual}`;
+  });
+}
+function ArrayValidator(nodeName, node, definedTypes) {
+  const itemValidator = createValidatorForTypeNode(nodeName, node.item, definedTypes);
+  switch (node.count.kind) {
+    case "fixedCountNode": {
+      return size(array(itemValidator), node.count.value);
+    }
+    case "remainderCountNode":
+    case "prefixedCountNode": {
+      return array(itemValidator);
+    }
+    default: {
+      throw new Error(`Node: ${nodeName}. Unsupported array count type`);
+    }
+  }
+}
+function AmountTypeValidator(nodeName) {
+  return define(`AmountType_${nodeName}`, (value) => {
+    if (typeof value === "number") {
+      return Number.isSafeInteger(value) || `Expected a safe integer, received unsafe number: ${value}`;
+    }
+    if (typeof value === "bigint") {
+      return true;
+    }
+    return `Expected a number or bigint, received: ${formatValueType(value)}`;
+  });
+}
+
+// src/accounts/validate-accounts-input.ts
+function createAccountsInputValidator(ixNode) {
+  const validator = ixNode.accounts.length ? createIxAccountsValidator(ixNode.accounts) : null;
+  return (accountsInput = {}) => {
+    if (!validator) return;
+    try {
+      assert(accountsInput, validator);
+    } catch (error) {
+      if (error instanceof StructError) {
+        const key = error.key;
+        const value = error.value;
+        if (value == null) {
+          throw new CodamaError(CODAMA_ERROR__DYNAMIC_CLIENT__ACCOUNT_MISSING, {
+            accountName: camelCase(key),
+            instructionName: ixNode.name
+          });
+        } else {
+          throw new CodamaError(CODAMA_ERROR__DYNAMIC_CLIENT__INVALID_ACCOUNT_ADDRESS, {
+            accountName: camelCase(key),
+            value: safeStringify(value)
+          });
+        }
+      }
+      throw new CodamaError(CODAMA_ERROR__DYNAMIC_CLIENT__FAILED_TO_VALIDATE_INPUT, {
+        cause: error,
+        message: "Unexpected validation error"
+      });
+    }
+  };
+}
+function isOmittedArgument(node) {
+  return node.defaultValueStrategy === "omitted";
+}
+function isOptionalArgument(ixArgumentNode, input) {
+  return OPTIONAL_NODE_KINDS.includes(ixArgumentNode.type.kind) && (input === null || input === void 0);
+}
+
+// src/arguments/encode-instruction-arguments.ts
+function encodeInstructionArguments(root, ix, argumentsInput) {
+  const chunks = ix.arguments.map((ixArgumentNode) => {
+    const input = argumentsInput?.[ixArgumentNode.name];
+    const nodeCodec = getNodeCodec([root, root.program, ix, ixArgumentNode]);
+    if (isOmittedArgument(ixArgumentNode)) {
+      return encodeOmittedArgument(ix, ixArgumentNode, nodeCodec);
+    } else if (isOptionalArgument(ixArgumentNode, input)) {
+      return encodeOptionalArgument(ix, ixArgumentNode, nodeCodec);
+    } else {
+      return encodeRequiredArgument(root, ix, ixArgumentNode, input, nodeCodec);
+    }
+  });
+  return mergeBytes(chunks.map((chunk) => Uint8Array.from(chunk)));
+}
+function encodeOmittedArgument(ix, ixArgumentNode, nodeCodec) {
+  const defaultValue = ixArgumentNode.defaultValue;
+  if (defaultValue === void 0) {
+    throw new CodamaError(CODAMA_ERROR__DYNAMIC_CLIENT__DEFAULT_VALUE_MISSING, {
+      argumentName: ixArgumentNode.name,
+      instructionName: ix.name
+    });
+  }
+  const visitor = createDefaultValueEncoderVisitor(nodeCodec);
+  return visitOrElse(defaultValue, visitor, (node) => {
+    throw new CodamaError(CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+      expectedKinds: [...DEFAULT_VALUE_ENCODER_SUPPORTED_NODE_KINDS],
+      kind: node.kind,
+      node
+    });
+  });
+}
+function encodeOptionalArgument(ix, ixArgumentNode, nodeCodec) {
+  try {
+    return nodeCodec.encode(null);
+  } catch (error) {
+    throw new CodamaError(CODAMA_ERROR__DYNAMIC_CLIENT__FAILED_TO_ENCODE_ARGUMENT, {
+      argumentName: ixArgumentNode.name,
+      cause: error,
+      instructionName: ix.name
+    });
+  }
+}
+function encodeRequiredArgument(root, ix, ixArgumentNode, input, nodeCodec) {
+  if (input === void 0) {
+    throw new CodamaError(CODAMA_ERROR__DYNAMIC_CLIENT__ARGUMENT_MISSING, {
+      argumentName: ixArgumentNode.name,
+      instructionName: ix.name
+    });
+  }
+  const transformer = createCodecInputTransformer(ixArgumentNode.type, root, {
+    bytesEncoding: "base16"
+  });
+  const transformedInput = transformer(input);
+  try {
+    return nodeCodec.encode(transformedInput);
+  } catch (error) {
+    throw new CodamaError(CODAMA_ERROR__DYNAMIC_CLIENT__FAILED_TO_ENCODE_ARGUMENT, {
+      argumentName: ixArgumentNode.name,
+      cause: error,
+      instructionName: ix.name
+    });
+  }
+}
+function createArgumentsInputValidator(root, ixNode) {
+  const requiredArguments = ixNode.arguments.filter((arg) => arg?.defaultValueStrategy !== "omitted");
+  const validator = requiredArguments.length ? createIxArgumentsValidator(ixNode.name, requiredArguments, root.program.definedTypes) : null;
+  return (argumentsInput = {}) => {
+    validateOmittedArguments(ixNode, argumentsInput);
+    if (!validator) return;
+    const filteredInput = filterRemainingAccountArguments(ixNode, argumentsInput);
+    try {
+      assert(filteredInput, validator);
+    } catch (error) {
+      if (!(error instanceof StructError)) {
+        throw new CodamaError(CODAMA_ERROR__DYNAMIC_CLIENT__FAILED_TO_VALIDATE_INPUT, {
+          cause: error,
+          message: "Unexpected validation error"
+        });
+      }
+      const formattedMessage = error.failures().map((failure) => {
+        const fieldPath = formatFailurePath(failure);
+        const value = formatFailureValue(failure.value);
+        return `Invalid argument "${fieldPath}", value: ${value}. ${failure.message}
+`;
+      });
+      throw new CodamaError(CODAMA_ERROR__DYNAMIC_CLIENT__FAILED_TO_VALIDATE_INPUT, {
+        cause: error,
+        message: formattedMessage.join("")
+      });
+    }
+  };
+}
+function formatFailurePath(failure) {
+  const path = failure.path;
+  if (!path || path.length === 0) return String(failure.key ?? "");
+  return path.map((segment, i) => {
+    if (typeof segment === "number") {
+      return `[${segment}]`;
+    }
+    return `${i === 0 ? "" : "."}${String(segment)}`;
+  }).join("");
+}
+var MAX_VALUE_LENGTH = 120;
+function formatFailureValue(value) {
+  const raw = typeof value === "object" ? safeStringify(value) : String(value);
+  return raw.length > MAX_VALUE_LENGTH ? `${raw.slice(0, MAX_VALUE_LENGTH)}...` : raw;
+}
+function validateOmittedArguments(ixNode, argumentsInput = {}) {
+  ixNode.arguments.filter(isOmittedArgument).forEach((ixArgumentNode) => {
+    if (Object.hasOwn(argumentsInput, ixArgumentNode.name)) {
+      throw new CodamaError(CODAMA_ERROR__DYNAMIC_CLIENT__FAILED_TO_VALIDATE_INPUT, {
+        message: "Omitted argument must not be provided"
+      });
+    }
+  });
+}
+function getRemainingAccountArgNames(ixNode) {
+  return (ixNode.remainingAccounts ?? []).filter((node) => node.value.kind === "argumentValueNode").map((node) => node.value.name);
+}
+function filterRemainingAccountArguments(ixNode, argumentsInput) {
+  const remainingAccountArgNames = getRemainingAccountArgNames(ixNode);
+  if (!remainingAccountArgNames.length) {
+    return argumentsInput;
+  }
+  const remainingAccountArgNamesSet = new Set(remainingAccountArgNames);
+  return Object.fromEntries(Object.entries(argumentsInput).filter(([key]) => !remainingAccountArgNamesSet.has(key)));
+}
+async function resolveArgumentDefaultsFromCustomResolvers(ixNode, argumentsInput, accountsInput, resolversInput) {
+  const resolvedArgumentsInput = { ...argumentsInput };
+  const allArguments = [...ixNode.arguments, ...ixNode.extraArguments ?? []];
+  for (const argumentNode of allArguments) {
+    if (resolvedArgumentsInput[argumentNode.name] !== void 0) continue;
+    if (isOmittedArgument(argumentNode)) continue;
+    if (!isNode(argumentNode.defaultValue, "resolverValueNode")) continue;
+    const resolverFn = resolversInput?.[argumentNode.defaultValue.name];
+    if (!resolverFn) continue;
+    try {
+      resolvedArgumentsInput[argumentNode.name] = await resolverFn(
+        resolvedArgumentsInput,
+        accountsInput ?? {}
+      );
+    } catch (error) {
+      throw new CodamaError(CODAMA_ERROR__DYNAMIC_CLIENT__FAILED_TO_EXECUTE_RESOLVER, {
+        cause: error,
+        resolverName: argumentNode.defaultValue.name,
+        targetKind: "instructionArgumentNode",
+        targetName: argumentNode.name
+      });
+    }
+  }
+  return resolvedArgumentsInput;
+}
+function createInstructionsBuilder(root, ixNode) {
+  const programAddress = address(root.program.publicKey);
+  const validateArguments = createArgumentsInputValidator(root, ixNode);
+  const validateAccounts = createAccountsInputValidator(ixNode);
+  return async (argumentsInput, accountsInput, signers, resolversInput) => {
+    validateArguments(argumentsInput);
+    validateAccounts(accountsInput);
+    const enrichedArgumentsInput = await resolveArgumentDefaultsFromCustomResolvers(
+      ixNode,
+      argumentsInput,
+      accountsInput,
+      resolversInput
+    );
+    const argumentsData = encodeInstructionArguments(root, ixNode, enrichedArgumentsInput);
+    const accountsData = await createAccountMeta(
+      root,
+      ixNode,
+      enrichedArgumentsInput,
+      accountsInput,
+      signers,
+      resolversInput
+    );
+    return {
+      accounts: accountsData,
+      data: argumentsData,
+      programAddress
+    };
+  };
+}
+
+export { createAccountMeta, createInstructionsBuilder, encodeInstructionArguments };
+//# sourceMappingURL=index.browser.mjs.map
+//# sourceMappingURL=index.browser.mjs.map