@codama/dynamic-address-resolution 0.2.0

package/dist/index.node.cjs

@@ -0,0 +1,1288 @@
+'use strict';
+
+var errors = require('@codama/errors');
+var codama = require('codama');
+var addresses = require('@solana/addresses');
+var dynamicCodecs = require('@codama/dynamic-codecs');
+var codecs = require('@solana/codecs');
+
+// src/resolvers/resolve-account-address.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/shared/address.ts
+function isPublicKeyLike(value) {
+  const obj = value;
+  return typeof value === "object" && value !== null && "toBase58" in obj && typeof obj.toBase58 === "function";
+}
+function toAddress(input) {
+  if (isPublicKeyLike(input)) return addresses.address(input.toBase58());
+  if (typeof input === "string" && addresses.isAddress(input)) return addresses.address(input);
+  throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__CANNOT_CONVERT_TO_ADDRESS, {
+    value: safeStringify(input)
+  });
+}
+function isAddressConvertible(value) {
+  if (value == null) return false;
+  return isPublicKeyLike(value) || typeof value === "string" && addresses.isAddress(value);
+}
+async function resolveAccountValueNodeAddress(node, ctx) {
+  const { accountsInput, ixNode, resolutionPath } = ctx;
+  const providedAddress = accountsInput?.[node.name];
+  if (providedAddress !== void 0 && providedAddress !== null) {
+    return toAddress(providedAddress);
+  }
+  const referencedIxAccountNode = ixNode.accounts.find((acc) => acc.name === node.name);
+  if (!referencedIxAccountNode) {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__NODE_REFERENCE_NOT_FOUND, {
+      instructionName: ixNode.name,
+      referencedName: node.name
+    });
+  }
+  detectCircularDependency(node.name, resolutionPath);
+  return await resolveAccountAddress({
+    accountsInput: ctx.accountsInput,
+    argumentsInput: ctx.argumentsInput,
+    ixAccountNode: referencedIxAccountNode,
+    ixNode,
+    resolutionPath: [...resolutionPath, node.name],
+    resolversInput: ctx.resolversInput,
+    root: ctx.root
+  });
+}
+function detectCircularDependency(nodeName, resolutionPath) {
+  if (resolutionPath.includes(nodeName)) {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__CIRCULAR_ACCOUNT_DEPENDENCY, {
+      chain: [...resolutionPath, nodeName].join(" -> ")
+    });
+  }
+}
+var CONDITION_NODE_SUPPORTED_NODE_KINDS = [
+  "accountValueNode",
+  "argumentValueNode",
+  "resolverValueNode"
+];
+function createConditionNodeValueVisitor(ctx) {
+  const { root, ixNode, argumentsInput, accountsInput, resolutionPath, resolversInput } = ctx;
+  return {
+    visitAccountValue: async (node) => {
+      const accountAddressInput = accountsInput?.[node.name];
+      if (accountAddressInput === null) {
+        return null;
+      }
+      return await resolveAccountValueNodeAddress(node, {
+        accountsInput,
+        argumentsInput,
+        ixNode,
+        resolutionPath,
+        resolversInput,
+        root
+      });
+    },
+    visitArgumentValue: async (node) => {
+      const argInput = argumentsInput?.[node.name];
+      return await Promise.resolve(argInput);
+    },
+    visitResolverValue: async (node) => {
+      const resolverFn = resolversInput?.[node.name];
+      if (!resolverFn) {
+        return void 0;
+      }
+      try {
+        return await resolverFn(argumentsInput ?? {}, accountsInput ?? {});
+      } catch (error) {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__FAILED_TO_EXECUTE_RESOLVER, {
+          cause: error,
+          resolverName: node.name,
+          targetKind: "conditionalValueNode",
+          targetName: node.name
+        });
+      }
+    }
+  };
+}
+var VALUE_NODE_SUPPORTED_NODE_KINDS = [
+  "arrayValueNode",
+  "booleanValueNode",
+  "bytesValueNode",
+  "constantValueNode",
+  "enumValueNode",
+  "mapValueNode",
+  "noneValueNode",
+  "numberValueNode",
+  "publicKeyValueNode",
+  "setValueNode",
+  "someValueNode",
+  "stringValueNode",
+  "structValueNode",
+  "tupleValueNode"
+];
+function createValueNodeVisitor() {
+  const visitor = {
+    visitArrayValue: (node) => ({
+      kind: node.kind,
+      value: node.items.map(
+        (item) => codama.visitOrElse(item, visitor, (n) => {
+          throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+            expectedKinds: [...VALUE_NODE_SUPPORTED_NODE_KINDS],
+            kind: n.kind,
+            node: n
+          });
+        })
+      )
+    }),
+    visitBooleanValue: (node) => ({
+      kind: node.kind,
+      value: node.boolean
+    }),
+    visitBytesValue: (node) => ({
+      encoding: node.encoding,
+      kind: node.kind,
+      value: node.data
+    }),
+    visitConstantValue: (node) => {
+      return codama.visitOrElse(node.value, visitor, (innerNode) => {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+          expectedKinds: [...VALUE_NODE_SUPPORTED_NODE_KINDS],
+          kind: innerNode.kind,
+          node: innerNode
+        });
+      });
+    },
+    visitEnumValue: (node) => ({
+      kind: node.kind,
+      value: node.variant
+    }),
+    visitMapValue: (node) => ({
+      kind: node.kind,
+      value: node.entries.map((entry) => ({
+        key: codama.visitOrElse(entry.key, visitor, (n) => {
+          throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+            expectedKinds: [...VALUE_NODE_SUPPORTED_NODE_KINDS],
+            kind: n.kind,
+            node: n
+          });
+        }),
+        value: codama.visitOrElse(entry.value, visitor, (n) => {
+          throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+            expectedKinds: [...VALUE_NODE_SUPPORTED_NODE_KINDS],
+            kind: n.kind,
+            node: n
+          });
+        })
+      }))
+    }),
+    visitNoneValue: (node) => ({
+      kind: node.kind,
+      value: null
+    }),
+    visitNumberValue: (node) => ({
+      kind: node.kind,
+      value: node.number
+    }),
+    visitPublicKeyValue: (node) => ({
+      kind: node.kind,
+      value: addresses.address(node.publicKey)
+    }),
+    visitSetValue: (node) => ({
+      kind: node.kind,
+      value: node.items.map(
+        (item) => codama.visitOrElse(item, visitor, (n) => {
+          throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+            expectedKinds: [...VALUE_NODE_SUPPORTED_NODE_KINDS],
+            kind: n.kind,
+            node: n
+          });
+        })
+      )
+    }),
+    visitSomeValue: (node) => {
+      return codama.visitOrElse(node.value, visitor, (innerNode) => {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+          expectedKinds: [...VALUE_NODE_SUPPORTED_NODE_KINDS],
+          kind: innerNode.kind,
+          node: innerNode
+        });
+      });
+    },
+    visitStringValue: (node) => ({
+      kind: node.kind,
+      value: node.string
+    }),
+    visitStructValue: (node) => ({
+      kind: node.kind,
+      value: Object.fromEntries(
+        node.fields.map((field) => [
+          field.name,
+          codama.visitOrElse(field.value, visitor, (n) => {
+            throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+              expectedKinds: [...VALUE_NODE_SUPPORTED_NODE_KINDS],
+              kind: n.kind,
+              node: n
+            });
+          })
+        ])
+      )
+    }),
+    visitTupleValue: (node) => ({
+      kind: node.kind,
+      value: node.items.map(
+        (item) => codama.visitOrElse(item, visitor, (n) => {
+          throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+            expectedKinds: [...VALUE_NODE_SUPPORTED_NODE_KINDS],
+            kind: n.kind,
+            node: n
+          });
+        })
+      )
+    })
+  };
+  return visitor;
+}
+
+// src/resolvers/resolve-conditional.ts
+async function resolveConditionalValueNodeCondition({
+  root,
+  ixNode,
+  ixAccountNode,
+  conditionalValueNode,
+  argumentsInput,
+  accountsInput,
+  resolutionPath,
+  resolversInput
+}) {
+  if (!codama.isNode(conditionalValueNode, "conditionalValueNode")) {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+      expectedKinds: ["conditionalValueNode"],
+      kind: getMaybeNodeKind(conditionalValueNode),
+      node: conditionalValueNode
+    });
+  }
+  const { condition, value: expectedValueNode, ifTrue, ifFalse } = conditionalValueNode;
+  if (!expectedValueNode && !ifTrue && !ifFalse) {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__INVARIANT_VIOLATION, {
+      message: `Invalid conditionalValueNode: missing value and branches for account ${ixAccountNode.name} in ${ixNode.name}`
+    });
+  }
+  const conditionVisitor = createConditionNodeValueVisitor({
+    accountsInput,
+    argumentsInput,
+    ixNode,
+    resolutionPath,
+    resolversInput,
+    root
+  });
+  const actualProvidedValue = await codama.visitOrElse(condition, conditionVisitor, (condNode) => {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+      expectedKinds: [...CONDITION_NODE_SUPPORTED_NODE_KINDS],
+      kind: condNode.kind,
+      node: condNode
+    });
+  });
+  if (!expectedValueNode) {
+    return actualProvidedValue ? ifTrue : ifFalse;
+  }
+  const valueVisitor = createValueNodeVisitor();
+  const expectedValue = codama.visitOrElse(expectedValueNode, valueVisitor, (valueNode) => {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+      expectedKinds: [...VALUE_NODE_SUPPORTED_NODE_KINDS],
+      kind: valueNode.kind,
+      node: valueNode
+    });
+  });
+  if (typeof expectedValue.value === "object" || typeof actualProvidedValue === "object") {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__INVARIANT_VIOLATION, {
+      message: "Deep equality comparison not yet supported for conditional value"
+    });
+  }
+  return actualProvidedValue === expectedValue.value ? ifTrue : ifFalse;
+}
+var addressEncoder;
+function getMemoizedAddressEncoder() {
+  if (!addressEncoder) addressEncoder = addresses.getAddressEncoder();
+  return addressEncoder;
+}
+var utf8Encoder;
+function getMemoizedUtf8Encoder() {
+  if (!utf8Encoder) utf8Encoder = codecs.getUtf8Encoder();
+  return utf8Encoder;
+}
+var booleanEncoder;
+function getMemoizedBooleanEncoder() {
+  if (!booleanEncoder) booleanEncoder = codecs.getBooleanEncoder();
+  return booleanEncoder;
+}
+var utf8Codec;
+function getMemoizedUtf8Codec() {
+  if (!utf8Codec) utf8Codec = codecs.getUtf8Codec();
+  return utf8Codec;
+}
+var base16Codec;
+function getMemoizedBase16Codec() {
+  if (!base16Codec) base16Codec = codecs.getBase16Codec();
+  return base16Codec;
+}
+var base58Codec;
+function getMemoizedBase58Codec() {
+  if (!base58Codec) base58Codec = codecs.getBase58Codec();
+  return base58Codec;
+}
+var base64Codec;
+function getMemoizedBase64Codec() {
+  if (!base64Codec) base64Codec = codecs.getBase64Codec();
+  return base64Codec;
+}
+
+// src/shared/bytes-encoding.ts
+function uint8ArrayToEncodedString(bytes, encoding) {
+  const codec = getCodecFromBytesEncoding(encoding);
+  return codec.decode(bytes);
+}
+function getCodecFromBytesEncoding(encoding) {
+  switch (encoding) {
+    case "base16":
+      return getMemoizedBase16Codec();
+    case "base58":
+      return getMemoizedBase58Codec();
+    case "base64":
+      return getMemoizedBase64Codec();
+    case "utf8":
+      return getMemoizedUtf8Codec();
+    default:
+      throw new errors.CodamaError(errors.CODAMA_ERROR__UNRECOGNIZED_BYTES_ENCODING, {
+        encoding: safeStringify(encoding)
+      });
+  }
+}
+function isUint8Array(value) {
+  return value instanceof Uint8Array;
+}
+var CODEC_INPUT_TRANSFORMER_SUPPORTED_NODE_KINDS = [
+  "amountTypeNode",
+  "arrayTypeNode",
+  "booleanTypeNode",
+  "bytesTypeNode",
+  "dateTimeTypeNode",
+  "definedTypeLinkNode",
+  "enumTypeNode",
+  "fixedSizeTypeNode",
+  "hiddenPrefixTypeNode",
+  "hiddenSuffixTypeNode",
+  "mapTypeNode",
+  "numberTypeNode",
+  "optionTypeNode",
+  "postOffsetTypeNode",
+  "preOffsetTypeNode",
+  "publicKeyTypeNode",
+  "remainderOptionTypeNode",
+  "sentinelTypeNode",
+  "setTypeNode",
+  "sizePrefixTypeNode",
+  "solAmountTypeNode",
+  "stringTypeNode",
+  "structFieldTypeNode",
+  "structTypeNode",
+  "tupleTypeNode",
+  "zeroableOptionTypeNode"
+];
+function unexpectedNodeFallback(node) {
+  throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+    expectedKinds: [...CODEC_INPUT_TRANSFORMER_SUPPORTED_NODE_KINDS],
+    kind: node.kind,
+    node
+  });
+}
+function createCodecInputTransformerVisitor(root, options = {}) {
+  const bytesEncoding = options.bytesEncoding ?? "base16";
+  const visitor = {
+    visitAmountType(node) {
+      return codama.visitOrElse(node.number, visitor, unexpectedNodeFallback);
+    },
+    visitArrayType(node) {
+      const itemTransform = codama.visitOrElse(node.item, visitor, unexpectedNodeFallback);
+      return (input) => {
+        if (!Array.isArray(input)) {
+          throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__UNEXPECTED_ARGUMENT_TYPE, {
+            actualType: formatValueType(input),
+            expectedType: "array",
+            nodeKind: "arrayTypeNode"
+          });
+        }
+        return input.map(itemTransform);
+      };
+    },
+    visitBooleanType() {
+      return (input) => input;
+    },
+    visitBytesType() {
+      return (input) => {
+        if (isUint8Array(input)) {
+          return [bytesEncoding, uint8ArrayToEncodedString(input, bytesEncoding)];
+        }
+        if (Array.isArray(input) && input.every((item) => typeof item === "number")) {
+          return [bytesEncoding, uint8ArrayToEncodedString(new Uint8Array(input), bytesEncoding)];
+        }
+        throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__UNEXPECTED_ARGUMENT_TYPE, {
+          actualType: formatValueType(input),
+          expectedType: "Uint8Array | number[]",
+          nodeKind: "bytesTypeNode"
+        });
+      };
+    },
+    visitDateTimeType(node) {
+      return codama.visitOrElse(node.number, visitor, unexpectedNodeFallback);
+    },
+    visitDefinedTypeLink(node) {
+      const definedType = root.program.definedTypes.find((dt) => dt.name === node.name);
+      if (!definedType) {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__LINKED_NODE_NOT_FOUND, {
+          kind: "definedTypeLinkNode",
+          linkNode: node,
+          name: node.name,
+          path: []
+        });
+      }
+      return codama.visitOrElse(definedType.type, visitor, unexpectedNodeFallback);
+    },
+    visitEnumType(node) {
+      return (input) => {
+        if (typeof input === "number" || typeof input === "string") {
+          return input;
+        }
+        if (!isObjectRecord(input)) {
+          return input;
+        }
+        if (!("__kind" in input)) {
+          return input;
+        }
+        const { __kind, ...rest } = input;
+        const kindObj = { __kind: codama.pascalCase(String(__kind)) };
+        const variantNode = node.variants.find((v) => v.name === __kind);
+        if (!variantNode) {
+          const availableVariants = node.variants.map((v) => v.name).join(", ");
+          throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__UNEXPECTED_ARGUMENT_TYPE, {
+            actualType: `variant '${String(__kind)}'`,
+            expectedType: `one of [${availableVariants}]`,
+            nodeKind: "enumTypeNode"
+          });
+        }
+        if (codama.isNode(variantNode, "enumEmptyVariantTypeNode")) {
+          return { ...input, ...kindObj };
+        }
+        if (codama.isNode(variantNode, "enumStructVariantTypeNode")) {
+          const structTransform = codama.visitOrElse(variantNode.struct, visitor, unexpectedNodeFallback);
+          const transformedFields = structTransform(rest);
+          if (!isObjectRecord(transformedFields)) {
+            throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__UNEXPECTED_ARGUMENT_TYPE, {
+              actualType: formatValueType(transformedFields),
+              expectedType: "object",
+              nodeKind: "enumStructVariantTypeNode"
+            });
+          }
+          return { ...kindObj, ...transformedFields };
+        }
+        if (codama.isNode(variantNode, "enumTupleVariantTypeNode")) {
+          const tupleTransform = codama.visitOrElse(variantNode.tuple, visitor, unexpectedNodeFallback);
+          if (!("fields" in rest) || !Array.isArray(rest.fields)) {
+            throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__UNEXPECTED_ARGUMENT_TYPE, {
+              actualType: formatValueType(rest.fields ?? rest),
+              expectedType: "array (fields)",
+              nodeKind: "enumTupleVariantTypeNode"
+            });
+          }
+          return { ...kindObj, fields: tupleTransform(rest.fields) };
+        }
+        return input;
+      };
+    },
+    visitFixedSizeType(node) {
+      return codama.visitOrElse(node.type, visitor, unexpectedNodeFallback);
+    },
+    visitHiddenPrefixType(node) {
+      return codama.visitOrElse(node.type, visitor, unexpectedNodeFallback);
+    },
+    visitHiddenSuffixType(node) {
+      return codama.visitOrElse(node.type, visitor, unexpectedNodeFallback);
+    },
+    visitMapType(node) {
+      const valueTransform = codama.visitOrElse(node.value, visitor, unexpectedNodeFallback);
+      return (input) => {
+        if (!isObjectRecord(input)) {
+          throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__UNEXPECTED_ARGUMENT_TYPE, {
+            actualType: formatValueType(input),
+            expectedType: "object",
+            nodeKind: "mapTypeNode"
+          });
+        }
+        const result = {};
+        for (const [key, value] of Object.entries(input)) {
+          result[key] = valueTransform(value);
+        }
+        return result;
+      };
+    },
+    // Primitive types (pass through)
+    visitNumberType() {
+      return (input) => input;
+    },
+    visitOptionType(node) {
+      const innerTransform = codama.visitOrElse(node.item, visitor, unexpectedNodeFallback);
+      return (input) => {
+        if (input === null || input === void 0) return input;
+        return innerTransform(input);
+      };
+    },
+    visitPostOffsetType(node) {
+      return codama.visitOrElse(node.type, visitor, unexpectedNodeFallback);
+    },
+    visitPreOffsetType(node) {
+      return codama.visitOrElse(node.type, visitor, unexpectedNodeFallback);
+    },
+    visitPublicKeyType() {
+      return (input) => input;
+    },
+    visitRemainderOptionType(node) {
+      const innerTransform = codama.visitOrElse(node.item, visitor, unexpectedNodeFallback);
+      return (input) => {
+        if (input === null || input === void 0) return input;
+        return innerTransform(input);
+      };
+    },
+    visitSentinelType(node) {
+      return codama.visitOrElse(node.type, visitor, unexpectedNodeFallback);
+    },
+    visitSetType(node) {
+      const itemTransform = codama.visitOrElse(node.item, visitor, unexpectedNodeFallback);
+      return (input) => {
+        if (!Array.isArray(input)) {
+          throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__UNEXPECTED_ARGUMENT_TYPE, {
+            actualType: formatValueType(input),
+            expectedType: "array",
+            nodeKind: "setTypeNode"
+          });
+        }
+        return input.map(itemTransform);
+      };
+    },
+    visitSizePrefixType(node) {
+      return codama.visitOrElse(node.type, visitor, unexpectedNodeFallback);
+    },
+    visitSolAmountType(node) {
+      return codama.visitOrElse(node.number, visitor, unexpectedNodeFallback);
+    },
+    visitStringType() {
+      return (input) => input;
+    },
+    visitStructFieldType(node) {
+      return codama.visitOrElse(node.type, visitor, unexpectedNodeFallback);
+    },
+    visitStructType(node) {
+      const fieldTransformers = node.fields.map((field) => {
+        const transform = codama.visitOrElse(field, visitor, unexpectedNodeFallback);
+        return { name: field.name, transform };
+      });
+      return (input) => {
+        if (!isObjectRecord(input)) {
+          throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__UNEXPECTED_ARGUMENT_TYPE, {
+            actualType: formatValueType(input),
+            expectedType: "object",
+            nodeKind: "structTypeNode"
+          });
+        }
+        const result = { ...input };
+        for (const { name, transform } of fieldTransformers) {
+          if (name in result) {
+            result[name] = transform(result[name]);
+          }
+        }
+        return result;
+      };
+    },
+    visitTupleType(node) {
+      const itemTransforms = node.items.map((item) => codama.visitOrElse(item, visitor, unexpectedNodeFallback));
+      return (input) => {
+        if (!Array.isArray(input)) {
+          throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__UNEXPECTED_ARGUMENT_TYPE, {
+            actualType: formatValueType(input),
+            expectedType: "array",
+            nodeKind: "tupleTypeNode"
+          });
+        }
+        if (input.length !== itemTransforms.length) {
+          throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__UNEXPECTED_ARGUMENT_TYPE, {
+            actualType: `array(length:${input.length})`,
+            expectedType: `array(length:${itemTransforms.length})`,
+            nodeKind: "tupleTypeNode"
+          });
+        }
+        return input.map((value, index) => itemTransforms[index](value));
+      };
+    },
+    visitZeroableOptionType(node) {
+      const innerTransform = codama.visitOrElse(node.item, visitor, unexpectedNodeFallback);
+      return (input) => {
+        if (input === null || input === void 0) return input;
+        return innerTransform(input);
+      };
+    }
+  };
+  return visitor;
+}
+function createCodecInputTransformer(typeNode, root, options) {
+  const visitor = createCodecInputTransformerVisitor(root, options);
+  return codama.visitOrElse(typeNode, visitor, unexpectedNodeFallback);
+}
+
+// src/visitors/pda-seed-value.ts
+var PDA_SEED_VALUE_SUPPORTED_NODE_KINDS = [
+  "accountValueNode",
+  "argumentValueNode",
+  "booleanValueNode",
+  "bytesValueNode",
+  "constantValueNode",
+  "noneValueNode",
+  "numberValueNode",
+  "programIdValueNode",
+  "publicKeyValueNode",
+  "someValueNode",
+  "stringValueNode"
+];
+function createPdaSeedValueVisitor(ctx) {
+  const { root, ixNode, programId, seedTypeNode, resolversInput, resolutionPath } = ctx;
+  const accountsInput = ctx.accountsInput ?? {};
+  const argumentsInput = ctx.argumentsInput ?? {};
+  return {
+    visitAccountValue: async (node) => {
+      const resolvedAddress = await resolveAccountValueNodeAddress(node, {
+        accountsInput,
+        argumentsInput,
+        ixNode,
+        resolutionPath,
+        resolversInput,
+        root
+      });
+      if (resolvedAddress === null) {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__FAILED_TO_DERIVE_PDA, {
+          accountName: node.name
+        });
+      }
+      return getMemoizedAddressEncoder().encode(resolvedAddress);
+    },
+    visitArgumentValue: async (node) => {
+      const ixArgumentNode = ixNode.arguments.find((arg) => arg.name === node.name);
+      if (!ixArgumentNode) {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__NODE_REFERENCE_NOT_FOUND, {
+          instructionName: ixNode.name,
+          referencedName: node.name
+        });
+      }
+      const argInput = argumentsInput[node.name];
+      const typeNode = seedTypeNode ?? ixArgumentNode.type;
+      if (argInput === void 0 || argInput === null) {
+        if (codama.isNode(typeNode, "remainderOptionTypeNode")) {
+          return new Uint8Array(0);
+        }
+        throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__ARGUMENT_MISSING, {
+          argumentName: node.name,
+          instructionName: ixNode.name
+        });
+      }
+      const codec = dynamicCodecs.getNodeCodec([root, root.program, ixNode, { ...ixArgumentNode, type: typeNode }]);
+      const transformer = createCodecInputTransformer(typeNode, root, {
+        bytesEncoding: "base16"
+      });
+      const transformedInput = transformer(argInput);
+      return await Promise.resolve(codec.encode(transformedInput));
+    },
+    visitBooleanValue: async (node) => await Promise.resolve(getMemoizedBooleanEncoder().encode(node.boolean)),
+    visitBytesValue: async (node) => {
+      const encodedValue = getCodecFromBytesEncoding(node.encoding).encode(node.data);
+      return await Promise.resolve(encodedValue);
+    },
+    visitConstantValue: async (node) => {
+      const innerVisitor = createPdaSeedValueVisitor(ctx);
+      return await codama.visitOrElse(node.value, innerVisitor, (innerNode) => {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+          expectedKinds: [...PDA_SEED_VALUE_SUPPORTED_NODE_KINDS],
+          kind: innerNode.kind,
+          node: innerNode
+        });
+      });
+    },
+    visitNoneValue: async (_node) => await Promise.resolve(new Uint8Array(0)),
+    visitNumberValue: async (node) => {
+      if (!Number.isInteger(node.number) || node.number < 0 || node.number > 255) {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__INVARIANT_VIOLATION, {
+          message: `NumberValueNode PDA seed is out of range: must be a valid u8 (0\u2013255), got ${node.number}`
+        });
+      }
+      return await Promise.resolve(new Uint8Array([node.number]));
+    },
+    visitProgramIdValue: async (_node) => {
+      return await Promise.resolve(getMemoizedAddressEncoder().encode(toAddress(programId)));
+    },
+    visitPublicKeyValue: async (node) => {
+      return await Promise.resolve(getMemoizedAddressEncoder().encode(toAddress(node.publicKey)));
+    },
+    visitSomeValue: async (node) => {
+      const innerVisitor = createPdaSeedValueVisitor(ctx);
+      return await codama.visitOrElse(node.value, innerVisitor, (innerNode) => {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+          expectedKinds: [...PDA_SEED_VALUE_SUPPORTED_NODE_KINDS],
+          kind: innerNode.kind,
+          node: innerNode
+        });
+      });
+    },
+    visitStringValue: async (node) => await Promise.resolve(getMemoizedUtf8Codec().encode(node.string))
+  };
+}
+
+// src/resolvers/resolve-pda-address.ts
+async function resolvePDAAddress({
+  root,
+  ixNode,
+  argumentsInput,
+  accountsInput,
+  pdaValueNode,
+  resolutionPath,
+  resolversInput
+}) {
+  if (!codama.isNode(pdaValueNode, "pdaValueNode")) {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+      expectedKinds: ["pdaValueNode"],
+      kind: getMaybeNodeKind(pdaValueNode),
+      node: pdaValueNode
+    });
+  }
+  const pdaNode = resolvePdaNode(pdaValueNode, root.program.pdas);
+  const programId = addresses.address(pdaNode.programId || root.program.publicKey);
+  const seedValues = await Promise.all(
+    pdaNode.seeds.map(async (seedNode) => {
+      if (seedNode.kind === "constantPdaSeedNode") {
+        return await resolveConstantPdaSeed({
+          accountsInput,
+          argumentsInput,
+          ixNode,
+          programId,
+          resolutionPath,
+          resolversInput,
+          root,
+          seedNode
+        });
+      }
+      if (seedNode.kind === "variablePdaSeedNode") {
+        const variableSeedValueNodes = pdaValueNode.seeds;
+        const seedName = seedNode.name;
+        const variableSeedValueNode = variableSeedValueNodes.find((node) => node.name === seedName);
+        if (!variableSeedValueNode) {
+          throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__NODE_REFERENCE_NOT_FOUND, {
+            instructionName: ixNode.name,
+            referencedName: seedName
+          });
+        }
+        return await resolveVariablePdaSeed({
+          accountsInput,
+          argumentsInput,
+          ixNode,
+          programId,
+          resolutionPath,
+          resolversInput,
+          root,
+          seedNode,
+          variableSeedValueNode
+        });
+      }
+      throw new errors.CodamaError(errors.CODAMA_ERROR__UNRECOGNIZED_NODE_KIND, {
+        kind: getMaybeNodeKind(seedNode) ?? "unknown"
+      });
+    })
+  );
+  return await addresses.getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: seedValues
+  });
+}
+function resolvePdaNode(pdaDefaultValue, pdas) {
+  if (codama.isNode(pdaDefaultValue.pda, "pdaLinkNode")) {
+    const linkedPda = pdas.find((p) => p.name === pdaDefaultValue.pda.name);
+    if (!linkedPda) {
+      throw new errors.CodamaError(errors.CODAMA_ERROR__LINKED_NODE_NOT_FOUND, {
+        kind: "pdaLinkNode",
+        linkNode: pdaDefaultValue.pda,
+        name: pdaDefaultValue.pda.name,
+        path: []
+      });
+    }
+    return linkedPda;
+  }
+  if (codama.isNode(pdaDefaultValue.pda, "pdaNode")) {
+    return pdaDefaultValue.pda;
+  }
+  throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+    expectedKinds: ["pdaLinkNode", "pdaNode"],
+    kind: getMaybeNodeKind(pdaDefaultValue.pda),
+    node: pdaDefaultValue.pda
+  });
+}
+function resolveVariablePdaSeed({
+  accountsInput,
+  argumentsInput,
+  ixNode,
+  programId,
+  resolutionPath,
+  resolversInput,
+  root,
+  seedNode,
+  variableSeedValueNode
+}) {
+  if (!codama.isNode(variableSeedValueNode, "pdaSeedValueNode")) {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+      expectedKinds: ["pdaSeedValueNode"],
+      kind: getMaybeNodeKind(variableSeedValueNode),
+      node: variableSeedValueNode
+    });
+  }
+  if (seedNode.name !== variableSeedValueNode.name) {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__INVARIANT_VIOLATION, {
+      message: `Mismatched PDA seed names: expected [${seedNode.name}], got [${variableSeedValueNode.name}]`
+    });
+  }
+  const visitor = createPdaSeedValueVisitor({
+    accountsInput,
+    argumentsInput,
+    ixNode,
+    programId,
+    resolutionPath,
+    resolversInput,
+    root,
+    seedTypeNode: seedNode.type
+  });
+  return codama.visitOrElse(variableSeedValueNode.value, visitor, (node) => {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+      expectedKinds: [...PDA_SEED_VALUE_SUPPORTED_NODE_KINDS],
+      kind: node.kind,
+      node
+    });
+  });
+}
+function resolveConstantPdaSeed({
+  accountsInput,
+  argumentsInput,
+  ixNode,
+  programId,
+  resolutionPath,
+  resolversInput,
+  root,
+  seedNode
+}) {
+  if (!codama.isNode(seedNode, "constantPdaSeedNode")) {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+      expectedKinds: ["constantPdaSeedNode"],
+      kind: seedNode.kind,
+      node: seedNode
+    });
+  }
+  const visitor = createPdaSeedValueVisitor({
+    accountsInput,
+    argumentsInput,
+    ixNode,
+    programId,
+    resolutionPath,
+    resolversInput,
+    root,
+    seedTypeNode: seedNode.type
+  });
+  return codama.visitOrElse(seedNode.value, visitor, (node) => {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+      expectedKinds: [...PDA_SEED_VALUE_SUPPORTED_NODE_KINDS],
+      kind: node.kind,
+      node
+    });
+  });
+}
+
+// src/visitors/account-default-value.ts
+var ACCOUNT_DEFAULT_VALUE_SUPPORTED_NODE_KINDS = [
+  "accountBumpValueNode",
+  "accountValueNode",
+  "argumentValueNode",
+  "conditionalValueNode",
+  "identityValueNode",
+  "payerValueNode",
+  "pdaValueNode",
+  "programIdValueNode",
+  "publicKeyValueNode",
+  "resolverValueNode"
+];
+function createAccountDefaultValueVisitor(ctx) {
+  const { root, ixNode, ixAccountNode, argumentsInput, accountsInput, resolversInput, resolutionPath } = ctx;
+  const accountAddressInput = accountsInput?.[ixAccountNode.name];
+  return {
+    visitAccountBumpValue: async (_node) => {
+      return await Promise.reject(
+        new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__UNSUPPORTED_NODE, {
+          nodeKind: "accountBumpValueNode"
+        })
+      );
+    },
+    visitAccountValue: async (node) => {
+      return await resolveAccountValueNodeAddress(node, {
+        accountsInput,
+        argumentsInput,
+        ixNode,
+        resolutionPath,
+        resolversInput,
+        root
+      });
+    },
+    visitArgumentValue: async (node) => {
+      const argValue = argumentsInput?.[node.name];
+      if (argValue === void 0 || argValue === null) {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__ARGUMENT_MISSING, {
+          argumentName: node.name,
+          instructionName: ixNode.name
+        });
+      }
+      if (!isAddressConvertible(argValue)) {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__UNEXPECTED_ADDRESS_TYPE, {
+          accountName: ixAccountNode.name,
+          actualType: formatValueType(argValue),
+          expectedType: "Address | PublicKey"
+        });
+      }
+      return await Promise.resolve(toAddress(argValue));
+    },
+    visitConditionalValue: async (conditionalValueNode) => {
+      const resolvedInputValueNode = await resolveConditionalValueNodeCondition({
+        accountsInput,
+        argumentsInput,
+        conditionalValueNode,
+        ixAccountNode,
+        ixNode,
+        resolutionPath,
+        resolversInput,
+        root
+      });
+      if (resolvedInputValueNode === void 0) {
+        if (ixAccountNode.isOptional) {
+          return null;
+        }
+        throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__ACCOUNT_MISSING, {
+          accountName: ixAccountNode.name,
+          instructionName: ixNode.name
+        });
+      }
+      const visitor = createAccountDefaultValueVisitor(ctx);
+      const addressValue = await codama.visitOrElse(resolvedInputValueNode, visitor, (innerNode) => {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+          expectedKinds: [...ACCOUNT_DEFAULT_VALUE_SUPPORTED_NODE_KINDS],
+          kind: innerNode.kind,
+          node: innerNode
+        });
+      });
+      return addressValue;
+    },
+    visitIdentityValue: async (_node) => {
+      if (accountAddressInput === void 0 || accountAddressInput === null) {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__ACCOUNT_MISSING, {
+          accountName: ixAccountNode.name,
+          instructionName: ixNode.name
+        });
+      }
+      return await Promise.resolve(toAddress(accountAddressInput));
+    },
+    visitPayerValue: async (_node) => {
+      if (accountAddressInput === void 0 || accountAddressInput === null) {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__ACCOUNT_MISSING, {
+          accountName: ixAccountNode.name,
+          instructionName: ixNode.name
+        });
+      }
+      return await Promise.resolve(toAddress(accountAddressInput));
+    },
+    visitPdaValue: async (node) => {
+      const pda = await resolvePDAAddress({
+        accountsInput,
+        argumentsInput,
+        ixNode,
+        pdaValueNode: node,
+        resolutionPath,
+        resolversInput,
+        root
+      });
+      if (pda === null) {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__FAILED_TO_DERIVE_PDA, {
+          accountName: ixAccountNode.name
+        });
+      }
+      return pda[0];
+    },
+    visitProgramIdValue: async (_node) => {
+      return await Promise.resolve(addresses.address(root.program.publicKey));
+    },
+    visitPublicKeyValue: async (node) => {
+      return await Promise.resolve(addresses.address(node.publicKey));
+    },
+    visitResolverValue: async (node) => {
+      const resolverFn = resolversInput?.[node.name];
+      if (!resolverFn) {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__ACCOUNT_RESOLVER_MISSING, {
+          accountName: ixAccountNode.name,
+          resolverName: node.name
+        });
+      }
+      let result;
+      try {
+        result = await resolverFn(argumentsInput ?? {}, accountsInput ?? {});
+      } catch (error) {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__FAILED_TO_EXECUTE_RESOLVER, {
+          cause: error,
+          resolverName: node.name,
+          targetKind: "instructionAccountNode",
+          targetName: ixAccountNode.name
+        });
+      }
+      if (!isAddressConvertible(result)) {
+        throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__INVALID_ACCOUNT_ADDRESS, {
+          accountName: ixAccountNode.name,
+          value: safeStringify(result)
+        });
+      }
+      return toAddress(result);
+    }
+  };
+}
+
+// src/resolvers/resolve-account-address.ts
+async function resolveAccountAddress({
+  root,
+  ixNode,
+  ixAccountNode,
+  argumentsInput,
+  accountsInput,
+  resolutionPath,
+  resolversInput
+}) {
+  const accountAddressInput = accountsInput?.[ixAccountNode.name];
+  if (accountAddressInput === null && ixAccountNode.isOptional) {
+    return resolveOptionalAccountWithStrategy(root, ixNode, ixAccountNode);
+  }
+  if (ixAccountNode.defaultValue) {
+    const visitor = createAccountDefaultValueVisitor({
+      accountsInput,
+      argumentsInput,
+      ixAccountNode,
+      ixNode,
+      resolutionPath,
+      resolversInput,
+      root
+    });
+    const addressValue = await codama.visitOrElse(ixAccountNode.defaultValue, visitor, (node) => {
+      throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+        expectedKinds: [...ACCOUNT_DEFAULT_VALUE_SUPPORTED_NODE_KINDS],
+        kind: node.kind,
+        node
+      });
+    });
+    if (addressValue === null && ixAccountNode.isOptional) {
+      return resolveOptionalAccountWithStrategy(root, ixNode, ixAccountNode);
+    }
+    return addressValue;
+  }
+  throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__ACCOUNT_MISSING, {
+    accountName: ixAccountNode.name,
+    instructionName: ixNode.name
+  });
+}
+function resolveOptionalAccountWithStrategy(root, ixNode, ixAccountNode) {
+  if (!ixAccountNode.isOptional) {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__INVARIANT_VIOLATION, {
+      message: `resolveOptionalAccountWithStrategy called for non-optional account: ${ixAccountNode.name}`
+    });
+  }
+  switch (ixNode.optionalAccountStrategy) {
+    case "omitted":
+      return null;
+    case "programId":
+      return toAddress(root.program.publicKey);
+    default:
+      throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__UNSUPPORTED_OPTIONAL_ACCOUNT_STRATEGY, {
+        accountName: ixAccountNode.name,
+        instructionName: ixNode.name,
+        strategy: safeStringify(ixNode.optionalAccountStrategy)
+      });
+  }
+}
+async function resolveInstructionAccountAddress({
+  accountsInput,
+  argumentsInput,
+  ixAccountNode,
+  ixNode,
+  resolversInput,
+  root
+}) {
+  const accountAddressInput = accountsInput?.[ixAccountNode.name];
+  const isAccountProvided = accountAddressInput !== void 0 && accountAddressInput !== null;
+  const canAutoResolve = !!ixAccountNode.defaultValue || ixAccountNode.isOptional && accountAddressInput === null;
+  if (!isAccountProvided && !canAutoResolve) {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__ACCOUNT_MISSING, {
+      accountName: ixAccountNode.name,
+      instructionName: ixNode.name
+    });
+  }
+  if (isAccountProvided) {
+    return toAddress(accountAddressInput);
+  }
+  return await resolveAccountAddress({
+    accountsInput,
+    argumentsInput,
+    ixAccountNode,
+    ixNode,
+    resolutionPath: [],
+    resolversInput,
+    root
+  });
+}
+var STANDALONE_IX_NODE = {
+  accounts: [],
+  arguments: [],
+  kind: "instructionNode",
+  name: "__standalone__"
+};
+async function resolveStandalonePda(root, pdaNode, seedInputs = {}) {
+  const programAddress = toAddress(pdaNode.programId || root.program.publicKey);
+  const seedValues = await Promise.all(
+    pdaNode.seeds.map(async (seedNode) => {
+      if (seedNode.kind === "constantPdaSeedNode") {
+        return await resolveStandaloneConstantSeed(root, programAddress, seedNode);
+      }
+      if (seedNode.kind === "variablePdaSeedNode") {
+        return await resolveStandaloneVariableSeed(root, seedNode, seedInputs);
+      }
+      throw new errors.CodamaError(errors.CODAMA_ERROR__UNRECOGNIZED_NODE_KIND, {
+        kind: getMaybeNodeKind(seedNode) ?? "unknown"
+      });
+    })
+  );
+  return await addresses.getProgramDerivedAddress({ programAddress, seeds: seedValues });
+}
+function resolveStandaloneConstantSeed(root, programAddress, seedNode) {
+  if (!codama.isNode(seedNode, "constantPdaSeedNode")) {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+      expectedKinds: ["constantPdaSeedNode"],
+      kind: seedNode.kind,
+      node: seedNode
+    });
+  }
+  const visitor = createPdaSeedValueVisitor({
+    accountsInput: void 0,
+    argumentsInput: void 0,
+    ixNode: STANDALONE_IX_NODE,
+    programId: programAddress,
+    resolutionPath: [],
+    resolversInput: void 0,
+    root
+  });
+  return codama.visitOrElse(seedNode.value, visitor, (node) => {
+    throw new errors.CodamaError(errors.CODAMA_ERROR__UNEXPECTED_NODE_KIND, {
+      expectedKinds: Array.from(PDA_SEED_VALUE_SUPPORTED_NODE_KINDS),
+      kind: node.kind,
+      node
+    });
+  });
+}
+function resolveStandaloneVariableSeed(root, seedNode, seedInputs) {
+  const input = seedInputs[seedNode.name];
+  const typeNode = seedNode.type;
+  if (input === void 0 || input === null) {
+    if (codama.isNode(typeNode, "remainderOptionTypeNode")) {
+      return Promise.resolve(new Uint8Array(0));
+    }
+    throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__ARGUMENT_MISSING, {
+      argumentName: seedNode.name,
+      instructionName: codama.camelCase("standaloneSeedNode")
+    });
+  }
+  if (codama.isNode(typeNode, "stringTypeNode")) {
+    if (typeof input !== "string") {
+      throw new errors.CodamaError(errors.CODAMA_ERROR__DYNAMIC_CLIENT__UNEXPECTED_ARGUMENT_TYPE, {
+        actualType: formatValueType(input),
+        expectedType: "string",
+        nodeKind: "stringTypeNode"
+      });
+    }
+    return Promise.resolve(getMemoizedUtf8Encoder().encode(input));
+  }
+  const syntheticArgNode = createSyntheticArgNode(seedNode);
+  const codec = dynamicCodecs.getNodeCodec([root, root.program, syntheticArgNode]);
+  const transformer = createCodecInputTransformer(typeNode, root, { bytesEncoding: "base16" });
+  const transformedInput = transformer(input);
+  return Promise.resolve(codec.encode(transformedInput));
+}
+function createSyntheticArgNode(seedNode) {
+  return {
+    docs: [],
+    kind: "instructionArgumentNode",
+    name: seedNode.name,
+    type: seedNode.type
+  };
+}
+
+// src/visitors/default-value-encoder.ts
+var DEFAULT_VALUE_ENCODER_SUPPORTED_NODE_KINDS = [
+  "booleanValueNode",
+  "bytesValueNode",
+  "enumValueNode",
+  "noneValueNode",
+  "numberValueNode",
+  "publicKeyValueNode",
+  "stringValueNode"
+];
+function createDefaultValueEncoderVisitor(codec) {
+  return {
+    visitBooleanValue: (node) => codec.encode(node.boolean),
+    visitBytesValue: (node) => codec.encode([node.encoding, node.data]),
+    visitEnumValue: (node) => codec.encode(node.variant),
+    visitNoneValue: () => codec.encode(null),
+    visitNumberValue: (node) => codec.encode(node.number),
+    visitPublicKeyValue: (node) => codec.encode(node.publicKey),
+    visitStringValue: (node) => codec.encode(node.string)
+  };
+}
+
+// src/shared/nodes.ts
+var OPTIONAL_NODE_KINDS = ["optionTypeNode", "zeroableOptionTypeNode", "remainderOptionTypeNode"];
+
+exports.DEFAULT_VALUE_ENCODER_SUPPORTED_NODE_KINDS = DEFAULT_VALUE_ENCODER_SUPPORTED_NODE_KINDS;
+exports.OPTIONAL_NODE_KINDS = OPTIONAL_NODE_KINDS;
+exports.createCodecInputTransformer = createCodecInputTransformer;
+exports.createDefaultValueEncoderVisitor = createDefaultValueEncoderVisitor;
+exports.isAddressConvertible = isAddressConvertible;
+exports.isPublicKeyLike = isPublicKeyLike;
+exports.resolveInstructionAccountAddress = resolveInstructionAccountAddress;
+exports.resolveStandalonePda = resolveStandalonePda;
+exports.toAddress = toAddress;
+//# sourceMappingURL=index.node.cjs.map
+//# sourceMappingURL=index.node.cjs.map