@thru/programs 0.2.30 → 0.2.31

package/dist/token/index.js

@@ -22,6 +22,46 @@ function __tnWarnOnce(message) {
     __tnLogWarn(message);
   }
 }
+function __tnResolveBuilderInput(input, context) {
+  if (input instanceof Uint8Array) {
+    return new Uint8Array(input);
+  }
+  if (input && typeof input.build === "function") {
+    const built = input.build();
+    if (!(built instanceof Uint8Array)) {
+      throw new Error(`${context}: builder did not return Uint8Array`);
+    }
+    return new Uint8Array(built);
+  }
+  throw new Error(`${context}: expected Uint8Array or builder`);
+}
+function __tnCreateFamWriter(parent, fieldName, assign) {
+  let hasWritten = false;
+  return {
+    write(payload) {
+      const bytes = __tnResolveBuilderInput(
+        payload,
+        `flexible array '${fieldName}'`
+      );
+      const copy = new Uint8Array(bytes);
+      assign(copy);
+      hasWritten = true;
+      return {
+        finish() {
+          return parent;
+        }
+      };
+    },
+    finish() {
+      if (!hasWritten) {
+        throw new Error(
+          `flexible array '${fieldName}' requires write() before finish()`
+        );
+      }
+      return parent;
+    }
+  };
+}
 var __tnMask32 = __tnHasNativeBigInt ? (BigInt(1) << BigInt(32)) - BigInt(1) : 4294967295;
 var __tnSignBit32 = __tnHasNativeBigInt ? BigInt(1) << BigInt(31) : 2147483648;
 function __tnToBigInt(value) {
@@ -246,12 +286,16 @@ if (typeof DataView !== "undefined" && !__tnHasBigIntDataView) {
 }
 var __tnFootprintRegistry = {};
 var __tnValidateRegistry = {};
+var __tnDynamicValidateRegistry = {};
 function __tnRegisterFootprint(typeName, fn) {
   __tnFootprintRegistry[typeName] = fn;
 }
 function __tnRegisterValidate(typeName, fn) {
   __tnValidateRegistry[typeName] = fn;
 }
+function __tnRegisterDynamicValidate(typeName, fn) {
+  __tnDynamicValidateRegistry[typeName] = fn;
+}
 function __tnInvokeFootprint(typeName, params) {
   const fn = __tnFootprintRegistry[typeName];
   if (!fn) throw new Error(`IR runtime missing footprint for ${typeName}`);
@@ -262,12 +306,17 @@ function __tnInvokeValidate(typeName, buffer, params) {
   if (!fn) throw new Error(`IR runtime missing validate helper for ${typeName}`);
   return fn(buffer, params);
 }
+function __tnInvokeDynamicValidate(typeName, buffer) {
+  const fn = __tnDynamicValidateRegistry[typeName];
+  if (!fn) throw new Error(`IR runtime missing dynamic validate helper for ${typeName}`);
+  return fn(buffer);
+}
 function __tnEvalFootprint(node, ctx) {
-  return __tnEvalIrNode(node, ctx);
+  return __tnEvalIrNode(node, ctx, __tnToBigInt(0));
 }
 function __tnTryEvalIr(node, ctx) {
   try {
-    return { ok: true, value: __tnEvalIrNode(node, ctx) };
+    return { ok: true, value: __tnEvalIrNode(node, ctx, __tnToBigInt(0)) };
   } catch (err) {
     return { ok: false, code: __tnNormalizeIrError(err) };
   }
@@ -291,7 +340,7 @@ function __tnValidateIrTree(ir, buffer, params) {
   }
   return { ok: true, consumed: required };
 }
-function __tnEvalIrNode(node, ctx) {
+function __tnEvalIrNode(node, ctx, baseOffset) {
   switch (node.op) {
     case "zero":
       return __tnToBigInt(0);
@@ -308,18 +357,22 @@ function __tnEvalIrNode(node, ctx) {
       }
       return val;
     }
-    case "add":
-      return __tnCheckedAdd(
-        __tnEvalIrNode(node.left, ctx),
-        __tnEvalIrNode(node.right, ctx)
+    case "add": {
+      const left = __tnEvalIrNode(node.left, ctx, baseOffset);
+      const right = __tnEvalIrNode(
+        node.right,
+        ctx,
+        __tnCheckedAdd(baseOffset, left)
       );
+      return __tnCheckedAdd(left, right);
+    }
     case "mul":
       return __tnCheckedMul(
-        __tnEvalIrNode(node.left, ctx),
-        __tnEvalIrNode(node.right, ctx)
+        __tnEvalIrNode(node.left, ctx, baseOffset),
+        __tnEvalIrNode(node.right, ctx, baseOffset)
       );
     case "align":
-      return __tnAlign(__tnEvalIrNode(node.node, ctx), node.alignment);
+      return __tnAlign(__tnEvalIrNode(node.node, ctx, baseOffset), node.alignment);
     case "switch": {
       const tagVal = ctx.params[node.tag];
       if (tagVal === void 0) {
@@ -332,10 +385,10 @@ function __tnEvalIrNode(node, ctx) {
       const tagNumber = Number(tagVal);
       for (const caseNode of node.cases) {
         if (caseNode.value === tagNumber) {
-          return __tnEvalIrNode(caseNode.node, ctx);
+          return __tnEvalIrNode(caseNode.node, ctx, baseOffset);
         }
       }
-      if (node.default) return __tnEvalIrNode(node.default, ctx);
+      if (node.default) return __tnEvalIrNode(node.default, ctx, baseOffset);
       __tnRaiseIrError(
         "tn.ir.invalid_tag",
         `Unhandled IR switch value ${tagNumber} for '${node.tag}'`
@@ -355,9 +408,10 @@ function __tnEvalIrNode(node, ctx) {
         nestedParams[arg.name] = val;
       }
       if (ctx.buffer) {
+        const nestedOffset = __tnBigIntToNumber(baseOffset, "IR nested offset");
         const nestedResult = __tnInvokeValidate(
           node.typeName,
-          ctx.buffer,
+          ctx.buffer.subarray(nestedOffset),
           nestedParams
         );
         if (!nestedResult.ok) {
@@ -374,6 +428,36 @@ function __tnEvalIrNode(node, ctx) {
       }
       return __tnInvokeFootprint(node.typeName, nestedParams);
     }
+    case "sumOverArray": {
+      if (!ctx.buffer) {
+        __tnRaiseIrError(
+          "tn.ir.missing_buffer",
+          `Jagged array '${node.fieldName}' requires buffer-backed validation`
+        );
+      }
+      const count = __tnBigIntToNumber(
+        __tnEvalIrNode(node.count, ctx, baseOffset),
+        `Jagged array '${node.fieldName}' count`
+      );
+      let cursor = __tnBigIntToNumber(baseOffset, "IR jagged array offset");
+      let total = __tnToBigInt(0);
+      for (let i = 0; i < count; i++) {
+        const result = __tnInvokeDynamicValidate(
+          node.elementTypeName,
+          ctx.buffer.subarray(cursor)
+        );
+        if (!result.ok || result.consumed === void 0) {
+          const code = result.code ?? "tn.ir.runtime_error";
+          __tnRaiseIrError(
+            code,
+            `Jagged array '${node.fieldName}' element ${i} failed validation`
+          );
+        }
+        cursor += __tnBigIntToNumber(result.consumed, "IR jagged element size");
+        total = __tnCheckedAdd(total, result.consumed);
+      }
+      return total;
+    }
     default:
       __tnRaiseIrError(
         "tn.ir.runtime_error",
@@ -397,54 +481,206 @@ function __tnNormalizeIrError(err) {
   if (message.length > 0) return `tn.ir.runtime_error: ${message}`;
   return "tn.ir.runtime_error";
 }
-var __tn_ir_Hash = {
-  typeName: "Hash",
-  root: { op: "const", value: 32n }
+var __tn_ir_Date = {
+  typeName: "Date",
+  root: { op: "const", value: 6n }
 };
-var Hash = class _Hash {
+var Date = class _Date {
   constructor(buffer) {
     this.buffer = buffer;
     this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
   }
   static __tnCreateView(buffer, opts) {
-    if (!buffer || buffer.length === void 0) throw new Error("Hash.__tnCreateView requires a Uint8Array");
-    return new _Hash(new Uint8Array(buffer));
+    if (!buffer || buffer.length === void 0) throw new Error("Date.__tnCreateView requires a Uint8Array");
+    return new _Date(new Uint8Array(buffer));
   }
   static builder() {
-    return new HashBuilder();
+    return new DateBuilder();
   }
   static fromBuilder(builder) {
     const buffer = builder.build();
-    return _Hash.from_array(buffer);
+    return _Date.from_array(buffer);
   }
-  get_bytes() {
+  get_year() {
     const offset = 0;
-    const result = [];
-    for (let i = 0; i < 32; i++) {
-      result.push(this.view.getUint8(offset + i * 1));
-    }
-    return result;
+    return this.view.getInt32(offset, true);
   }
-  set_bytes(value) {
+  set_year(value) {
     const offset = 0;
-    if (value.length !== 32) {
-      throw new Error("Array length must be 32");
+    this.view.setInt32(offset, value, true);
+  }
+  get year() {
+    return this.get_year();
+  }
+  set year(value) {
+    this.set_year(value);
+  }
+  get_month() {
+    const offset = 4;
+    return this.view.getUint8(offset);
+  }
+  set_month(value) {
+    const offset = 4;
+    this.view.setUint8(offset, value);
+  }
+  get month() {
+    return this.get_month();
+  }
+  set month(value) {
+    this.set_month(value);
+  }
+  get_day() {
+    const offset = 5;
+    return this.view.getUint8(offset);
+  }
+  set_day(value) {
+    const offset = 5;
+    this.view.setUint8(offset, value);
+  }
+  get day() {
+    return this.get_day();
+  }
+  set day(value) {
+    this.set_day(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint(__tn_ir_Date.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree(__tn_ir_Date, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr() {
+    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  }
+  static footprint() {
+    const irResult = this.footprintIr();
+    const maxSafe = __tnToBigInt(Number.MAX_SAFE_INTEGER);
+    if (__tnBigIntGreaterThan(irResult, maxSafe)) {
+      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for Date");
     }
-    for (let i = 0; i < 32; i++) {
-      this.view.setUint8(offset + i * 1, value[i]);
+    return __tnBigIntToNumber(irResult, "Date::footprint");
+  }
+  static validate(buffer, _opts) {
+    if (buffer.length < 6) return { ok: false, code: "tn.buffer_too_small", consumed: 6 };
+    return { ok: true, consumed: 6 };
+  }
+  static new(year, month, day) {
+    const buffer = new Uint8Array(6);
+    const view = new DataView(buffer.buffer);
+    view.setInt32(0, year, true);
+    view.setUint8(4, month);
+    view.setUint8(5, day);
+    return new _Date(buffer);
+  }
+  static from_array(buffer) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
     }
+    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const validation = this.validate(buffer);
+    if (!validation.ok) {
+      return null;
+    }
+    return new _Date(buffer);
   }
-  get bytes() {
-    return this.get_bytes();
+};
+var DateBuilder = class {
+  constructor() {
+    this.buffer = new Uint8Array(6);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
   }
-  set bytes(value) {
-    this.set_bytes(value);
+  set_year(value) {
+    this.view.setInt32(0, value, true);
+    return this;
+  }
+  set_month(value) {
+    this.view.setUint8(4, value);
+    return this;
+  }
+  set_day(value) {
+    this.view.setUint8(5, value);
+    return this;
+  }
+  build() {
+    return this.buffer.slice();
+  }
+  buildInto(target, offset = 0) {
+    if (target.length - offset < this.buffer.length) throw new Error("target buffer too small");
+    target.set(this.buffer, offset);
+    return target;
+  }
+  finish() {
+    const view = Date.from_array(this.buffer.slice());
+    if (!view) throw new Error("failed to build Date");
+    return view;
+  }
+};
+__tnRegisterFootprint("Date", (params) => Date.__tnInvokeFootprint(params));
+__tnRegisterValidate("Date", (buffer, params) => Date.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Date", (buffer) => {
+  const result = Date.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed), params };
+});
+var __tn_ir_Duration = {
+  typeName: "Duration",
+  root: { op: "const", value: 12n }
+};
+var Duration = class _Duration {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  static __tnCreateView(buffer, opts) {
+    if (!buffer || buffer.length === void 0) throw new Error("Duration.__tnCreateView requires a Uint8Array");
+    return new _Duration(new Uint8Array(buffer));
+  }
+  static builder() {
+    return new DurationBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    return _Duration.from_array(buffer);
+  }
+  get_seconds() {
+    const offset = 0;
+    return this.view.getBigInt64(offset, true);
+  }
+  set_seconds(value) {
+    const offset = 0;
+    this.view.setBigInt64(offset, value, true);
+  }
+  get seconds() {
+    return this.get_seconds();
+  }
+  set seconds(value) {
+    this.set_seconds(value);
+  }
+  get_nanos() {
+    const offset = 8;
+    return this.view.getInt32(offset, true);
+  }
+  set_nanos(value) {
+    const offset = 8;
+    this.view.setInt32(offset, value, true);
+  }
+  get nanos() {
+    return this.get_nanos();
+  }
+  set nanos(value) {
+    this.set_nanos(value);
   }
   static __tnFootprintInternal(__tnParams) {
-    return __tnEvalFootprint(__tn_ir_Hash.root, { params: __tnParams });
+    return __tnEvalFootprint(__tn_ir_Duration.root, { params: __tnParams });
   }
   static __tnValidateInternal(buffer, __tnParams) {
-    return __tnValidateIrTree(__tn_ir_Hash, buffer, __tnParams);
+    return __tnValidateIrTree(__tn_ir_Duration, buffer, __tnParams);
   }
   static __tnInvokeFootprint(__tnParams) {
     return this.__tnFootprintInternal(__tnParams);
@@ -459,13 +695,20 @@ var Hash = class _Hash {
     const irResult = this.footprintIr();
     const maxSafe = __tnToBigInt(Number.MAX_SAFE_INTEGER);
     if (__tnBigIntGreaterThan(irResult, maxSafe)) {
-      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for Hash");
+      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for Duration");
     }
-    return __tnBigIntToNumber(irResult, "Hash::footprint");
+    return __tnBigIntToNumber(irResult, "Duration::footprint");
   }
   static validate(buffer, _opts) {
-    if (buffer.length < 32) return { ok: false, code: "tn.buffer_too_small", consumed: 32 };
-    return { ok: true, consumed: 32 };
+    if (buffer.length < 12) return { ok: false, code: "tn.buffer_too_small", consumed: 12 };
+    return { ok: true, consumed: 12 };
+  }
+  static new(seconds, nanos) {
+    const buffer = new Uint8Array(12);
+    const view = new DataView(buffer.buffer);
+    view.setBigInt64(0, seconds, true);
+    view.setInt32(8, nanos, true);
+    return new _Duration(buffer);
   }
   static from_array(buffer) {
     if (!buffer || buffer.length === void 0) {
@@ -476,22 +719,21 @@ var Hash = class _Hash {
     if (!validation.ok) {
       return null;
     }
-    return new _Hash(buffer);
+    return new _Duration(buffer);
   }
 };
-__tnRegisterFootprint("Hash", (params) => Hash.__tnInvokeFootprint(params));
-__tnRegisterValidate("Hash", (buffer, params) => Hash.__tnInvokeValidate(buffer, params));
-var HashBuilder = class {
+var DurationBuilder = class {
   constructor() {
-    this.buffer = new Uint8Array(32);
+    this.buffer = new Uint8Array(12);
     this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
   }
-  set_bytes(values) {
-    if (values.length !== 32) throw new Error("bytes expects 32 elements");
-    for (let i = 0; i < values.length; i++) {
-      const byteOffset = 0 + i * 1;
-      this.view.setUint8(byteOffset, values[i]);
-    }
+  set_seconds(value) {
+    const cast = __tnToBigInt(value);
+    this.view.setBigInt64(0, cast, true);
+    return this;
+  }
+  set_nanos(value) {
+    this.view.setInt32(8, value, true);
     return this;
   }
   build() {
@@ -502,12 +744,605 @@ var HashBuilder = class {
     target.set(this.buffer, offset);
     return target;
   }
-  finish() {
-    const view = Hash.from_array(this.buffer.slice());
-    if (!view) throw new Error("failed to build Hash");
-    return view;
+  finish() {
+    const view = Duration.from_array(this.buffer.slice());
+    if (!view) throw new Error("failed to build Duration");
+    return view;
+  }
+};
+__tnRegisterFootprint("Duration", (params) => Duration.__tnInvokeFootprint(params));
+__tnRegisterValidate("Duration", (buffer, params) => Duration.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Duration", (buffer) => {
+  const result = Duration.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed), params };
+});
+var __tn_ir_FixedPoint = {
+  typeName: "FixedPoint",
+  root: { op: "const", value: 9n }
+};
+var FixedPoint = class _FixedPoint {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  static __tnCreateView(buffer, opts) {
+    if (!buffer || buffer.length === void 0) throw new Error("FixedPoint.__tnCreateView requires a Uint8Array");
+    return new _FixedPoint(new Uint8Array(buffer));
+  }
+  static builder() {
+    return new FixedPointBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    return _FixedPoint.from_array(buffer);
+  }
+  get_mantissa() {
+    const offset = 0;
+    return this.view.getBigInt64(offset, true);
+  }
+  set_mantissa(value) {
+    const offset = 0;
+    this.view.setBigInt64(offset, value, true);
+  }
+  get mantissa() {
+    return this.get_mantissa();
+  }
+  set mantissa(value) {
+    this.set_mantissa(value);
+  }
+  get_scale() {
+    const offset = 8;
+    return this.view.getUint8(offset);
+  }
+  set_scale(value) {
+    const offset = 8;
+    this.view.setUint8(offset, value);
+  }
+  get scale() {
+    return this.get_scale();
+  }
+  set scale(value) {
+    this.set_scale(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint(__tn_ir_FixedPoint.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree(__tn_ir_FixedPoint, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr() {
+    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  }
+  static footprint() {
+    const irResult = this.footprintIr();
+    const maxSafe = __tnToBigInt(Number.MAX_SAFE_INTEGER);
+    if (__tnBigIntGreaterThan(irResult, maxSafe)) {
+      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for FixedPoint");
+    }
+    return __tnBigIntToNumber(irResult, "FixedPoint::footprint");
+  }
+  static validate(buffer, _opts) {
+    if (buffer.length < 9) return { ok: false, code: "tn.buffer_too_small", consumed: 9 };
+    return { ok: true, consumed: 9 };
+  }
+  static new(mantissa, scale) {
+    const buffer = new Uint8Array(9);
+    const view = new DataView(buffer.buffer);
+    view.setBigInt64(0, mantissa, true);
+    view.setUint8(8, scale);
+    return new _FixedPoint(buffer);
+  }
+  static from_array(buffer) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const validation = this.validate(buffer);
+    if (!validation.ok) {
+      return null;
+    }
+    return new _FixedPoint(buffer);
+  }
+};
+var FixedPointBuilder = class {
+  constructor() {
+    this.buffer = new Uint8Array(9);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  set_mantissa(value) {
+    const cast = __tnToBigInt(value);
+    this.view.setBigInt64(0, cast, true);
+    return this;
+  }
+  set_scale(value) {
+    this.view.setUint8(8, value);
+    return this;
+  }
+  build() {
+    return this.buffer.slice();
+  }
+  buildInto(target, offset = 0) {
+    if (target.length - offset < this.buffer.length) throw new Error("target buffer too small");
+    target.set(this.buffer, offset);
+    return target;
+  }
+  finish() {
+    const view = FixedPoint.from_array(this.buffer.slice());
+    if (!view) throw new Error("failed to build FixedPoint");
+    return view;
+  }
+};
+__tnRegisterFootprint("FixedPoint", (params) => FixedPoint.__tnInvokeFootprint(params));
+__tnRegisterValidate("FixedPoint", (buffer, params) => FixedPoint.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("FixedPoint", (buffer) => {
+  const result = FixedPoint.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed), params };
+});
+var __tn_ir_Hash = {
+  typeName: "Hash",
+  root: { op: "const", value: 32n }
+};
+var Hash = class _Hash {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  static __tnCreateView(buffer, opts) {
+    if (!buffer || buffer.length === void 0) throw new Error("Hash.__tnCreateView requires a Uint8Array");
+    return new _Hash(new Uint8Array(buffer));
+  }
+  static builder() {
+    return new HashBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    return _Hash.from_array(buffer);
+  }
+  get_bytes() {
+    const offset = 0;
+    const result = [];
+    for (let i = 0; i < 32; i++) {
+      result.push(this.view.getUint8(offset + i * 1));
+    }
+    return result;
+  }
+  set_bytes(value) {
+    const offset = 0;
+    if (value.length !== 32) {
+      throw new Error("Array length must be 32");
+    }
+    for (let i = 0; i < 32; i++) {
+      this.view.setUint8(offset + i * 1, value[i]);
+    }
+  }
+  get bytes() {
+    return this.get_bytes();
+  }
+  set bytes(value) {
+    this.set_bytes(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint(__tn_ir_Hash.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree(__tn_ir_Hash, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr() {
+    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  }
+  static footprint() {
+    const irResult = this.footprintIr();
+    const maxSafe = __tnToBigInt(Number.MAX_SAFE_INTEGER);
+    if (__tnBigIntGreaterThan(irResult, maxSafe)) {
+      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for Hash");
+    }
+    return __tnBigIntToNumber(irResult, "Hash::footprint");
+  }
+  static validate(buffer, _opts) {
+    if (buffer.length < 32) return { ok: false, code: "tn.buffer_too_small", consumed: 32 };
+    return { ok: true, consumed: 32 };
+  }
+  static from_array(buffer) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const validation = this.validate(buffer);
+    if (!validation.ok) {
+      return null;
+    }
+    return new _Hash(buffer);
+  }
+};
+var HashBuilder = class {
+  constructor() {
+    this.buffer = new Uint8Array(32);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  set_bytes(values) {
+    if (values.length !== 32) throw new Error("bytes expects 32 elements");
+    for (let i = 0; i < values.length; i++) {
+      const byteOffset = 0 + i * 1;
+      this.view.setUint8(byteOffset, values[i]);
+    }
+    return this;
+  }
+  build() {
+    return this.buffer.slice();
+  }
+  buildInto(target, offset = 0) {
+    if (target.length - offset < this.buffer.length) throw new Error("target buffer too small");
+    target.set(this.buffer, offset);
+    return target;
+  }
+  finish() {
+    const view = Hash.from_array(this.buffer.slice());
+    if (!view) throw new Error("failed to build Hash");
+    return view;
+  }
+};
+__tnRegisterFootprint("Hash", (params) => Hash.__tnInvokeFootprint(params));
+__tnRegisterValidate("Hash", (buffer, params) => Hash.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Hash", (buffer) => {
+  const result = Hash.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed), params };
+});
+var __tn_ir_InstructionData = {
+  typeName: "InstructionData",
+  root: { op: "align", alignment: 1, node: { op: "add", left: { op: "add", left: { op: "align", alignment: 2, node: { op: "const", value: 2n } }, right: { op: "align", alignment: 8, node: { op: "const", value: 8n } } }, right: { op: "align", alignment: 1, node: { op: "mul", left: { op: "field", param: "data.data_size" }, right: { op: "const", value: 1n } } } } }
+};
+var _InstructionData = class _InstructionData {
+  constructor(buffer, params, fieldContext) {
+    this.buffer = buffer;
+    this.__tnFieldContext = null;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    this.__tnFieldContext = fieldContext ?? null;
+    if (params) {
+      this.__tnParams = params;
+    } else {
+      const derived = _InstructionData.__tnExtractParams(this.view, buffer);
+      if (!derived) {
+        throw new Error("InstructionData: failed to derive dynamic parameters");
+      }
+      this.__tnParams = derived.params;
+    }
+  }
+  static __tnCreateView(buffer, opts) {
+    if (!buffer || buffer.length === void 0) throw new Error("InstructionData.__tnCreateView requires a Uint8Array");
+    let params = opts?.params ?? null;
+    if (!params) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      const derived = _InstructionData.__tnExtractParams(view, buffer);
+      if (!derived) throw new Error("InstructionData.__tnCreateView: failed to derive params");
+      params = derived.params;
+    }
+    const instance = new _InstructionData(new Uint8Array(buffer), params, opts?.fieldContext);
+    return instance;
+  }
+  dynamicParams() {
+    return this.__tnParams;
+  }
+  withFieldContext(context) {
+    this.__tnFieldContext = context;
+    return this;
+  }
+  __tnResolveFieldRef(path) {
+    const getterName = `get_${path.replace(/[.]/g, "_")}`;
+    const getter = this[getterName];
+    if (typeof getter === "function") {
+      const value = getter.call(this);
+      return typeof value === "bigint" ? __tnBigIntToNumber(value, "InstructionData::__tnResolveFieldRef") : value;
+    }
+    if (this.__tnFieldContext && Object.prototype.hasOwnProperty.call(this.__tnFieldContext, path)) {
+      const contextValue = this.__tnFieldContext[path];
+      return typeof contextValue === "bigint" ? __tnBigIntToNumber(contextValue, "InstructionData::__tnResolveFieldRef") : contextValue;
+    }
+    throw new Error("InstructionData: field reference '" + path + "' is not available; provide fieldContext when creating this view");
+  }
+  static builder() {
+    return new InstructionDataBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    const params = builder.dynamicParams();
+    return _InstructionData.from_array(buffer, { params });
+  }
+  static __tnExtractParams(view, buffer) {
+    if (buffer.length < 10) {
+      return null;
+    }
+    const __tnParam_data_data_size = __tnToBigInt(view.getBigUint64(2, true));
+    const __tnExtractedParams = _InstructionData.Params.fromValues({
+      data_data_size: __tnParam_data_data_size
+    });
+    return { params: __tnExtractedParams, derived: null };
+  }
+  get_program_idx() {
+    const offset = 0;
+    return this.view.getUint16(offset, true);
+  }
+  set_program_idx(value) {
+    const offset = 0;
+    this.view.setUint16(offset, value, true);
+  }
+  get program_idx() {
+    return this.get_program_idx();
+  }
+  set program_idx(value) {
+    this.set_program_idx(value);
+  }
+  get_data_size() {
+    const offset = 2;
+    return this.view.getBigUint64(offset, true);
+  }
+  set_data_size(value) {
+    const offset = 2;
+    this.view.setBigUint64(offset, value, true);
+  }
+  get data_size() {
+    return this.get_data_size();
+  }
+  set data_size(value) {
+    this.set_data_size(value);
+  }
+  get_data_length() {
+    return this.__tnResolveFieldRef("data_size");
+  }
+  get_data_at(index) {
+    const offset = 10;
+    return this.view.getUint8(offset + index * 1);
+  }
+  get_data() {
+    const len = this.get_data_length();
+    const result = [];
+    for (let i = 0; i < len; i++) {
+      result.push(this.get_data_at(i));
+    }
+    return result;
+  }
+  set_data_at(index, value) {
+    const offset = 10;
+    this.view.setUint8(offset + index * 1, value);
+  }
+  set_data(value) {
+    const len = Math.min(this.get_data_length(), value.length);
+    for (let i = 0; i < len; i++) {
+      this.set_data_at(i, value[i]);
+    }
+  }
+  get data() {
+    return this.get_data();
+  }
+  set data(value) {
+    this.set_data(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint(__tn_ir_InstructionData.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree(__tn_ir_InstructionData, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr(data_data_size) {
+    const params = _InstructionData.Params.fromValues({
+      data_data_size
+    });
+    return this.footprintIrFromParams(params);
+  }
+  static __tnPackParams(params) {
+    const record = /* @__PURE__ */ Object.create(null);
+    record["data.data_size"] = params.data_data_size;
+    return record;
+  }
+  static footprintIrFromParams(params) {
+    const __tnParams = this.__tnPackParams(params);
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static footprintFromParams(params) {
+    const irResult = this.footprintIrFromParams(params);
+    const maxSafe = __tnToBigInt(Number.MAX_SAFE_INTEGER);
+    if (__tnBigIntGreaterThan(irResult, maxSafe)) throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for InstructionData");
+    return __tnBigIntToNumber(irResult, "InstructionData::footprintFromParams");
+  }
+  static footprintFromValues(input) {
+    const params = _InstructionData.params(input);
+    return this.footprintFromParams(params);
+  }
+  static footprint(params) {
+    return this.footprintFromParams(params);
+  }
+  static validate(buffer, opts) {
+    if (!buffer || buffer.length === void 0) {
+      return { ok: false, code: "tn.invalid_buffer" };
+    }
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    let params = opts?.params ?? null;
+    if (!params) {
+      const extracted = this.__tnExtractParams(view, buffer);
+      if (!extracted) return { ok: false, code: "tn.param_extraction_failed" };
+      params = extracted.params;
+    }
+    const __tnParamsRec = this.__tnPackParams(params);
+    const irResult = this.__tnValidateInternal(buffer, __tnParamsRec);
+    if (!irResult.ok) {
+      return { ok: false, code: irResult.code, consumed: irResult.consumed ? __tnBigIntToNumber(irResult.consumed, "InstructionData::validate") : void 0, params };
+    }
+    const consumed = irResult.consumed ? __tnBigIntToNumber(irResult.consumed, "InstructionData::validate") : void 0;
+    return { ok: true, consumed, params };
+  }
+  static from_array(buffer, opts) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    let params = opts?.params ?? null;
+    if (!params) {
+      const derived = this.__tnExtractParams(view, buffer);
+      if (!derived) return null;
+      params = derived.params;
+    }
+    const validation = this.validate(buffer, { params });
+    if (!validation.ok) {
+      return null;
+    }
+    const cached = validation.params ?? params;
+    const state = new _InstructionData(buffer, cached);
+    return state;
+  }
+};
+_InstructionData.flexibleArrayWriters = Object.freeze([
+  { field: "data", method: "data", sizeField: "data_size", paramKey: "data_size", elementSize: 1 }
+]);
+var InstructionData = _InstructionData;
+((InstructionData2) => {
+  InstructionData2.ParamKeys = Object.freeze({
+    data_data_size: "data.data_size"
+  });
+  InstructionData2.Params = {
+    fromValues(input) {
+      return {
+        data_data_size: __tnToBigInt(input.data_data_size)
+      };
+    },
+    fromBuilder(source) {
+      if (source.dynamicParams) {
+        return source.dynamicParams();
+      }
+      if (source.params) {
+        return source.params;
+      }
+      return source;
+    }
+  };
+  function params(input) {
+    return InstructionData2.Params.fromValues(input);
+  }
+  InstructionData2.params = params;
+})(InstructionData || (InstructionData = {}));
+var InstructionDataBuilder = class {
+  constructor() {
+    this.__tnCachedParams = null;
+    this.__tnLastBuffer = null;
+    this.__tnLastParams = null;
+    this.__tnFam_data = null;
+    this.__tnFam_dataCount = null;
+    this.buffer = new Uint8Array(10);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  __tnInvalidate() {
+    this.__tnCachedParams = null;
+    this.__tnLastBuffer = null;
+    this.__tnLastParams = null;
+  }
+  set_program_idx(value) {
+    this.view.setUint16(0, value, true);
+    this.__tnInvalidate();
+    return this;
+  }
+  set_data_size(value) {
+    const cast = __tnToBigInt(value);
+    this.view.setBigUint64(2, cast, true);
+    this.__tnInvalidate();
+    return this;
+  }
+  data() {
+    if (!this.__tnFamWriter_data) {
+      this.__tnFamWriter_data = __tnCreateFamWriter(this, "data", (payload) => {
+        const bytes = new Uint8Array(payload);
+        const elementCount = bytes.length;
+        this.__tnFam_data = bytes;
+        this.__tnFam_dataCount = elementCount;
+        this.set_data_size(__tnToBigInt(elementCount));
+        this.__tnInvalidate();
+      });
+    }
+    return this.__tnFamWriter_data;
+  }
+  build() {
+    const params = this.__tnComputeParams();
+    const size = InstructionData.footprintFromParams(params);
+    const buffer = new Uint8Array(size);
+    this.__tnWriteInto(buffer);
+    this.__tnValidateOrThrow(buffer, params);
+    return buffer;
+  }
+  buildInto(target, offset = 0) {
+    const params = this.__tnComputeParams();
+    const size = InstructionData.footprintFromParams(params);
+    if (target.length - offset < size) throw new Error("InstructionDataBuilder: target buffer too small");
+    const slice = target.subarray(offset, offset + size);
+    this.__tnWriteInto(slice);
+    this.__tnValidateOrThrow(slice, params);
+    return target;
+  }
+  finish() {
+    const buffer = this.build();
+    const params = this.__tnLastParams ?? this.__tnComputeParams();
+    const view = InstructionData.from_array(buffer, { params });
+    if (!view) throw new Error("InstructionDataBuilder: failed to finalize view");
+    return view;
+  }
+  finishView() {
+    return this.finish();
+  }
+  dynamicParams() {
+    return this.__tnComputeParams();
+  }
+  __tnComputeParams() {
+    if (this.__tnCachedParams) return this.__tnCachedParams;
+    const params = InstructionData.Params.fromValues({
+      data_data_size: (() => {
+        if (this.__tnFam_dataCount === null) throw new Error("InstructionDataBuilder: field 'data' must be written before computing params");
+        return __tnToBigInt(this.__tnFam_dataCount);
+      })()
+    });
+    this.__tnCachedParams = params;
+    return params;
+  }
+  __tnWriteInto(target) {
+    target.set(this.buffer, 0);
+    let cursor = this.buffer.length;
+    const __tnLocal_data_bytes = this.__tnFam_data;
+    if (!__tnLocal_data_bytes) throw new Error("InstructionDataBuilder: field 'data' must be written before build");
+    target.set(__tnLocal_data_bytes, cursor);
+    cursor += __tnLocal_data_bytes.length;
+  }
+  __tnValidateOrThrow(buffer, params) {
+    const result = InstructionData.validate(buffer, { params });
+    if (!result.ok) {
+      throw new Error(`${InstructionData}Builder: builder produced invalid buffer (code=${result.code ?? "unknown"})`);
+    }
+    this.__tnLastParams = result.params ?? params;
+    this.__tnLastBuffer = buffer;
   }
 };
+__tnRegisterFootprint("InstructionData", (params) => InstructionData.__tnInvokeFootprint(params));
+__tnRegisterValidate("InstructionData", (buffer, params) => InstructionData.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("InstructionData", (buffer) => {
+  const result = InstructionData.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed), params };
+});
 var __tn_ir_Pubkey = {
   typeName: "Pubkey",
   root: { op: "const", value: 32n }
@@ -590,8 +1425,6 @@ var Pubkey = class _Pubkey {
     return new _Pubkey(buffer);
   }
 };
-__tnRegisterFootprint("Pubkey", (params) => Pubkey.__tnInvokeFootprint(params));
-__tnRegisterValidate("Pubkey", (buffer, params) => Pubkey.__tnInvokeValidate(buffer, params));
 var PubkeyBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(32);
@@ -619,6 +1452,13 @@ var PubkeyBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint("Pubkey", (params) => Pubkey.__tnInvokeFootprint(params));
+__tnRegisterValidate("Pubkey", (buffer, params) => Pubkey.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Pubkey", (buffer) => {
+  const result = Pubkey.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed), params };
+});
 var __tn_ir_Signature = {
   typeName: "Signature",
   root: { op: "const", value: 64n }
@@ -701,8 +1541,6 @@ var Signature = class _Signature {
     return new _Signature(buffer);
   }
 };
-__tnRegisterFootprint("Signature", (params) => Signature.__tnInvokeFootprint(params));
-__tnRegisterValidate("Signature", (buffer, params) => Signature.__tnInvokeValidate(buffer, params));
 var SignatureBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(64);
@@ -730,6 +1568,123 @@ var SignatureBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint("Signature", (params) => Signature.__tnInvokeFootprint(params));
+__tnRegisterValidate("Signature", (buffer, params) => Signature.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Signature", (buffer) => {
+  const result = Signature.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed), params };
+});
+var __tn_ir_Timestamp = {
+  typeName: "Timestamp",
+  root: { op: "const", value: 8n }
+};
+var Timestamp = class _Timestamp {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  static __tnCreateView(buffer, opts) {
+    if (!buffer || buffer.length === void 0) throw new Error("Timestamp.__tnCreateView requires a Uint8Array");
+    return new _Timestamp(new Uint8Array(buffer));
+  }
+  static builder() {
+    return new TimestampBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    return _Timestamp.from_array(buffer);
+  }
+  get_seconds() {
+    const offset = 0;
+    return this.view.getBigInt64(offset, true);
+  }
+  set_seconds(value) {
+    const offset = 0;
+    this.view.setBigInt64(offset, value, true);
+  }
+  get seconds() {
+    return this.get_seconds();
+  }
+  set seconds(value) {
+    this.set_seconds(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint(__tn_ir_Timestamp.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree(__tn_ir_Timestamp, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr() {
+    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  }
+  static footprint() {
+    const irResult = this.footprintIr();
+    const maxSafe = __tnToBigInt(Number.MAX_SAFE_INTEGER);
+    if (__tnBigIntGreaterThan(irResult, maxSafe)) {
+      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for Timestamp");
+    }
+    return __tnBigIntToNumber(irResult, "Timestamp::footprint");
+  }
+  static validate(buffer, _opts) {
+    if (buffer.length < 8) return { ok: false, code: "tn.buffer_too_small", consumed: 8 };
+    return { ok: true, consumed: 8 };
+  }
+  static new(seconds) {
+    const buffer = new Uint8Array(8);
+    const view = new DataView(buffer.buffer);
+    view.setBigInt64(0, seconds, true);
+    return new _Timestamp(buffer);
+  }
+  static from_array(buffer) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const validation = this.validate(buffer);
+    if (!validation.ok) {
+      return null;
+    }
+    return new _Timestamp(buffer);
+  }
+};
+var TimestampBuilder = class {
+  constructor() {
+    this.buffer = new Uint8Array(8);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  set_seconds(value) {
+    const cast = __tnToBigInt(value);
+    this.view.setBigInt64(0, cast, true);
+    return this;
+  }
+  build() {
+    return this.buffer.slice();
+  }
+  buildInto(target, offset = 0) {
+    if (target.length - offset < this.buffer.length) throw new Error("target buffer too small");
+    target.set(this.buffer, offset);
+    return target;
+  }
+  finish() {
+    const view = Timestamp.from_array(this.buffer.slice());
+    if (!view) throw new Error("failed to build Timestamp");
+    return view;
+  }
+};
+__tnRegisterFootprint("Timestamp", (params) => Timestamp.__tnInvokeFootprint(params));
+__tnRegisterValidate("Timestamp", (buffer, params) => Timestamp.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Timestamp", (buffer) => {
+  const result = Timestamp.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed), params };
+});
 
 // src/token/abi/thru/blockchain/state_proof/types.ts
 var __tnWarnings2 = /* @__PURE__ */ new Set();
@@ -747,7 +1702,7 @@ function __tnWarnOnce2(message) {
     __tnLogWarn2(message);
   }
 }
-function __tnResolveBuilderInput(input, context) {
+function __tnResolveBuilderInput2(input, context) {
   if (input instanceof Uint8Array) {
     return new Uint8Array(input);
   }
@@ -769,7 +1724,7 @@ function __tnCreateVariantSelector(parent, descriptors, assign) {
       }
       return {
         writePayload(payload) {
-          const bytes = __tnResolveBuilderInput(
+          const bytes = __tnResolveBuilderInput2(
             payload,
             `variant ${descriptor.name}`
           );
@@ -1022,12 +1977,16 @@ if (typeof DataView !== "undefined" && !__tnHasBigIntDataView2) {
 }
 var __tnFootprintRegistry2 = {};
 var __tnValidateRegistry2 = {};
+var __tnDynamicValidateRegistry2 = {};
 function __tnRegisterFootprint2(typeName, fn) {
   __tnFootprintRegistry2[typeName] = fn;
 }
 function __tnRegisterValidate2(typeName, fn) {
   __tnValidateRegistry2[typeName] = fn;
 }
+function __tnRegisterDynamicValidate2(typeName, fn) {
+  __tnDynamicValidateRegistry2[typeName] = fn;
+}
 function __tnInvokeFootprint2(typeName, params) {
   const fn = __tnFootprintRegistry2[typeName];
   if (!fn) throw new Error(`IR runtime missing footprint for ${typeName}`);
@@ -1038,12 +1997,17 @@ function __tnInvokeValidate2(typeName, buffer, params) {
   if (!fn) throw new Error(`IR runtime missing validate helper for ${typeName}`);
   return fn(buffer, params);
 }
+function __tnInvokeDynamicValidate2(typeName, buffer) {
+  const fn = __tnDynamicValidateRegistry2[typeName];
+  if (!fn) throw new Error(`IR runtime missing dynamic validate helper for ${typeName}`);
+  return fn(buffer);
+}
 function __tnEvalFootprint2(node, ctx) {
-  return __tnEvalIrNode2(node, ctx);
+  return __tnEvalIrNode2(node, ctx, __tnToBigInt2(0));
 }
 function __tnTryEvalIr2(node, ctx) {
   try {
-    return { ok: true, value: __tnEvalIrNode2(node, ctx) };
+    return { ok: true, value: __tnEvalIrNode2(node, ctx, __tnToBigInt2(0)) };
   } catch (err) {
     return { ok: false, code: __tnNormalizeIrError2(err) };
   }
@@ -1067,7 +2031,7 @@ function __tnValidateIrTree2(ir, buffer, params) {
   }
   return { ok: true, consumed: required };
 }
-function __tnEvalIrNode2(node, ctx) {
+function __tnEvalIrNode2(node, ctx, baseOffset) {
   switch (node.op) {
     case "zero":
       return __tnToBigInt2(0);
@@ -1084,18 +2048,22 @@ function __tnEvalIrNode2(node, ctx) {
       }
       return val;
     }
-    case "add":
-      return __tnCheckedAdd2(
-        __tnEvalIrNode2(node.left, ctx),
-        __tnEvalIrNode2(node.right, ctx)
+    case "add": {
+      const left = __tnEvalIrNode2(node.left, ctx, baseOffset);
+      const right = __tnEvalIrNode2(
+        node.right,
+        ctx,
+        __tnCheckedAdd2(baseOffset, left)
       );
+      return __tnCheckedAdd2(left, right);
+    }
     case "mul":
       return __tnCheckedMul2(
-        __tnEvalIrNode2(node.left, ctx),
-        __tnEvalIrNode2(node.right, ctx)
+        __tnEvalIrNode2(node.left, ctx, baseOffset),
+        __tnEvalIrNode2(node.right, ctx, baseOffset)
       );
     case "align":
-      return __tnAlign2(__tnEvalIrNode2(node.node, ctx), node.alignment);
+      return __tnAlign2(__tnEvalIrNode2(node.node, ctx, baseOffset), node.alignment);
     case "switch": {
       const tagVal = ctx.params[node.tag];
       if (tagVal === void 0) {
@@ -1108,10 +2076,10 @@ function __tnEvalIrNode2(node, ctx) {
       const tagNumber = Number(tagVal);
       for (const caseNode of node.cases) {
         if (caseNode.value === tagNumber) {
-          return __tnEvalIrNode2(caseNode.node, ctx);
+          return __tnEvalIrNode2(caseNode.node, ctx, baseOffset);
         }
       }
-      if (node.default) return __tnEvalIrNode2(node.default, ctx);
+      if (node.default) return __tnEvalIrNode2(node.default, ctx, baseOffset);
       __tnRaiseIrError2(
         "tn.ir.invalid_tag",
         `Unhandled IR switch value ${tagNumber} for '${node.tag}'`
@@ -1131,9 +2099,10 @@ function __tnEvalIrNode2(node, ctx) {
         nestedParams[arg.name] = val;
       }
       if (ctx.buffer) {
+        const nestedOffset = __tnBigIntToNumber2(baseOffset, "IR nested offset");
         const nestedResult = __tnInvokeValidate2(
           node.typeName,
-          ctx.buffer,
+          ctx.buffer.subarray(nestedOffset),
           nestedParams
         );
         if (!nestedResult.ok) {
@@ -1150,6 +2119,36 @@ function __tnEvalIrNode2(node, ctx) {
       }
       return __tnInvokeFootprint2(node.typeName, nestedParams);
     }
+    case "sumOverArray": {
+      if (!ctx.buffer) {
+        __tnRaiseIrError2(
+          "tn.ir.missing_buffer",
+          `Jagged array '${node.fieldName}' requires buffer-backed validation`
+        );
+      }
+      const count = __tnBigIntToNumber2(
+        __tnEvalIrNode2(node.count, ctx, baseOffset),
+        `Jagged array '${node.fieldName}' count`
+      );
+      let cursor = __tnBigIntToNumber2(baseOffset, "IR jagged array offset");
+      let total = __tnToBigInt2(0);
+      for (let i = 0; i < count; i++) {
+        const result = __tnInvokeDynamicValidate2(
+          node.elementTypeName,
+          ctx.buffer.subarray(cursor)
+        );
+        if (!result.ok || result.consumed === void 0) {
+          const code = result.code ?? "tn.ir.runtime_error";
+          __tnRaiseIrError2(
+            code,
+            `Jagged array '${node.fieldName}' element ${i} failed validation`
+          );
+        }
+        cursor += __tnBigIntToNumber2(result.consumed, "IR jagged element size");
+        total = __tnCheckedAdd2(total, result.consumed);
+      }
+      return total;
+    }
     default:
       __tnRaiseIrError2(
         "tn.ir.runtime_error",
@@ -1173,6 +2172,20 @@ function __tnNormalizeIrError2(err) {
   if (message.length > 0) return `tn.ir.runtime_error: ${message}`;
   return "tn.ir.runtime_error";
 }
+__tnRegisterFootprint2("Hash", (params) => Hash.__tnInvokeFootprint(params));
+__tnRegisterValidate2("Hash", (buffer, params) => Hash.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate2("Hash", (buffer) => {
+  const result = Hash.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt2(result.consumed), params };
+});
+__tnRegisterFootprint2("Pubkey", (params) => Pubkey.__tnInvokeFootprint(params));
+__tnRegisterValidate2("Pubkey", (buffer, params) => Pubkey.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate2("Pubkey", (buffer) => {
+  const result = Pubkey.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt2(result.consumed), params };
+});
 var __tn_ir_StateProofHeader = {
   typeName: "StateProofHeader",
   root: { op: "const", value: 40n }
@@ -1262,8 +2275,6 @@ var StateProofHeader = class _StateProofHeader {
     return new _StateProofHeader(buffer);
   }
 };
-__tnRegisterFootprint2("StateProofHeader", (params) => StateProofHeader.__tnInvokeFootprint(params));
-__tnRegisterValidate2("StateProofHeader", (buffer, params) => StateProofHeader.__tnInvokeValidate(buffer, params));
 var StateProofHeaderBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(40);
@@ -1293,6 +2304,13 @@ var StateProofHeaderBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint2("StateProofHeader", (params) => StateProofHeader.__tnInvokeFootprint(params));
+__tnRegisterValidate2("StateProofHeader", (buffer, params) => StateProofHeader.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate2("StateProofHeader", (buffer) => {
+  const result = StateProofHeader.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt2(result.consumed), params };
+});
 var __tn_ir_StateProof = {
   typeName: "StateProof",
   root: { op: "align", alignment: 1, node: { op: "add", left: { op: "align", alignment: 1, node: { op: "const", value: 40n } }, right: { op: "align", alignment: 1, node: { op: "field", param: "proof_body.payload_size" } } } }
@@ -1864,8 +2882,6 @@ var StateProof = _StateProof;
   }
   StateProof2.params = params;
 })(StateProof || (StateProof = {}));
-__tnRegisterFootprint2("StateProof", (params) => StateProof.__tnInvokeFootprint(params));
-__tnRegisterValidate2("StateProof", (buffer, params) => StateProof.__tnInvokeValidate(buffer, params));
 var StateProofBuilder = class {
   constructor() {
     this.__tnPayload_proof_body = null;
@@ -1972,6 +2988,13 @@ var StateProofBuilder = class {
     this.__tnLastBuffer = buffer;
   }
 };
+__tnRegisterFootprint2("StateProof", (params) => StateProof.__tnInvokeFootprint(params));
+__tnRegisterValidate2("StateProof", (buffer, params) => StateProof.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate2("StateProof", (buffer) => {
+  const result = StateProof.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt2(result.consumed), params };
+});
 
 // src/token/abi/thru/program/token/types.ts
 var __tnWarnings3 = /* @__PURE__ */ new Set();
@@ -1989,7 +3012,7 @@ function __tnWarnOnce3(message) {
     __tnLogWarn3(message);
   }
 }
-function __tnResolveBuilderInput2(input, context) {
+function __tnResolveBuilderInput3(input, context) {
   if (input instanceof Uint8Array) {
     return new Uint8Array(input);
   }
@@ -2004,7 +3027,7 @@ function __tnResolveBuilderInput2(input, context) {
 }
 function __tnResolveStructFieldInput(input, context) {
   if (input instanceof Uint8Array || input && typeof input.build === "function") {
-    return __tnResolveBuilderInput2(input, context);
+    return __tnResolveBuilderInput3(input, context);
   }
   if (input && typeof input.asUint8Array === "function") {
     const bytes = input.asUint8Array();
@@ -2035,7 +3058,7 @@ function __tnCreateVariantSelector2(parent, descriptors, assign) {
       }
       return {
         writePayload(payload) {
-          const bytes = __tnResolveBuilderInput2(
+          const bytes = __tnResolveBuilderInput3(
             payload,
             `variant ${descriptor.name}`
           );
@@ -2282,12 +3305,16 @@ if (typeof DataView !== "undefined" && !__tnHasBigIntDataView3) {
 }
 var __tnFootprintRegistry3 = {};
 var __tnValidateRegistry3 = {};
+var __tnDynamicValidateRegistry3 = {};
 function __tnRegisterFootprint3(typeName, fn) {
   __tnFootprintRegistry3[typeName] = fn;
 }
 function __tnRegisterValidate3(typeName, fn) {
   __tnValidateRegistry3[typeName] = fn;
 }
+function __tnRegisterDynamicValidate3(typeName, fn) {
+  __tnDynamicValidateRegistry3[typeName] = fn;
+}
 function __tnInvokeFootprint3(typeName, params) {
   const fn = __tnFootprintRegistry3[typeName];
   if (!fn) throw new Error(`IR runtime missing footprint for ${typeName}`);
@@ -2298,12 +3325,17 @@ function __tnInvokeValidate3(typeName, buffer, params) {
   if (!fn) throw new Error(`IR runtime missing validate helper for ${typeName}`);
   return fn(buffer, params);
 }
+function __tnInvokeDynamicValidate3(typeName, buffer) {
+  const fn = __tnDynamicValidateRegistry3[typeName];
+  if (!fn) throw new Error(`IR runtime missing dynamic validate helper for ${typeName}`);
+  return fn(buffer);
+}
 function __tnEvalFootprint3(node, ctx) {
-  return __tnEvalIrNode3(node, ctx);
+  return __tnEvalIrNode3(node, ctx, __tnToBigInt3(0));
 }
 function __tnTryEvalIr3(node, ctx) {
   try {
-    return { ok: true, value: __tnEvalIrNode3(node, ctx) };
+    return { ok: true, value: __tnEvalIrNode3(node, ctx, __tnToBigInt3(0)) };
   } catch (err) {
     return { ok: false, code: __tnNormalizeIrError3(err) };
   }
@@ -2327,7 +3359,7 @@ function __tnValidateIrTree3(ir, buffer, params) {
   }
   return { ok: true, consumed: required };
 }
-function __tnEvalIrNode3(node, ctx) {
+function __tnEvalIrNode3(node, ctx, baseOffset) {
   switch (node.op) {
     case "zero":
       return __tnToBigInt3(0);
@@ -2344,18 +3376,22 @@ function __tnEvalIrNode3(node, ctx) {
       }
       return val;
     }
-    case "add":
-      return __tnCheckedAdd3(
-        __tnEvalIrNode3(node.left, ctx),
-        __tnEvalIrNode3(node.right, ctx)
+    case "add": {
+      const left = __tnEvalIrNode3(node.left, ctx, baseOffset);
+      const right = __tnEvalIrNode3(
+        node.right,
+        ctx,
+        __tnCheckedAdd3(baseOffset, left)
       );
+      return __tnCheckedAdd3(left, right);
+    }
     case "mul":
       return __tnCheckedMul3(
-        __tnEvalIrNode3(node.left, ctx),
-        __tnEvalIrNode3(node.right, ctx)
+        __tnEvalIrNode3(node.left, ctx, baseOffset),
+        __tnEvalIrNode3(node.right, ctx, baseOffset)
       );
     case "align":
-      return __tnAlign3(__tnEvalIrNode3(node.node, ctx), node.alignment);
+      return __tnAlign3(__tnEvalIrNode3(node.node, ctx, baseOffset), node.alignment);
     case "switch": {
       const tagVal = ctx.params[node.tag];
       if (tagVal === void 0) {
@@ -2368,10 +3404,10 @@ function __tnEvalIrNode3(node, ctx) {
       const tagNumber = Number(tagVal);
       for (const caseNode of node.cases) {
         if (caseNode.value === tagNumber) {
-          return __tnEvalIrNode3(caseNode.node, ctx);
+          return __tnEvalIrNode3(caseNode.node, ctx, baseOffset);
         }
       }
-      if (node.default) return __tnEvalIrNode3(node.default, ctx);
+      if (node.default) return __tnEvalIrNode3(node.default, ctx, baseOffset);
       __tnRaiseIrError3(
         "tn.ir.invalid_tag",
         `Unhandled IR switch value ${tagNumber} for '${node.tag}'`
@@ -2391,9 +3427,10 @@ function __tnEvalIrNode3(node, ctx) {
         nestedParams[arg.name] = val;
       }
       if (ctx.buffer) {
+        const nestedOffset = __tnBigIntToNumber3(baseOffset, "IR nested offset");
         const nestedResult = __tnInvokeValidate3(
           node.typeName,
-          ctx.buffer,
+          ctx.buffer.subarray(nestedOffset),
           nestedParams
         );
         if (!nestedResult.ok) {
@@ -2410,6 +3447,36 @@ function __tnEvalIrNode3(node, ctx) {
       }
       return __tnInvokeFootprint3(node.typeName, nestedParams);
     }
+    case "sumOverArray": {
+      if (!ctx.buffer) {
+        __tnRaiseIrError3(
+          "tn.ir.missing_buffer",
+          `Jagged array '${node.fieldName}' requires buffer-backed validation`
+        );
+      }
+      const count = __tnBigIntToNumber3(
+        __tnEvalIrNode3(node.count, ctx, baseOffset),
+        `Jagged array '${node.fieldName}' count`
+      );
+      let cursor = __tnBigIntToNumber3(baseOffset, "IR jagged array offset");
+      let total = __tnToBigInt3(0);
+      for (let i = 0; i < count; i++) {
+        const result = __tnInvokeDynamicValidate3(
+          node.elementTypeName,
+          ctx.buffer.subarray(cursor)
+        );
+        if (!result.ok || result.consumed === void 0) {
+          const code = result.code ?? "tn.ir.runtime_error";
+          __tnRaiseIrError3(
+            code,
+            `Jagged array '${node.fieldName}' element ${i} failed validation`
+          );
+        }
+        cursor += __tnBigIntToNumber3(result.consumed, "IR jagged element size");
+        total = __tnCheckedAdd3(total, result.consumed);
+      }
+      return total;
+    }
     default:
       __tnRaiseIrError3(
         "tn.ir.runtime_error",
@@ -2433,6 +3500,20 @@ function __tnNormalizeIrError3(err) {
   if (message.length > 0) return `tn.ir.runtime_error: ${message}`;
   return "tn.ir.runtime_error";
 }
+__tnRegisterFootprint3("Pubkey", (params) => Pubkey.__tnInvokeFootprint(params));
+__tnRegisterValidate3("Pubkey", (buffer, params) => Pubkey.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("Pubkey", (buffer) => {
+  const result = Pubkey.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
+__tnRegisterFootprint3("StateProof", (params) => StateProof.__tnInvokeFootprint(params));
+__tnRegisterValidate3("StateProof", (buffer, params) => StateProof.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("StateProof", (buffer) => {
+  const result = StateProof.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_BurnInstruction = {
   typeName: "BurnInstruction",
   root: { op: "const", value: 14n }
@@ -2557,8 +3638,6 @@ var BurnInstruction = class _BurnInstruction {
     return new _BurnInstruction(buffer);
   }
 };
-__tnRegisterFootprint3("BurnInstruction", (params) => BurnInstruction.__tnInvokeFootprint(params));
-__tnRegisterValidate3("BurnInstruction", (buffer, params) => BurnInstruction.__tnInvokeValidate(buffer, params));
 var BurnInstructionBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(14);
@@ -2595,6 +3674,13 @@ var BurnInstructionBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("BurnInstruction", (params) => BurnInstruction.__tnInvokeFootprint(params));
+__tnRegisterValidate3("BurnInstruction", (buffer, params) => BurnInstruction.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("BurnInstruction", (buffer) => {
+  const result = BurnInstruction.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_CloseAccountInstruction = {
   typeName: "CloseAccountInstruction",
   root: { op: "const", value: 6n }
@@ -2704,8 +3790,6 @@ var CloseAccountInstruction = class _CloseAccountInstruction {
     return new _CloseAccountInstruction(buffer);
   }
 };
-__tnRegisterFootprint3("CloseAccountInstruction", (params) => CloseAccountInstruction.__tnInvokeFootprint(params));
-__tnRegisterValidate3("CloseAccountInstruction", (buffer, params) => CloseAccountInstruction.__tnInvokeValidate(buffer, params));
 var CloseAccountInstructionBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(6);
@@ -2737,6 +3821,13 @@ var CloseAccountInstructionBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("CloseAccountInstruction", (params) => CloseAccountInstruction.__tnInvokeFootprint(params));
+__tnRegisterValidate3("CloseAccountInstruction", (buffer, params) => CloseAccountInstruction.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("CloseAccountInstruction", (buffer) => {
+  const result = CloseAccountInstruction.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_FreezeAccountInstruction = {
   typeName: "FreezeAccountInstruction",
   root: { op: "const", value: 6n }
@@ -2846,8 +3937,6 @@ var FreezeAccountInstruction = class _FreezeAccountInstruction {
     return new _FreezeAccountInstruction(buffer);
   }
 };
-__tnRegisterFootprint3("FreezeAccountInstruction", (params) => FreezeAccountInstruction.__tnInvokeFootprint(params));
-__tnRegisterValidate3("FreezeAccountInstruction", (buffer, params) => FreezeAccountInstruction.__tnInvokeValidate(buffer, params));
 var FreezeAccountInstructionBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(6);
@@ -2879,6 +3968,13 @@ var FreezeAccountInstructionBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("FreezeAccountInstruction", (params) => FreezeAccountInstruction.__tnInvokeFootprint(params));
+__tnRegisterValidate3("FreezeAccountInstruction", (buffer, params) => FreezeAccountInstruction.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("FreezeAccountInstruction", (buffer) => {
+  const result = FreezeAccountInstruction.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_MintToInstruction = {
   typeName: "MintToInstruction",
   root: { op: "const", value: 14n }
@@ -3003,8 +4099,6 @@ var MintToInstruction = class _MintToInstruction {
     return new _MintToInstruction(buffer);
   }
 };
-__tnRegisterFootprint3("MintToInstruction", (params) => MintToInstruction.__tnInvokeFootprint(params));
-__tnRegisterValidate3("MintToInstruction", (buffer, params) => MintToInstruction.__tnInvokeValidate(buffer, params));
 var MintToInstructionBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(14);
@@ -3041,6 +4135,13 @@ var MintToInstructionBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("MintToInstruction", (params) => MintToInstruction.__tnInvokeFootprint(params));
+__tnRegisterValidate3("MintToInstruction", (buffer, params) => MintToInstruction.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("MintToInstruction", (buffer) => {
+  const result = MintToInstruction.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_Seed32 = {
   typeName: "Seed32",
   root: { op: "const", value: 32n }
@@ -3122,6 +4223,11 @@ _Seed32.__tnElementCount = 32;
 var Seed32 = _Seed32;
 __tnRegisterFootprint3("Seed32", (params) => Seed32.__tnInvokeFootprint(params));
 __tnRegisterValidate3("Seed32", (buffer, params) => Seed32.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("Seed32", (buffer) => {
+  const result = Seed32.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_ThawAccountEventData = {
   typeName: "ThawAccountEventData",
   root: { op: "const", value: 96n }
@@ -3229,8 +4335,6 @@ var ThawAccountEventData = class _ThawAccountEventData {
     return new _ThawAccountEventData(buffer);
   }
 };
-__tnRegisterFootprint3("ThawAccountEventData", (params) => ThawAccountEventData.__tnInvokeFootprint(params));
-__tnRegisterValidate3("ThawAccountEventData", (buffer, params) => ThawAccountEventData.__tnInvokeValidate(buffer, params));
 var ThawAccountEventDataBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(96);
@@ -3265,6 +4369,13 @@ var ThawAccountEventDataBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("ThawAccountEventData", (params) => ThawAccountEventData.__tnInvokeFootprint(params));
+__tnRegisterValidate3("ThawAccountEventData", (buffer, params) => ThawAccountEventData.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("ThawAccountEventData", (buffer) => {
+  const result = ThawAccountEventData.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_ThawAccountInstruction = {
   typeName: "ThawAccountInstruction",
   root: { op: "const", value: 6n }
@@ -3374,8 +4485,6 @@ var ThawAccountInstruction = class _ThawAccountInstruction {
     return new _ThawAccountInstruction(buffer);
   }
 };
-__tnRegisterFootprint3("ThawAccountInstruction", (params) => ThawAccountInstruction.__tnInvokeFootprint(params));
-__tnRegisterValidate3("ThawAccountInstruction", (buffer, params) => ThawAccountInstruction.__tnInvokeValidate(buffer, params));
 var ThawAccountInstructionBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(6);
@@ -3407,6 +4516,13 @@ var ThawAccountInstructionBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("ThawAccountInstruction", (params) => ThawAccountInstruction.__tnInvokeFootprint(params));
+__tnRegisterValidate3("ThawAccountInstruction", (buffer, params) => ThawAccountInstruction.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("ThawAccountInstruction", (buffer) => {
+  const result = ThawAccountInstruction.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_TickerField = {
   typeName: "TickerField",
   root: { op: "const", value: 9n }
@@ -3503,8 +4619,6 @@ var TickerField = class _TickerField {
     return new _TickerField(buffer);
   }
 };
-__tnRegisterFootprint3("TickerField", (params) => TickerField.__tnInvokeFootprint(params));
-__tnRegisterValidate3("TickerField", (buffer, params) => TickerField.__tnInvokeValidate(buffer, params));
 var TickerFieldBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(9);
@@ -3536,6 +4650,13 @@ var TickerFieldBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("TickerField", (params) => TickerField.__tnInvokeFootprint(params));
+__tnRegisterValidate3("TickerField", (buffer, params) => TickerField.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("TickerField", (buffer) => {
+  const result = TickerField.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_TokenAccount = {
   typeName: "TokenAccount",
   root: { op: "const", value: 73n }
@@ -3655,8 +4776,6 @@ var TokenAccount = class _TokenAccount {
     return new _TokenAccount(buffer);
   }
 };
-__tnRegisterFootprint3("TokenAccount", (params) => TokenAccount.__tnInvokeFootprint(params));
-__tnRegisterValidate3("TokenAccount", (buffer, params) => TokenAccount.__tnInvokeValidate(buffer, params));
 var TokenAccountBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(73);
@@ -3695,6 +4814,13 @@ var TokenAccountBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("TokenAccount", (params) => TokenAccount.__tnInvokeFootprint(params));
+__tnRegisterValidate3("TokenAccount", (buffer, params) => TokenAccount.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("TokenAccount", (buffer) => {
+  const result = TokenAccount.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_TokenMintAccount = {
   typeName: "TokenMintAccount",
   root: { op: "const", value: 115n }
@@ -3860,8 +4986,6 @@ var TokenMintAccount = class _TokenMintAccount {
     return new _TokenMintAccount(buffer);
   }
 };
-__tnRegisterFootprint3("TokenMintAccount", (params) => TokenMintAccount.__tnInvokeFootprint(params));
-__tnRegisterValidate3("TokenMintAccount", (buffer, params) => TokenMintAccount.__tnInvokeValidate(buffer, params));
 var TokenMintAccountBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(115);
@@ -3914,6 +5038,13 @@ var TokenMintAccountBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("TokenMintAccount", (params) => TokenMintAccount.__tnInvokeFootprint(params));
+__tnRegisterValidate3("TokenMintAccount", (buffer, params) => TokenMintAccount.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("TokenMintAccount", (buffer) => {
+  const result = TokenMintAccount.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_TokenProgramAccount = {
   typeName: "TokenProgramAccount",
   root: { op: "align", alignment: 1, node: { op: "align", alignment: 1, node: { op: "switch", tag: "TokenProgramAccount::data.payload_size", cases: [{ value: 73, node: { op: "align", alignment: 1, node: { op: "const", value: 73n } } }, { value: 115, node: { op: "align", alignment: 1, node: { op: "const", value: 115n } } }] } } }
@@ -3950,7 +5081,6 @@ var TokenProgramAccount = class _TokenProgramAccount {
   static __tnComputeSequentialLayout(view, buffer) {
     const __tnLength = buffer.length;
     let __tnParamSeq_data_payload_size = null;
-    let __tnParamSeq_TokenProgramAccount__data_payload_size = null;
     let __tnCursorMutable = 0;
     const __tnSduAvailable_data = __tnLength - __tnCursorMutable;
     let __tnSduSize_data = -1;
@@ -3965,13 +5095,10 @@ var TokenProgramAccount = class _TokenProgramAccount {
         return null;
     }
     __tnParamSeq_data_payload_size = __tnToBigInt3(__tnSduSize_data);
-    __tnParamSeq_TokenProgramAccount__data_payload_size = __tnToBigInt3(__tnSduSize_data);
     __tnCursorMutable += __tnSduSize_data;
     const params = /* @__PURE__ */ Object.create(null);
     if (__tnParamSeq_data_payload_size === null) return null;
     params["data_payload_size"] = __tnParamSeq_data_payload_size;
-    if (__tnParamSeq_TokenProgramAccount__data_payload_size === null) return null;
-    params["TokenProgramAccount__data_payload_size"] = __tnParamSeq_TokenProgramAccount__data_payload_size;
     return { params, offsets: null, derived: null };
   }
   static __tnExtractParams(view, buffer) {
@@ -3980,11 +5107,8 @@ var TokenProgramAccount = class _TokenProgramAccount {
     const __tnSeqParams = __tnLayout.params;
     const __tnParamSeq_data_payload_size = __tnSeqParams["data_payload_size"];
     if (__tnParamSeq_data_payload_size === void 0) return null;
-    const __tnParamSeq_TokenProgramAccount__data_payload_size = __tnSeqParams["TokenProgramAccount__data_payload_size"];
-    if (__tnParamSeq_TokenProgramAccount__data_payload_size === void 0) return null;
     const __tnExtractedParams = _TokenProgramAccount.Params.fromValues({
-      data_payload_size: __tnParamSeq_data_payload_size,
-      TokenProgramAccount__data_payload_size: __tnParamSeq_TokenProgramAccount__data_payload_size
+      data_payload_size: __tnParamSeq_data_payload_size
     });
     return { params: __tnExtractedParams, derived: null };
   }
@@ -4000,17 +5124,16 @@ var TokenProgramAccount = class _TokenProgramAccount {
   static __tnInvokeValidate(buffer, __tnParams) {
     return this.__tnValidateInternal(buffer, __tnParams);
   }
-  static footprintIr(data_payload_size, TokenProgramAccount__data_payload_size) {
+  static footprintIr(data_payload_size) {
     const params = _TokenProgramAccount.Params.fromValues({
-      data_payload_size,
-      TokenProgramAccount__data_payload_size
+      data_payload_size
     });
     return this.footprintIrFromParams(params);
   }
   static __tnPackParams(params) {
     const record = /* @__PURE__ */ Object.create(null);
     record["data.payload_size"] = params.data_payload_size;
-    record["TokenProgramAccount::data.payload_size"] = params.TokenProgramAccount__data_payload_size;
+    record["TokenProgramAccount::data.payload_size"] = params.data_payload_size;
     return record;
   }
   static footprintIrFromParams(params) {
@@ -4071,14 +5194,12 @@ var TokenProgramAccount = class _TokenProgramAccount {
 };
 ((TokenProgramAccount2) => {
   TokenProgramAccount2.ParamKeys = Object.freeze({
-    data_payload_size: "data.payload_size",
-    TokenProgramAccount__data_payload_size: "TokenProgramAccount::data.payload_size"
+    data_payload_size: "data.payload_size"
   });
   TokenProgramAccount2.Params = {
     fromValues(input) {
       return {
-        data_payload_size: __tnToBigInt3(input.data_payload_size),
-        TokenProgramAccount__data_payload_size: __tnToBigInt3(input.TokenProgramAccount__data_payload_size)
+        data_payload_size: __tnToBigInt3(input.data_payload_size)
       };
     },
     fromBuilder(source) {
@@ -4098,6 +5219,11 @@ var TokenProgramAccount = class _TokenProgramAccount {
 })(TokenProgramAccount || (TokenProgramAccount = {}));
 __tnRegisterFootprint3("TokenProgramAccount", (params) => TokenProgramAccount.__tnInvokeFootprint(params));
 __tnRegisterValidate3("TokenProgramAccount", (buffer, params) => TokenProgramAccount.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("TokenProgramAccount", (buffer) => {
+  const result = TokenProgramAccount.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_TransferEventData = {
   typeName: "TransferEventData",
   root: { op: "const", value: 88n }
@@ -4231,8 +5357,6 @@ var TransferEventData = class _TransferEventData {
     return new _TransferEventData(buffer);
   }
 };
-__tnRegisterFootprint3("TransferEventData", (params) => TransferEventData.__tnInvokeFootprint(params));
-__tnRegisterValidate3("TransferEventData", (buffer, params) => TransferEventData.__tnInvokeValidate(buffer, params));
 var TransferEventDataBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(88);
@@ -4277,6 +5401,13 @@ var TransferEventDataBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("TransferEventData", (params) => TransferEventData.__tnInvokeFootprint(params));
+__tnRegisterValidate3("TransferEventData", (buffer, params) => TransferEventData.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("TransferEventData", (buffer) => {
+  const result = TransferEventData.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_TransferInstruction = {
   typeName: "TransferInstruction",
   root: { op: "const", value: 12n }
@@ -4386,8 +5517,6 @@ var TransferInstruction = class _TransferInstruction {
     return new _TransferInstruction(buffer);
   }
 };
-__tnRegisterFootprint3("TransferInstruction", (params) => TransferInstruction.__tnInvokeFootprint(params));
-__tnRegisterValidate3("TransferInstruction", (buffer, params) => TransferInstruction.__tnInvokeValidate(buffer, params));
 var TransferInstructionBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(12);
@@ -4420,6 +5549,13 @@ var TransferInstructionBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("TransferInstruction", (params) => TransferInstruction.__tnInvokeFootprint(params));
+__tnRegisterValidate3("TransferInstruction", (buffer, params) => TransferInstruction.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("TransferInstruction", (buffer) => {
+  const result = TransferInstruction.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_BurnEventData = {
   typeName: "BurnEventData",
   root: { op: "const", value: 120n }
@@ -4569,8 +5705,6 @@ var BurnEventData = class _BurnEventData {
     return new _BurnEventData(buffer);
   }
 };
-__tnRegisterFootprint3("BurnEventData", (params) => BurnEventData.__tnInvokeFootprint(params));
-__tnRegisterValidate3("BurnEventData", (buffer, params) => BurnEventData.__tnInvokeValidate(buffer, params));
 var BurnEventDataBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(120);
@@ -4620,6 +5754,13 @@ var BurnEventDataBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("BurnEventData", (params) => BurnEventData.__tnInvokeFootprint(params));
+__tnRegisterValidate3("BurnEventData", (buffer, params) => BurnEventData.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("BurnEventData", (buffer) => {
+  const result = BurnEventData.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_CloseAccountEventData = {
   typeName: "CloseAccountEventData",
   root: { op: "const", value: 96n }
@@ -4727,8 +5868,6 @@ var CloseAccountEventData = class _CloseAccountEventData {
     return new _CloseAccountEventData(buffer);
   }
 };
-__tnRegisterFootprint3("CloseAccountEventData", (params) => CloseAccountEventData.__tnInvokeFootprint(params));
-__tnRegisterValidate3("CloseAccountEventData", (buffer, params) => CloseAccountEventData.__tnInvokeValidate(buffer, params));
 var CloseAccountEventDataBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(96);
@@ -4763,6 +5902,13 @@ var CloseAccountEventDataBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("CloseAccountEventData", (params) => CloseAccountEventData.__tnInvokeFootprint(params));
+__tnRegisterValidate3("CloseAccountEventData", (buffer, params) => CloseAccountEventData.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("CloseAccountEventData", (buffer) => {
+  const result = CloseAccountEventData.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_FreezeAccountEventData = {
   typeName: "FreezeAccountEventData",
   root: { op: "const", value: 96n }
@@ -4870,8 +6016,6 @@ var FreezeAccountEventData = class _FreezeAccountEventData {
     return new _FreezeAccountEventData(buffer);
   }
 };
-__tnRegisterFootprint3("FreezeAccountEventData", (params) => FreezeAccountEventData.__tnInvokeFootprint(params));
-__tnRegisterValidate3("FreezeAccountEventData", (buffer, params) => FreezeAccountEventData.__tnInvokeValidate(buffer, params));
 var FreezeAccountEventDataBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(96);
@@ -4906,6 +6050,13 @@ var FreezeAccountEventDataBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("FreezeAccountEventData", (params) => FreezeAccountEventData.__tnInvokeFootprint(params));
+__tnRegisterValidate3("FreezeAccountEventData", (buffer, params) => FreezeAccountEventData.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("FreezeAccountEventData", (buffer) => {
+  const result = FreezeAccountEventData.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_InitializeAccountEventData = {
   typeName: "InitializeAccountEventData",
   root: { op: "const", value: 96n }
@@ -5013,8 +6164,6 @@ var InitializeAccountEventData = class _InitializeAccountEventData {
     return new _InitializeAccountEventData(buffer);
   }
 };
-__tnRegisterFootprint3("InitializeAccountEventData", (params) => InitializeAccountEventData.__tnInvokeFootprint(params));
-__tnRegisterValidate3("InitializeAccountEventData", (buffer, params) => InitializeAccountEventData.__tnInvokeValidate(buffer, params));
 var InitializeAccountEventDataBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(96);
@@ -5049,6 +6198,13 @@ var InitializeAccountEventDataBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("InitializeAccountEventData", (params) => InitializeAccountEventData.__tnInvokeFootprint(params));
+__tnRegisterValidate3("InitializeAccountEventData", (buffer, params) => InitializeAccountEventData.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("InitializeAccountEventData", (buffer) => {
+  const result = InitializeAccountEventData.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_InitializeMintEventData = {
   typeName: "InitializeMintEventData",
   root: { op: "const", value: 115n }
@@ -5214,8 +6370,6 @@ var InitializeMintEventData = class _InitializeMintEventData {
     return new _InitializeMintEventData(buffer);
   }
 };
-__tnRegisterFootprint3("InitializeMintEventData", (params) => InitializeMintEventData.__tnInvokeFootprint(params));
-__tnRegisterValidate3("InitializeMintEventData", (buffer, params) => InitializeMintEventData.__tnInvokeValidate(buffer, params));
 var InitializeMintEventDataBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(115);
@@ -5268,6 +6422,13 @@ var InitializeMintEventDataBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("InitializeMintEventData", (params) => InitializeMintEventData.__tnInvokeFootprint(params));
+__tnRegisterValidate3("InitializeMintEventData", (buffer, params) => InitializeMintEventData.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("InitializeMintEventData", (buffer) => {
+  const result = InitializeMintEventData.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_MintToEventData = {
   typeName: "MintToEventData",
   root: { op: "const", value: 120n }
@@ -5417,8 +6578,6 @@ var MintToEventData = class _MintToEventData {
     return new _MintToEventData(buffer);
   }
 };
-__tnRegisterFootprint3("MintToEventData", (params) => MintToEventData.__tnInvokeFootprint(params));
-__tnRegisterValidate3("MintToEventData", (buffer, params) => MintToEventData.__tnInvokeValidate(buffer, params));
 var MintToEventDataBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(120);
@@ -5468,6 +6627,13 @@ var MintToEventDataBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("MintToEventData", (params) => MintToEventData.__tnInvokeFootprint(params));
+__tnRegisterValidate3("MintToEventData", (buffer, params) => MintToEventData.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("MintToEventData", (buffer) => {
+  const result = MintToEventData.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_TokenEvent = {
   typeName: "TokenEvent",
   root: { op: "align", alignment: 1, node: { op: "add", left: { op: "align", alignment: 1, node: { op: "const", value: 1n } }, right: { op: "align", alignment: 1, node: { op: "switch", tag: "TokenEvent::payload.event_type", cases: [{ value: 0, node: { op: "align", alignment: 1, node: { op: "const", value: 115n } } }, { value: 1, node: { op: "align", alignment: 1, node: { op: "const", value: 96n } } }, { value: 2, node: { op: "align", alignment: 1, node: { op: "const", value: 88n } } }, { value: 3, node: { op: "align", alignment: 1, node: { op: "const", value: 120n } } }, { value: 4, node: { op: "align", alignment: 1, node: { op: "const", value: 120n } } }, { value: 5, node: { op: "align", alignment: 1, node: { op: "const", value: 96n } } }, { value: 6, node: { op: "align", alignment: 1, node: { op: "const", value: 96n } } }, { value: 7, node: { op: "align", alignment: 1, node: { op: "const", value: 96n } } }] } } } }
@@ -5564,13 +6730,8 @@ var _TokenEvent = class _TokenEvent {
       return null;
     }
     const __tnParam_payload_event_type = __tnToBigInt3(view.getUint8(0));
-    if (buffer.length < 1) {
-      return null;
-    }
-    const __tnParam_TokenEvent__payload_event_type = __tnToBigInt3(view.getUint8(0));
     const __tnExtractedParams = _TokenEvent.Params.fromValues({
-      payload_event_type: __tnParam_payload_event_type,
-      TokenEvent__payload_event_type: __tnParam_TokenEvent__payload_event_type
+      payload_event_type: __tnParam_payload_event_type
     });
     return { params: __tnExtractedParams, derived: null };
   }
@@ -5614,17 +6775,16 @@ var _TokenEvent = class _TokenEvent {
   static __tnInvokeValidate(buffer, __tnParams) {
     return this.__tnValidateInternal(buffer, __tnParams);
   }
-  static footprintIr(payload_event_type, TokenEvent__payload_event_type) {
+  static footprintIr(payload_event_type) {
     const params = _TokenEvent.Params.fromValues({
-      payload_event_type,
-      TokenEvent__payload_event_type
+      payload_event_type
     });
     return this.footprintIrFromParams(params);
   }
   static __tnPackParams(params) {
     const record = /* @__PURE__ */ Object.create(null);
     record["payload.event_type"] = params.payload_event_type;
-    record["TokenEvent::payload.event_type"] = params.TokenEvent__payload_event_type;
+    record["TokenEvent::payload.event_type"] = params.payload_event_type;
     return record;
   }
   static footprintIrFromParams(params) {
@@ -5745,16 +6905,12 @@ _TokenEvent.payloadVariantDescriptors = Object.freeze([
 var TokenEvent = _TokenEvent;
 ((TokenEvent2) => {
   TokenEvent2.ParamKeys = Object.freeze({
-    payload_event_type: "payload.event_type",
-    TokenEvent__payload_event_type: "TokenEvent::payload.event_type"
+    payload_event_type: "payload.event_type"
   });
   TokenEvent2.Params = {
     fromValues(input) {
-      const payloadEventType = __tnToBigInt3(input.payload_event_type);
-      const tokenEventPayloadType = input.TokenEvent__payload_event_type !== void 0 ? __tnToBigInt3(input.TokenEvent__payload_event_type) : payloadEventType;
       return {
-        payload_event_type: payloadEventType,
-        TokenEvent__payload_event_type: tokenEventPayloadType
+        payload_event_type: __tnToBigInt3(input.payload_event_type)
       };
     },
     fromBuilder(source) {
@@ -5772,8 +6928,6 @@ var TokenEvent = _TokenEvent;
   }
   TokenEvent2.params = params;
 })(TokenEvent || (TokenEvent = {}));
-__tnRegisterFootprint3("TokenEvent", (params) => TokenEvent.__tnInvokeFootprint(params));
-__tnRegisterValidate3("TokenEvent", (buffer, params) => TokenEvent.__tnInvokeValidate(buffer, params));
 var TokenEventBuilder = class {
   constructor() {
     this.__tnField_event_type = null;
@@ -5848,10 +7002,11 @@ var TokenEventBuilder = class {
   }
   __tnComputeParams() {
     if (this.__tnCachedParams) return this.__tnCachedParams;
-    const eventType = __tnToBigInt3(this.__tnPrefixView.getUint8(0));
     const params = TokenEvent.Params.fromValues({
-      payload_event_type: eventType,
-      TokenEvent__payload_event_type: eventType
+      payload_event_type: (() => {
+        if (this.__tnField_event_type === null) throw new Error("TokenEventBuilder: missing enum tag");
+        return __tnToBigInt3(this.__tnField_event_type);
+      })()
     });
     this.__tnCachedParams = params;
     return params;
@@ -5873,25 +7028,98 @@ var TokenEventBuilder = class {
     this.__tnLastBuffer = buffer;
   }
 };
+__tnRegisterFootprint3("TokenEvent", (params) => TokenEvent.__tnInvokeFootprint(params));
+__tnRegisterValidate3("TokenEvent", (buffer, params) => TokenEvent.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("TokenEvent", (buffer) => {
+  const result = TokenEvent.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_InitializeAccountInstruction = {
   typeName: "InitializeAccountInstruction",
   root: { op: "align", alignment: 1, node: { op: "add", left: { op: "add", left: { op: "add", left: { op: "add", left: { op: "align", alignment: 2, node: { op: "const", value: 2n } }, right: { op: "align", alignment: 2, node: { op: "const", value: 2n } } }, right: { op: "align", alignment: 2, node: { op: "const", value: 2n } } }, right: { op: "align", alignment: 1, node: { op: "const", value: 32n } } }, right: { op: "align", alignment: 1, node: { op: "call", typeName: "StateProof", args: [{ name: "proof_body.hdr.type_slot", source: "proof_body.hdr.type_slot" }, { name: "proof_body.payload_size", source: "proof_body.payload_size" }] } } } }
 };
 var InitializeAccountInstruction = class _InitializeAccountInstruction {
-  constructor(buffer) {
+  constructor(buffer, params) {
     this.buffer = buffer;
     this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    if (params) {
+      this.__tnParams = params;
+    } else {
+      const derived = _InitializeAccountInstruction.__tnExtractParams(this.view, buffer);
+      if (!derived) {
+        throw new Error("InitializeAccountInstruction: failed to derive dynamic parameters");
+      }
+      this.__tnParams = derived.params;
+    }
   }
   static __tnCreateView(buffer, opts) {
     if (!buffer || buffer.length === void 0) throw new Error("InitializeAccountInstruction.__tnCreateView requires a Uint8Array");
-    return new _InitializeAccountInstruction(new Uint8Array(buffer));
+    let params = opts?.params ?? null;
+    if (!params) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      const derived = _InitializeAccountInstruction.__tnExtractParams(view, buffer);
+      if (!derived) throw new Error("InitializeAccountInstruction.__tnCreateView: failed to derive params");
+      params = derived.params;
+    }
+    const instance = new _InitializeAccountInstruction(new Uint8Array(buffer), params);
+    return instance;
+  }
+  dynamicParams() {
+    return this.__tnParams;
   }
   static builder() {
     return new InitializeAccountInstructionBuilder();
   }
   static fromBuilder(builder) {
     const buffer = builder.build();
-    return _InitializeAccountInstruction.from_array(buffer);
+    const params = builder.dynamicParams();
+    return _InitializeAccountInstruction.from_array(buffer, { params });
+  }
+  static __tnComputeSequentialLayout(view, buffer) {
+    const __tnLength = buffer.length;
+    let __tnParamSeq_proof_body_hdr_type_slot = null;
+    let __tnParamSeq_proof_body_payload_size = null;
+    let __tnCursorMutable = 0;
+    if (__tnCursorMutable + 2 > __tnLength) return null;
+    view.getUint16(__tnCursorMutable, true);
+    __tnCursorMutable += 2;
+    if (__tnCursorMutable + 2 > __tnLength) return null;
+    view.getUint16(__tnCursorMutable, true);
+    __tnCursorMutable += 2;
+    if (__tnCursorMutable + 2 > __tnLength) return null;
+    view.getUint16(__tnCursorMutable, true);
+    __tnCursorMutable += 2;
+    if (__tnCursorMutable + 32 > __tnLength) return null;
+    __tnCursorMutable += 32;
+    const __tnTyperefResult_state_proof = __tnInvokeDynamicValidate3("StateProof", buffer.subarray(__tnCursorMutable));
+    if (!__tnTyperefResult_state_proof.ok || __tnTyperefResult_state_proof.consumed === void 0) return null;
+    const __tnTyperefParams_state_proof = __tnTyperefResult_state_proof.params ?? null;
+    if (!__tnTyperefParams_state_proof || __tnTyperefParams_state_proof["proof_body_hdr_type_slot"] === void 0) return null;
+    __tnParamSeq_proof_body_hdr_type_slot = __tnTyperefParams_state_proof["proof_body_hdr_type_slot"];
+    if (!__tnTyperefParams_state_proof || __tnTyperefParams_state_proof["proof_body_payload_size"] === void 0) return null;
+    __tnParamSeq_proof_body_payload_size = __tnTyperefParams_state_proof["proof_body_payload_size"];
+    __tnCursorMutable += __tnBigIntToNumber3(__tnTyperefResult_state_proof.consumed, "InitializeAccountInstruction::state_proof");
+    const params = /* @__PURE__ */ Object.create(null);
+    if (__tnParamSeq_proof_body_hdr_type_slot === null) return null;
+    params["proof_body_hdr_type_slot"] = __tnParamSeq_proof_body_hdr_type_slot;
+    if (__tnParamSeq_proof_body_payload_size === null) return null;
+    params["proof_body_payload_size"] = __tnParamSeq_proof_body_payload_size;
+    return { params, offsets: null, derived: null };
+  }
+  static __tnExtractParams(view, buffer) {
+    const __tnLayout = _InitializeAccountInstruction.__tnComputeSequentialLayout(view, buffer);
+    if (!__tnLayout || !__tnLayout.params) return null;
+    const __tnSeqParams = __tnLayout.params;
+    const __tnParamSeq_proof_body_hdr_type_slot = __tnSeqParams["proof_body_hdr_type_slot"];
+    if (__tnParamSeq_proof_body_hdr_type_slot === void 0) return null;
+    const __tnParamSeq_proof_body_payload_size = __tnSeqParams["proof_body_payload_size"];
+    if (__tnParamSeq_proof_body_payload_size === void 0) return null;
+    const __tnExtractedParams = _InitializeAccountInstruction.Params.fromValues({
+      proof_body_hdr_type_slot: __tnParamSeq_proof_body_hdr_type_slot,
+      proof_body_payload_size: __tnParamSeq_proof_body_payload_size
+    });
+    return { params: __tnExtractedParams, derived: null };
   }
   get_token_account_index() {
     const offset = 0;
@@ -5977,51 +7205,122 @@ var InitializeAccountInstruction = class _InitializeAccountInstruction {
   static __tnFootprintInternal(__tnParams) {
     return __tnEvalFootprint3(__tn_ir_InitializeAccountInstruction.root, { params: __tnParams });
   }
-  static __tnValidateInternal(buffer, __tnParams) {
-    return __tnValidateIrTree3(__tn_ir_InitializeAccountInstruction, buffer, __tnParams);
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree3(__tn_ir_InitializeAccountInstruction, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr(proof_body_hdr_type_slot, proof_body_payload_size) {
+    const params = _InitializeAccountInstruction.Params.fromValues({
+      proof_body_hdr_type_slot,
+      proof_body_payload_size
+    });
+    return this.footprintIrFromParams(params);
+  }
+  static __tnPackParams(params) {
+    const record = /* @__PURE__ */ Object.create(null);
+    record["proof_body.hdr.type_slot"] = params.proof_body_hdr_type_slot;
+    record["proof_body.payload_size"] = params.proof_body_payload_size;
+    return record;
   }
-  static __tnInvokeFootprint(__tnParams) {
+  static footprintIrFromParams(params) {
+    const __tnParams = this.__tnPackParams(params);
     return this.__tnFootprintInternal(__tnParams);
   }
-  static __tnInvokeValidate(buffer, __tnParams) {
-    return this.__tnValidateInternal(buffer, __tnParams);
+  static footprintFromParams(params) {
+    const irResult = this.footprintIrFromParams(params);
+    const maxSafe = __tnToBigInt3(Number.MAX_SAFE_INTEGER);
+    if (__tnBigIntGreaterThan3(irResult, maxSafe)) throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for InitializeAccountInstruction");
+    return __tnBigIntToNumber3(irResult, "InitializeAccountInstruction::footprintFromParams");
   }
-  static footprintIr() {
-    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  static footprintFromValues(input) {
+    const params = _InitializeAccountInstruction.params(input);
+    return this.footprintFromParams(params);
   }
-  static footprint() {
-    const irResult = this.footprintIr();
-    const maxSafe = __tnToBigInt3(Number.MAX_SAFE_INTEGER);
-    if (__tnBigIntGreaterThan3(irResult, maxSafe)) {
-      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for InitializeAccountInstruction");
-    }
-    return __tnBigIntToNumber3(irResult, "InitializeAccountInstruction::footprint");
+  static footprint(params) {
+    return this.footprintFromParams(params);
   }
-  static validate(_buffer, _opts) {
-    __tnLogWarn3("InitializeAccountInstruction::validate falling back to basic length check");
-    return { ok: true, consumed: _buffer.length };
+  static validate(buffer, opts) {
+    if (!buffer || buffer.length === void 0) {
+      return { ok: false, code: "tn.invalid_buffer" };
+    }
+    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    let params = opts?.params ?? null;
+    if (!params) {
+      return { ok: false, code: "tn.param_extraction_failed" };
+    }
+    const __tnParamsRec = this.__tnPackParams(params);
+    const irResult = this.__tnValidateInternal(buffer, __tnParamsRec);
+    if (!irResult.ok) {
+      return { ok: false, code: irResult.code, consumed: irResult.consumed ? __tnBigIntToNumber3(irResult.consumed, "InitializeAccountInstruction::validate") : void 0, params };
+    }
+    const consumed = irResult.consumed ? __tnBigIntToNumber3(irResult.consumed, "InitializeAccountInstruction::validate") : void 0;
+    return { ok: true, consumed, params };
   }
-  static from_array(buffer) {
+  static from_array(buffer, opts) {
     if (!buffer || buffer.length === void 0) {
       return null;
     }
     new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    const validation = this.validate(buffer);
+    let params = opts?.params ?? null;
+    if (!params) {
+      __tnLogWarn3("InitializeAccountInstruction::from_array requires params when IR extraction is unavailable");
+      return null;
+    }
+    const validation = this.validate(buffer, { params });
     if (!validation.ok) {
       return null;
     }
-    return new _InitializeAccountInstruction(buffer);
+    const cached = validation.params ?? params;
+    const state = new _InitializeAccountInstruction(buffer, cached);
+    return state;
   }
 };
-__tnRegisterFootprint3("InitializeAccountInstruction", (params) => InitializeAccountInstruction.__tnInvokeFootprint(params));
-__tnRegisterValidate3("InitializeAccountInstruction", (buffer, params) => InitializeAccountInstruction.__tnInvokeValidate(buffer, params));
+((InitializeAccountInstruction2) => {
+  InitializeAccountInstruction2.ParamKeys = Object.freeze({
+    proof_body_hdr_type_slot: "proof_body.hdr.type_slot",
+    proof_body_payload_size: "proof_body.payload_size"
+  });
+  InitializeAccountInstruction2.Params = {
+    fromValues(input) {
+      return {
+        proof_body_hdr_type_slot: __tnToBigInt3(input.proof_body_hdr_type_slot),
+        proof_body_payload_size: __tnToBigInt3(input.proof_body_payload_size)
+      };
+    },
+    fromBuilder(source) {
+      if (source.dynamicParams) {
+        return source.dynamicParams();
+      }
+      if (source.params) {
+        return source.params;
+      }
+      return source;
+    }
+  };
+  function params(input) {
+    return InitializeAccountInstruction2.Params.fromValues(input);
+  }
+  InitializeAccountInstruction2.params = params;
+})(InitializeAccountInstruction || (InitializeAccountInstruction = {}));
 var InitializeAccountInstructionBuilder = class {
   constructor() {
+    this.__tnCachedParams = null;
+    this.__tnLastBuffer = null;
+    this.__tnLastParams = null;
     this.__tnTail_state_proof = null;
+    this.__tnTailParams_state_proof = null;
     this.buffer = new Uint8Array(38);
     this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
   }
   __tnInvalidate() {
+    this.__tnCachedParams = null;
+    this.__tnLastBuffer = null;
+    this.__tnLastParams = null;
   }
   set_token_account_index(value) {
     this.view.setUint16(0, value, true);
@@ -6046,86 +7345,178 @@ var InitializeAccountInstructionBuilder = class {
   }
   set_state_proof(value) {
     const bytes = __tnResolveStructFieldInput(value, "InitializeAccountInstructionBuilder::state_proof");
+    const validation = __tnInvokeDynamicValidate3("StateProof", bytes);
+    if (!validation.ok || validation.consumed === void 0) throw new Error("InitializeAccountInstructionBuilder: field 'state_proof' failed validation");
+    if (__tnBigIntToNumber3(validation.consumed, "InitializeAccountInstructionBuilder::state_proof") !== bytes.length) throw new Error("InitializeAccountInstructionBuilder: field 'state_proof' validation did not consume the full buffer");
     this.__tnTail_state_proof = bytes;
+    this.__tnTailParams_state_proof = validation.params ?? null;
     this.__tnInvalidate();
     return this;
   }
   build() {
-    const fragments = this.__tnCollectTailFragments();
-    const size = this.__tnComputeSize(fragments);
+    const params = this.__tnComputeParams();
+    const size = InitializeAccountInstruction.footprintFromParams(params);
     const buffer = new Uint8Array(size);
-    this.__tnWriteInto(buffer, fragments);
-    this.__tnValidateOrThrow(buffer);
+    this.__tnWriteInto(buffer);
+    this.__tnValidateOrThrow(buffer, params);
     return buffer;
   }
   buildInto(target, offset = 0) {
-    const fragments = this.__tnCollectTailFragments();
-    const size = this.__tnComputeSize(fragments);
+    const params = this.__tnComputeParams();
+    const size = InitializeAccountInstruction.footprintFromParams(params);
     if (target.length - offset < size) throw new Error("InitializeAccountInstructionBuilder: target buffer too small");
     const slice = target.subarray(offset, offset + size);
-    this.__tnWriteInto(slice, fragments);
-    this.__tnValidateOrThrow(slice);
+    this.__tnWriteInto(slice);
+    this.__tnValidateOrThrow(slice, params);
     return target;
   }
   finish() {
     const buffer = this.build();
-    const view = InitializeAccountInstruction.from_array(buffer);
+    const params = this.__tnLastParams ?? this.__tnComputeParams();
+    const view = InitializeAccountInstruction.from_array(buffer, { params });
     if (!view) throw new Error("InitializeAccountInstructionBuilder: failed to finalize view");
     return view;
   }
   finishView() {
     return this.finish();
   }
-  __tnCollectTailFragments() {
-    return [
-      (() => {
-        const bytes = this.__tnTail_state_proof;
-        if (!bytes) throw new Error("InitializeAccountInstructionBuilder: field 'state_proof' must be set before build()");
-        return bytes;
-      })()
-    ];
+  dynamicParams() {
+    return this.__tnComputeParams();
   }
-  __tnComputeSize(fragments) {
-    let total = this.buffer.length;
-    for (const fragment of fragments) {
-      total += fragment.length;
-    }
-    return total;
+  __tnComputeParams() {
+    if (this.__tnCachedParams) return this.__tnCachedParams;
+    const params = InitializeAccountInstruction.Params.fromValues({
+      proof_body_hdr_type_slot: (() => {
+        const params2 = this.__tnTailParams_state_proof;
+        if (!params2 || params2["proof_body_hdr_type_slot"] === void 0) throw new Error("InitializeAccountInstructionBuilder: field 'state_proof' must be written before computing params");
+        return params2["proof_body_hdr_type_slot"];
+      })(),
+      proof_body_payload_size: (() => {
+        const params2 = this.__tnTailParams_state_proof;
+        if (!params2 || params2["proof_body_payload_size"] === void 0) throw new Error("InitializeAccountInstructionBuilder: field 'state_proof' must be written before computing params");
+        return params2["proof_body_payload_size"];
+      })()
+    });
+    this.__tnCachedParams = params;
+    return params;
   }
-  __tnWriteInto(target, fragments) {
+  __tnWriteInto(target) {
     target.set(this.buffer, 0);
     let cursor = this.buffer.length;
-    for (const fragment of fragments) {
-      target.set(fragment, cursor);
-      cursor += fragment.length;
-    }
+    const __tnLocal_state_proof_bytes = this.__tnTail_state_proof;
+    if (!__tnLocal_state_proof_bytes) throw new Error("InitializeAccountInstructionBuilder: field 'state_proof' must be written before build");
+    target.set(__tnLocal_state_proof_bytes, cursor);
+    cursor += __tnLocal_state_proof_bytes.length;
   }
-  __tnValidateOrThrow(buffer) {
-    const result = InitializeAccountInstruction.validate(buffer);
+  __tnValidateOrThrow(buffer, params) {
+    const result = InitializeAccountInstruction.validate(buffer, { params });
     if (!result.ok) {
-      throw new Error(`InitializeAccountInstructionBuilder: builder produced invalid buffer (code=${result.code ?? "unknown"})`);
+      throw new Error(`${InitializeAccountInstruction}Builder: builder produced invalid buffer (code=${result.code ?? "unknown"})`);
     }
+    this.__tnLastParams = result.params ?? params;
+    this.__tnLastBuffer = buffer;
   }
 };
+__tnRegisterFootprint3("InitializeAccountInstruction", (params) => InitializeAccountInstruction.__tnInvokeFootprint(params));
+__tnRegisterValidate3("InitializeAccountInstruction", (buffer, params) => InitializeAccountInstruction.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("InitializeAccountInstruction", (buffer) => {
+  const result = InitializeAccountInstruction.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_InitializeMintInstruction = {
   typeName: "InitializeMintInstruction",
   root: { op: "align", alignment: 1, node: { op: "add", left: { op: "add", left: { op: "add", left: { op: "add", left: { op: "add", left: { op: "add", left: { op: "add", left: { op: "add", left: { op: "align", alignment: 2, node: { op: "const", value: 2n } }, right: { op: "align", alignment: 1, node: { op: "const", value: 1n } } }, right: { op: "align", alignment: 1, node: { op: "const", value: 32n } } }, right: { op: "align", alignment: 1, node: { op: "const", value: 32n } } }, right: { op: "align", alignment: 1, node: { op: "const", value: 32n } } }, right: { op: "align", alignment: 1, node: { op: "const", value: 1n } } }, right: { op: "align", alignment: 1, node: { op: "const", value: 9n } } }, right: { op: "align", alignment: 1, node: { op: "const", value: 32n } } }, right: { op: "align", alignment: 1, node: { op: "call", typeName: "StateProof", args: [{ name: "proof_body.hdr.type_slot", source: "proof_body.hdr.type_slot" }, { name: "proof_body.payload_size", source: "proof_body.payload_size" }] } } } }
 };
 var InitializeMintInstruction = class _InitializeMintInstruction {
-  constructor(buffer) {
+  constructor(buffer, params) {
     this.buffer = buffer;
     this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    if (params) {
+      this.__tnParams = params;
+    } else {
+      const derived = _InitializeMintInstruction.__tnExtractParams(this.view, buffer);
+      if (!derived) {
+        throw new Error("InitializeMintInstruction: failed to derive dynamic parameters");
+      }
+      this.__tnParams = derived.params;
+    }
   }
   static __tnCreateView(buffer, opts) {
     if (!buffer || buffer.length === void 0) throw new Error("InitializeMintInstruction.__tnCreateView requires a Uint8Array");
-    return new _InitializeMintInstruction(new Uint8Array(buffer));
+    let params = opts?.params ?? null;
+    if (!params) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      const derived = _InitializeMintInstruction.__tnExtractParams(view, buffer);
+      if (!derived) throw new Error("InitializeMintInstruction.__tnCreateView: failed to derive params");
+      params = derived.params;
+    }
+    const instance = new _InitializeMintInstruction(new Uint8Array(buffer), params);
+    return instance;
+  }
+  dynamicParams() {
+    return this.__tnParams;
   }
   static builder() {
     return new InitializeMintInstructionBuilder();
   }
   static fromBuilder(builder) {
     const buffer = builder.build();
-    return _InitializeMintInstruction.from_array(buffer);
+    const params = builder.dynamicParams();
+    return _InitializeMintInstruction.from_array(buffer, { params });
+  }
+  static __tnComputeSequentialLayout(view, buffer) {
+    const __tnLength = buffer.length;
+    let __tnParamSeq_proof_body_hdr_type_slot = null;
+    let __tnParamSeq_proof_body_payload_size = null;
+    let __tnCursorMutable = 0;
+    if (__tnCursorMutable + 2 > __tnLength) return null;
+    view.getUint16(__tnCursorMutable, true);
+    __tnCursorMutable += 2;
+    if (__tnCursorMutable + 1 > __tnLength) return null;
+    view.getUint8(__tnCursorMutable);
+    __tnCursorMutable += 1;
+    if (__tnCursorMutable + 32 > __tnLength) return null;
+    __tnCursorMutable += 32;
+    if (__tnCursorMutable + 32 > __tnLength) return null;
+    __tnCursorMutable += 32;
+    if (__tnCursorMutable + 32 > __tnLength) return null;
+    __tnCursorMutable += 32;
+    if (__tnCursorMutable + 1 > __tnLength) return null;
+    view.getUint8(__tnCursorMutable);
+    __tnCursorMutable += 1;
+    if (__tnCursorMutable + 9 > __tnLength) return null;
+    __tnCursorMutable += 9;
+    if (__tnCursorMutable + 32 > __tnLength) return null;
+    __tnCursorMutable += 32;
+    const __tnTyperefResult_state_proof = __tnInvokeDynamicValidate3("StateProof", buffer.subarray(__tnCursorMutable));
+    if (!__tnTyperefResult_state_proof.ok || __tnTyperefResult_state_proof.consumed === void 0) return null;
+    const __tnTyperefParams_state_proof = __tnTyperefResult_state_proof.params ?? null;
+    if (!__tnTyperefParams_state_proof || __tnTyperefParams_state_proof["proof_body_hdr_type_slot"] === void 0) return null;
+    __tnParamSeq_proof_body_hdr_type_slot = __tnTyperefParams_state_proof["proof_body_hdr_type_slot"];
+    if (!__tnTyperefParams_state_proof || __tnTyperefParams_state_proof["proof_body_payload_size"] === void 0) return null;
+    __tnParamSeq_proof_body_payload_size = __tnTyperefParams_state_proof["proof_body_payload_size"];
+    __tnCursorMutable += __tnBigIntToNumber3(__tnTyperefResult_state_proof.consumed, "InitializeMintInstruction::state_proof");
+    const params = /* @__PURE__ */ Object.create(null);
+    if (__tnParamSeq_proof_body_hdr_type_slot === null) return null;
+    params["proof_body_hdr_type_slot"] = __tnParamSeq_proof_body_hdr_type_slot;
+    if (__tnParamSeq_proof_body_payload_size === null) return null;
+    params["proof_body_payload_size"] = __tnParamSeq_proof_body_payload_size;
+    return { params, offsets: null, derived: null };
+  }
+  static __tnExtractParams(view, buffer) {
+    const __tnLayout = _InitializeMintInstruction.__tnComputeSequentialLayout(view, buffer);
+    if (!__tnLayout || !__tnLayout.params) return null;
+    const __tnSeqParams = __tnLayout.params;
+    const __tnParamSeq_proof_body_hdr_type_slot = __tnSeqParams["proof_body_hdr_type_slot"];
+    if (__tnParamSeq_proof_body_hdr_type_slot === void 0) return null;
+    const __tnParamSeq_proof_body_payload_size = __tnSeqParams["proof_body_payload_size"];
+    if (__tnParamSeq_proof_body_payload_size === void 0) return null;
+    const __tnExtractedParams = _InitializeMintInstruction.Params.fromValues({
+      proof_body_hdr_type_slot: __tnParamSeq_proof_body_hdr_type_slot,
+      proof_body_payload_size: __tnParamSeq_proof_body_payload_size
+    });
+    return { params: __tnExtractedParams, derived: null };
   }
   get_mint_account_index() {
     const offset = 0;
@@ -6284,42 +7675,113 @@ var InitializeMintInstruction = class _InitializeMintInstruction {
   static __tnInvokeValidate(buffer, __tnParams) {
     return this.__tnValidateInternal(buffer, __tnParams);
   }
-  static footprintIr() {
-    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  static footprintIr(proof_body_hdr_type_slot, proof_body_payload_size) {
+    const params = _InitializeMintInstruction.Params.fromValues({
+      proof_body_hdr_type_slot,
+      proof_body_payload_size
+    });
+    return this.footprintIrFromParams(params);
   }
-  static footprint() {
-    const irResult = this.footprintIr();
+  static __tnPackParams(params) {
+    const record = /* @__PURE__ */ Object.create(null);
+    record["proof_body.hdr.type_slot"] = params.proof_body_hdr_type_slot;
+    record["proof_body.payload_size"] = params.proof_body_payload_size;
+    return record;
+  }
+  static footprintIrFromParams(params) {
+    const __tnParams = this.__tnPackParams(params);
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static footprintFromParams(params) {
+    const irResult = this.footprintIrFromParams(params);
     const maxSafe = __tnToBigInt3(Number.MAX_SAFE_INTEGER);
-    if (__tnBigIntGreaterThan3(irResult, maxSafe)) {
-      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for InitializeMintInstruction");
-    }
-    return __tnBigIntToNumber3(irResult, "InitializeMintInstruction::footprint");
+    if (__tnBigIntGreaterThan3(irResult, maxSafe)) throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for InitializeMintInstruction");
+    return __tnBigIntToNumber3(irResult, "InitializeMintInstruction::footprintFromParams");
   }
-  static validate(_buffer, _opts) {
-    __tnLogWarn3("InitializeMintInstruction::validate falling back to basic length check");
-    return { ok: true, consumed: _buffer.length };
+  static footprintFromValues(input) {
+    const params = _InitializeMintInstruction.params(input);
+    return this.footprintFromParams(params);
   }
-  static from_array(buffer) {
+  static footprint(params) {
+    return this.footprintFromParams(params);
+  }
+  static validate(buffer, opts) {
+    if (!buffer || buffer.length === void 0) {
+      return { ok: false, code: "tn.invalid_buffer" };
+    }
+    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    let params = opts?.params ?? null;
+    if (!params) {
+      return { ok: false, code: "tn.param_extraction_failed" };
+    }
+    const __tnParamsRec = this.__tnPackParams(params);
+    const irResult = this.__tnValidateInternal(buffer, __tnParamsRec);
+    if (!irResult.ok) {
+      return { ok: false, code: irResult.code, consumed: irResult.consumed ? __tnBigIntToNumber3(irResult.consumed, "InitializeMintInstruction::validate") : void 0, params };
+    }
+    const consumed = irResult.consumed ? __tnBigIntToNumber3(irResult.consumed, "InitializeMintInstruction::validate") : void 0;
+    return { ok: true, consumed, params };
+  }
+  static from_array(buffer, opts) {
     if (!buffer || buffer.length === void 0) {
       return null;
     }
     new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    const validation = this.validate(buffer);
+    let params = opts?.params ?? null;
+    if (!params) {
+      __tnLogWarn3("InitializeMintInstruction::from_array requires params when IR extraction is unavailable");
+      return null;
+    }
+    const validation = this.validate(buffer, { params });
     if (!validation.ok) {
       return null;
     }
-    return new _InitializeMintInstruction(buffer);
+    const cached = validation.params ?? params;
+    const state = new _InitializeMintInstruction(buffer, cached);
+    return state;
   }
 };
-__tnRegisterFootprint3("InitializeMintInstruction", (params) => InitializeMintInstruction.__tnInvokeFootprint(params));
-__tnRegisterValidate3("InitializeMintInstruction", (buffer, params) => InitializeMintInstruction.__tnInvokeValidate(buffer, params));
+((InitializeMintInstruction2) => {
+  InitializeMintInstruction2.ParamKeys = Object.freeze({
+    proof_body_hdr_type_slot: "proof_body.hdr.type_slot",
+    proof_body_payload_size: "proof_body.payload_size"
+  });
+  InitializeMintInstruction2.Params = {
+    fromValues(input) {
+      return {
+        proof_body_hdr_type_slot: __tnToBigInt3(input.proof_body_hdr_type_slot),
+        proof_body_payload_size: __tnToBigInt3(input.proof_body_payload_size)
+      };
+    },
+    fromBuilder(source) {
+      if (source.dynamicParams) {
+        return source.dynamicParams();
+      }
+      if (source.params) {
+        return source.params;
+      }
+      return source;
+    }
+  };
+  function params(input) {
+    return InitializeMintInstruction2.Params.fromValues(input);
+  }
+  InitializeMintInstruction2.params = params;
+})(InitializeMintInstruction || (InitializeMintInstruction = {}));
 var InitializeMintInstructionBuilder = class {
   constructor() {
+    this.__tnCachedParams = null;
+    this.__tnLastBuffer = null;
+    this.__tnLastParams = null;
     this.__tnTail_state_proof = null;
+    this.__tnTailParams_state_proof = null;
     this.buffer = new Uint8Array(141);
     this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
   }
   __tnInvalidate() {
+    this.__tnCachedParams = null;
+    this.__tnLastBuffer = null;
+    this.__tnLastParams = null;
   }
   set_mint_account_index(value) {
     this.view.setUint16(0, value, true);
@@ -6368,67 +7830,85 @@ var InitializeMintInstructionBuilder = class {
   }
   set_state_proof(value) {
     const bytes = __tnResolveStructFieldInput(value, "InitializeMintInstructionBuilder::state_proof");
+    const validation = __tnInvokeDynamicValidate3("StateProof", bytes);
+    if (!validation.ok || validation.consumed === void 0) throw new Error("InitializeMintInstructionBuilder: field 'state_proof' failed validation");
+    if (__tnBigIntToNumber3(validation.consumed, "InitializeMintInstructionBuilder::state_proof") !== bytes.length) throw new Error("InitializeMintInstructionBuilder: field 'state_proof' validation did not consume the full buffer");
     this.__tnTail_state_proof = bytes;
+    this.__tnTailParams_state_proof = validation.params ?? null;
     this.__tnInvalidate();
     return this;
   }
   build() {
-    const fragments = this.__tnCollectTailFragments();
-    const size = this.__tnComputeSize(fragments);
+    const params = this.__tnComputeParams();
+    const size = InitializeMintInstruction.footprintFromParams(params);
     const buffer = new Uint8Array(size);
-    this.__tnWriteInto(buffer, fragments);
-    this.__tnValidateOrThrow(buffer);
+    this.__tnWriteInto(buffer);
+    this.__tnValidateOrThrow(buffer, params);
     return buffer;
   }
   buildInto(target, offset = 0) {
-    const fragments = this.__tnCollectTailFragments();
-    const size = this.__tnComputeSize(fragments);
+    const params = this.__tnComputeParams();
+    const size = InitializeMintInstruction.footprintFromParams(params);
     if (target.length - offset < size) throw new Error("InitializeMintInstructionBuilder: target buffer too small");
     const slice = target.subarray(offset, offset + size);
-    this.__tnWriteInto(slice, fragments);
-    this.__tnValidateOrThrow(slice);
+    this.__tnWriteInto(slice);
+    this.__tnValidateOrThrow(slice, params);
     return target;
   }
   finish() {
     const buffer = this.build();
-    const view = InitializeMintInstruction.from_array(buffer);
+    const params = this.__tnLastParams ?? this.__tnComputeParams();
+    const view = InitializeMintInstruction.from_array(buffer, { params });
     if (!view) throw new Error("InitializeMintInstructionBuilder: failed to finalize view");
     return view;
   }
   finishView() {
     return this.finish();
   }
-  __tnCollectTailFragments() {
-    return [
-      (() => {
-        const bytes = this.__tnTail_state_proof;
-        if (!bytes) throw new Error("InitializeMintInstructionBuilder: field 'state_proof' must be set before build()");
-        return bytes;
-      })()
-    ];
+  dynamicParams() {
+    return this.__tnComputeParams();
   }
-  __tnComputeSize(fragments) {
-    let total = this.buffer.length;
-    for (const fragment of fragments) {
-      total += fragment.length;
-    }
-    return total;
+  __tnComputeParams() {
+    if (this.__tnCachedParams) return this.__tnCachedParams;
+    const params = InitializeMintInstruction.Params.fromValues({
+      proof_body_hdr_type_slot: (() => {
+        const params2 = this.__tnTailParams_state_proof;
+        if (!params2 || params2["proof_body_hdr_type_slot"] === void 0) throw new Error("InitializeMintInstructionBuilder: field 'state_proof' must be written before computing params");
+        return params2["proof_body_hdr_type_slot"];
+      })(),
+      proof_body_payload_size: (() => {
+        const params2 = this.__tnTailParams_state_proof;
+        if (!params2 || params2["proof_body_payload_size"] === void 0) throw new Error("InitializeMintInstructionBuilder: field 'state_proof' must be written before computing params");
+        return params2["proof_body_payload_size"];
+      })()
+    });
+    this.__tnCachedParams = params;
+    return params;
   }
-  __tnWriteInto(target, fragments) {
+  __tnWriteInto(target) {
     target.set(this.buffer, 0);
     let cursor = this.buffer.length;
-    for (const fragment of fragments) {
-      target.set(fragment, cursor);
-      cursor += fragment.length;
-    }
+    const __tnLocal_state_proof_bytes = this.__tnTail_state_proof;
+    if (!__tnLocal_state_proof_bytes) throw new Error("InitializeMintInstructionBuilder: field 'state_proof' must be written before build");
+    target.set(__tnLocal_state_proof_bytes, cursor);
+    cursor += __tnLocal_state_proof_bytes.length;
   }
-  __tnValidateOrThrow(buffer) {
-    const result = InitializeMintInstruction.validate(buffer);
+  __tnValidateOrThrow(buffer, params) {
+    const result = InitializeMintInstruction.validate(buffer, { params });
     if (!result.ok) {
-      throw new Error(`InitializeMintInstructionBuilder: builder produced invalid buffer (code=${result.code ?? "unknown"})`);
+      throw new Error(`${InitializeMintInstruction}Builder: builder produced invalid buffer (code=${result.code ?? "unknown"})`);
     }
+    this.__tnLastParams = result.params ?? params;
+    this.__tnLastBuffer = buffer;
   }
 };
+__tnRegisterFootprint3("InitializeMintInstruction", (params) => InitializeMintInstruction.__tnInvokeFootprint(params));
+__tnRegisterValidate3("InitializeMintInstruction", (buffer, params) => InitializeMintInstruction.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("InitializeMintInstruction", (buffer) => {
+  const result = InitializeMintInstruction.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 var __tn_ir_TokenInstruction = {
   typeName: "TokenInstruction",
   root: { op: "align", alignment: 1, node: { op: "add", left: { op: "align", alignment: 1, node: { op: "const", value: 1n } }, right: { op: "align", alignment: 1, node: { op: "field", param: "payload.payload_size" } } } }
@@ -6773,8 +8253,6 @@ var TokenInstruction = _TokenInstruction;
   }
   TokenInstruction3.params = params;
 })(TokenInstruction || (TokenInstruction = {}));
-__tnRegisterFootprint3("TokenInstruction", (params) => TokenInstruction.__tnInvokeFootprint(params));
-__tnRegisterValidate3("TokenInstruction", (buffer, params) => TokenInstruction.__tnInvokeValidate(buffer, params));
 var TokenInstructionBuilder = class {
   constructor() {
     this.__tnField_tag = null;
@@ -6879,6 +8357,13 @@ var TokenInstructionBuilder = class {
     this.__tnLastBuffer = buffer;
   }
 };
+__tnRegisterFootprint3("TokenInstruction", (params) => TokenInstruction.__tnInvokeFootprint(params));
+__tnRegisterValidate3("TokenInstruction", (buffer, params) => TokenInstruction.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("TokenInstruction", (buffer) => {
+  const result = TokenInstruction.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
 
 // src/token/instructions/shared.ts
 function buildTokenInstructionBytes(variant, payload) {