@thru/programs 0.2.22 → 0.2.23

package/src/multicall/index.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest';
+import {
+  MULTICALL_PROGRAM_ADDRESS,
+  MULTICALL_PROGRAM_PUBKEY,
+  InstructionDataBuilder,
+  MulticallArgs,
+  buildMulticallInstruction,
+} from './index';
+
+function instructionData(programIdx: number, data: Uint8Array): number[] {
+  const builder = new InstructionDataBuilder();
+  builder.set_program_idx(programIdx);
+  builder.data().write(data).finish();
+  return Array.from(builder.build());
+}
+
+describe('multicall helpers', () => {
+  it('encodes calls with generated InstructionData views', () => {
+    expect(MULTICALL_PROGRAM_ADDRESS).toBe(
+      'taAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkJ'
+    );
+    expect(MULTICALL_PROGRAM_PUBKEY[31]).toBe(9);
+
+    const encoded = buildMulticallInstruction([
+      { programIdx: 2, instructionData: new Uint8Array([0xaa]) },
+      { programIdx: 5, instructionData: new Uint8Array([0xbb, 0xcc]) },
+    ]);
+
+    expect(encoded).toEqual(
+      new Uint8Array([
+        0x02, 0x00,
+        ...instructionData(2, new Uint8Array([0xaa])),
+        ...instructionData(5, new Uint8Array([0xbb, 0xcc])),
+      ])
+    );
+
+    const validation = MulticallArgs.validate(encoded);
+    expect(validation).toMatchObject({ ok: true, consumed: encoded.length });
+
+    const view = MulticallArgs.from_array(encoded);
+    expect(view?.get_calls_count()).toBe(2);
+    const calls = view?.get_calls();
+    expect(calls?.map((call) => call.get_program_idx())).toEqual([2, 5]);
+    expect(calls?.map((call) => call.get_data())).toEqual([[0xaa], [0xbb, 0xcc]]);
+  });
+});

package/src/multicall/index.ts

@@ -0,0 +1,81 @@
+import { encodeAddress } from '@thru/sdk/helpers';
+import {
+  InstructionData,
+  InstructionDataBuilder,
+} from './abi/thru/common/primitives/types';
+import { MulticallArgs } from './abi/thru/program/multicall/types';
+
+export {
+  InstructionData,
+  InstructionDataBuilder,
+} from './abi/thru/common/primitives/types';
+export {
+  MulticallArgs,
+  MulticallError,
+} from './abi/thru/program/multicall/types';
+
+export type MulticallCall = {
+  programIdx: number;
+  instructionData: Uint8Array;
+};
+
+export const MULTICALL_PROGRAM_PUBKEY = new Uint8Array([
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9,
+]);
+
+export const MULTICALL_PROGRAM_ADDRESS = encodeAddress(MULTICALL_PROGRAM_PUBKEY);
+
+function writeU16LE(target: Uint8Array, offset: number, value: number): void {
+  target[offset] = value & 0xff;
+  target[offset + 1] = (value >> 8) & 0xff;
+}
+
+function assertProgramIdx(programIdx: number): void {
+  if (!Number.isInteger(programIdx) || programIdx < 0 || programIdx > 0xffff) {
+    throw new Error('programIdx must be 0-65535');
+  }
+}
+
+function buildInstructionData(call: MulticallCall): Uint8Array {
+  assertProgramIdx(call.programIdx);
+  if (!(call.instructionData instanceof Uint8Array)) {
+    throw new Error('instructionData must be a Uint8Array');
+  }
+
+  const builder = new InstructionDataBuilder();
+  builder.set_program_idx(call.programIdx);
+  builder.data().write(call.instructionData).finish();
+  const buffer = builder.build();
+  const view = InstructionData.from_array(buffer);
+  if (!view) {
+    throw new Error('generated InstructionData failed validation');
+  }
+  return buffer;
+}
+
+export function buildMulticallInstruction(calls: MulticallCall[]): Uint8Array {
+  if (!Array.isArray(calls)) throw new Error('calls must be an array');
+  if (calls.length > 0xffff) throw new Error('calls length must be 0-65535');
+
+  const encodedCalls = calls.map(buildInstructionData);
+  const totalLength = 2 + encodedCalls.reduce((sum, call) => sum + call.length, 0);
+
+  const output = new Uint8Array(totalLength);
+  let offset = 0;
+  writeU16LE(output, offset, calls.length);
+  offset += 2;
+
+  for (const call of encodedCalls) {
+    output.set(call, offset);
+    offset += call.length;
+  }
+
+  const validation = MulticallArgs.validate(output);
+  if (!validation.ok || validation.consumed !== output.length) {
+    throw new Error(
+      `generated MulticallArgs failed validation (code=${validation.code ?? 'unknown'})`
+    );
+  }
+
+  return output;
+}

package/src/passkey-manager/abi/thru/blockchain/state_proof/types.ts

@@ -32,6 +32,12 @@ type __TnIrNode =
       readonly op: "call";
       readonly typeName: string;
       readonly args: readonly { readonly name: string; readonly source: string }[];
+    }
+  | {
+      readonly op: "sumOverArray";
+      readonly count: __TnIrNode;
+      readonly elementTypeName: string;
+      readonly fieldName: string;
     };
 
 type __TnIrContext = {
@@ -517,6 +523,10 @@ const __tnValidateRegistry: Record<
   string,
   (buffer: Uint8Array, params: Record<string, bigint>) => __TnValidateResult
 > = {};
+const __tnDynamicValidateRegistry: Record<
+  string,
+  (buffer: Uint8Array) => __TnValidateResult
+> = {};
 
 function __tnRegisterFootprint(
   typeName: string,
@@ -532,6 +542,13 @@ function __tnRegisterValidate(
   __tnValidateRegistry[typeName] = fn;
 }
 
+function __tnRegisterDynamicValidate(
+  typeName: string,
+  fn: (buffer: Uint8Array) => __TnValidateResult
+): void {
+  __tnDynamicValidateRegistry[typeName] = fn;
+}
+
 function __tnInvokeFootprint(
   typeName: string,
   params: Record<string, bigint>
@@ -551,8 +568,17 @@ function __tnInvokeValidate(
   return fn(buffer, params);
 }
 
+function __tnInvokeDynamicValidate(
+  typeName: string,
+  buffer: Uint8Array
+): __TnValidateResult {
+  const fn = __tnDynamicValidateRegistry[typeName];
+  if (!fn) throw new Error(`IR runtime missing dynamic validate helper for ${typeName}`);
+  return fn(buffer);
+}
+
 function __tnEvalFootprint(node: __TnIrNode, ctx: __TnIrContext): bigint {
-  return __tnEvalIrNode(node, ctx);
+  return __tnEvalIrNode(node, ctx, __tnToBigInt(0));
 }
 
 function __tnTryEvalFootprint(
@@ -567,7 +593,7 @@ function __tnTryEvalIr(
   ctx: __TnIrContext
 ): __TnEvalResult {
   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) };
   }
@@ -598,7 +624,11 @@ function __tnValidateIrTree(
   return { ok: true, consumed: required };
 }
 
-function __tnEvalIrNode(node: __TnIrNode, ctx: __TnIrContext): bigint {
+function __tnEvalIrNode(
+  node: __TnIrNode,
+  ctx: __TnIrContext,
+  baseOffset: bigint
+): bigint {
   switch (node.op) {
     case "zero":
       return __tnToBigInt(0);
@@ -616,17 +646,22 @@ function __tnEvalIrNode(node: __TnIrNode, ctx: __TnIrContext): bigint {
       return val;
     }
     case "add":
-      return __tnCheckedAdd(
-        __tnEvalIrNode(node.left, ctx),
-        __tnEvalIrNode(node.right, ctx)
-      );
+      {
+        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 === undefined) {
@@ -639,10 +674,10 @@ function __tnEvalIrNode(node: __TnIrNode, ctx: __TnIrContext): bigint {
       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}'`
@@ -662,9 +697,10 @@ function __tnEvalIrNode(node: __TnIrNode, ctx: __TnIrContext): bigint {
         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) {
@@ -684,6 +720,36 @@ function __tnEvalIrNode(node: __TnIrNode, ctx: __TnIrContext): bigint {
       }
       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 === undefined) {
+          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",
@@ -718,6 +784,14 @@ function __tnNormalizeIrError(err: unknown): string {
   return "tn.ir.runtime_error";
 }
 
+__tnRegisterFootprint("Hash", (params) => Hash.__tnInvokeFootprint(params));
+__tnRegisterValidate("Hash", (buffer, params) => Hash.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Hash", (buffer) => { const result = Hash.validate(buffer); return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed) }; });
+
+__tnRegisterFootprint("Pubkey", (params) => Pubkey.__tnInvokeFootprint(params));
+__tnRegisterValidate("Pubkey", (buffer, params) => Pubkey.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Pubkey", (buffer) => { const result = Pubkey.validate(buffer); return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed) }; });
+
 /* ----- TYPE DEFINITION FOR StateProofHeader ----- */
 
 const __tn_ir_StateProofHeader = {
@@ -833,9 +907,6 @@ export class StateProofHeader {
 
 }
 
-__tnRegisterFootprint("StateProofHeader", (params) => StateProofHeader.__tnInvokeFootprint(params));
-__tnRegisterValidate("StateProofHeader", (buffer, params) => StateProofHeader.__tnInvokeValidate(buffer, params));
-
 export class StateProofHeaderBuilder {
   private buffer: Uint8Array;
   private view: DataView;
@@ -874,6 +945,10 @@ export class StateProofHeaderBuilder {
   }
 }
 
+__tnRegisterFootprint("StateProofHeader", (params) => StateProofHeader.__tnInvokeFootprint(params));
+__tnRegisterValidate("StateProofHeader", (buffer, params) => StateProofHeader.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("StateProofHeader", (buffer) => { const result = StateProofHeader.validate(buffer); return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed) }; });
+
 /* ----- TYPE DEFINITION FOR StateProof ----- */
 
 const __tn_ir_StateProof = {
@@ -1548,9 +1623,6 @@ export namespace StateProof {
   }
 }
 
-__tnRegisterFootprint("StateProof", (params) => StateProof.__tnInvokeFootprint(params));
-__tnRegisterValidate("StateProof", (buffer, params) => StateProof.__tnInvokeValidate(buffer, params));
-
 export class StateProofBuilder {
   private __tnPrefixBuffer: Uint8Array;
   private __tnPrefixView: DataView;
@@ -1665,3 +1737,7 @@ export class StateProofBuilder {
   }
 }
 
+__tnRegisterFootprint("StateProof", (params) => StateProof.__tnInvokeFootprint(params));
+__tnRegisterValidate("StateProof", (buffer, params) => StateProof.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("StateProof", (buffer) => { const result = StateProof.validate(buffer); return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed) }; });
+

package/src/passkey-manager/abi/thru/common/primitives/types.ts

@@ -30,6 +30,12 @@ type __TnIrNode =
       readonly op: "call";
       readonly typeName: string;
       readonly args: readonly { readonly name: string; readonly source: string }[];
+    }
+  | {
+      readonly op: "sumOverArray";
+      readonly count: __TnIrNode;
+      readonly elementTypeName: string;
+      readonly fieldName: string;
     };
 
 type __TnIrContext = {
@@ -515,6 +521,10 @@ const __tnValidateRegistry: Record<
   string,
   (buffer: Uint8Array, params: Record<string, bigint>) => __TnValidateResult
 > = {};
+const __tnDynamicValidateRegistry: Record<
+  string,
+  (buffer: Uint8Array) => __TnValidateResult
+> = {};
 
 function __tnRegisterFootprint(
   typeName: string,
@@ -530,6 +540,13 @@ function __tnRegisterValidate(
   __tnValidateRegistry[typeName] = fn;
 }
 
+function __tnRegisterDynamicValidate(
+  typeName: string,
+  fn: (buffer: Uint8Array) => __TnValidateResult
+): void {
+  __tnDynamicValidateRegistry[typeName] = fn;
+}
+
 function __tnInvokeFootprint(
   typeName: string,
   params: Record<string, bigint>
@@ -549,8 +566,17 @@ function __tnInvokeValidate(
   return fn(buffer, params);
 }
 
+function __tnInvokeDynamicValidate(
+  typeName: string,
+  buffer: Uint8Array
+): __TnValidateResult {
+  const fn = __tnDynamicValidateRegistry[typeName];
+  if (!fn) throw new Error(`IR runtime missing dynamic validate helper for ${typeName}`);
+  return fn(buffer);
+}
+
 function __tnEvalFootprint(node: __TnIrNode, ctx: __TnIrContext): bigint {
-  return __tnEvalIrNode(node, ctx);
+  return __tnEvalIrNode(node, ctx, __tnToBigInt(0));
 }
 
 function __tnTryEvalFootprint(
@@ -565,7 +591,7 @@ function __tnTryEvalIr(
   ctx: __TnIrContext
 ): __TnEvalResult {
   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) };
   }
@@ -596,7 +622,11 @@ function __tnValidateIrTree(
   return { ok: true, consumed: required };
 }
 
-function __tnEvalIrNode(node: __TnIrNode, ctx: __TnIrContext): bigint {
+function __tnEvalIrNode(
+  node: __TnIrNode,
+  ctx: __TnIrContext,
+  baseOffset: bigint
+): bigint {
   switch (node.op) {
     case "zero":
       return __tnToBigInt(0);
@@ -614,17 +644,22 @@ function __tnEvalIrNode(node: __TnIrNode, ctx: __TnIrContext): bigint {
       return val;
     }
     case "add":
-      return __tnCheckedAdd(
-        __tnEvalIrNode(node.left, ctx),
-        __tnEvalIrNode(node.right, ctx)
-      );
+      {
+        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 === undefined) {
@@ -637,10 +672,10 @@ function __tnEvalIrNode(node: __TnIrNode, ctx: __TnIrContext): bigint {
       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}'`
@@ -660,9 +695,10 @@ function __tnEvalIrNode(node: __TnIrNode, ctx: __TnIrContext): bigint {
         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) {
@@ -682,6 +718,36 @@ function __tnEvalIrNode(node: __TnIrNode, ctx: __TnIrContext): bigint {
       }
       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 === undefined) {
+          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",
@@ -858,9 +924,6 @@ export class Date {
 
 }
 
-__tnRegisterFootprint("Date", (params) => Date.__tnInvokeFootprint(params));
-__tnRegisterValidate("Date", (buffer, params) => Date.__tnInvokeValidate(buffer, params));
-
 export class DateBuilder {
   private buffer: Uint8Array;
   private view: DataView;
@@ -902,6 +965,10 @@ export class DateBuilder {
   }
 }
 
+__tnRegisterFootprint("Date", (params) => Date.__tnInvokeFootprint(params));
+__tnRegisterValidate("Date", (buffer, params) => Date.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Date", (buffer) => { const result = Date.validate(buffer); return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed) }; });
+
 /* ----- TYPE DEFINITION FOR Duration ----- */
 
 const __tn_ir_Duration = {
@@ -1025,9 +1092,6 @@ export class Duration {
 
 }
 
-__tnRegisterFootprint("Duration", (params) => Duration.__tnInvokeFootprint(params));
-__tnRegisterValidate("Duration", (buffer, params) => Duration.__tnInvokeValidate(buffer, params));
-
 export class DurationBuilder {
   private buffer: Uint8Array;
   private view: DataView;
@@ -1065,6 +1129,10 @@ export class DurationBuilder {
   }
 }
 
+__tnRegisterFootprint("Duration", (params) => Duration.__tnInvokeFootprint(params));
+__tnRegisterValidate("Duration", (buffer, params) => Duration.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Duration", (buffer) => { const result = Duration.validate(buffer); return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed) }; });
+
 /* ----- TYPE DEFINITION FOR FixedPoint ----- */
 
 const __tn_ir_FixedPoint = {
@@ -1188,9 +1256,6 @@ export class FixedPoint {
 
 }
 
-__tnRegisterFootprint("FixedPoint", (params) => FixedPoint.__tnInvokeFootprint(params));
-__tnRegisterValidate("FixedPoint", (buffer, params) => FixedPoint.__tnInvokeValidate(buffer, params));
-
 export class FixedPointBuilder {
   private buffer: Uint8Array;
   private view: DataView;
@@ -1228,6 +1293,10 @@ export class FixedPointBuilder {
   }
 }
 
+__tnRegisterFootprint("FixedPoint", (params) => FixedPoint.__tnInvokeFootprint(params));
+__tnRegisterValidate("FixedPoint", (buffer, params) => FixedPoint.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("FixedPoint", (buffer) => { const result = FixedPoint.validate(buffer); return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed) }; });
+
 /* ----- TYPE DEFINITION FOR Hash ----- */
 
 const __tn_ir_Hash = {
@@ -1331,9 +1400,6 @@ export class Hash {
 
 }
 
-__tnRegisterFootprint("Hash", (params) => Hash.__tnInvokeFootprint(params));
-__tnRegisterValidate("Hash", (buffer, params) => Hash.__tnInvokeValidate(buffer, params));
-
 export class HashBuilder {
   private buffer: Uint8Array;
   private view: DataView;
@@ -1369,6 +1435,10 @@ export class HashBuilder {
   }
 }
 
+__tnRegisterFootprint("Hash", (params) => Hash.__tnInvokeFootprint(params));
+__tnRegisterValidate("Hash", (buffer, params) => Hash.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Hash", (buffer) => { const result = Hash.validate(buffer); return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed) }; });
+
 /* ----- TYPE DEFINITION FOR InstructionData ----- */
 
 const __tn_ir_InstructionData = {
@@ -1654,9 +1724,6 @@ export namespace InstructionData {
   }
 }
 
-__tnRegisterFootprint("InstructionData", (params) => InstructionData.__tnInvokeFootprint(params));
-__tnRegisterValidate("InstructionData", (buffer, params) => InstructionData.__tnInvokeValidate(buffer, params));
-
 export class InstructionDataBuilder {
   private buffer: Uint8Array;
   private view: DataView;
@@ -1768,6 +1835,10 @@ export class InstructionDataBuilder {
   }
 }
 
+__tnRegisterFootprint("InstructionData", (params) => InstructionData.__tnInvokeFootprint(params));
+__tnRegisterValidate("InstructionData", (buffer, params) => InstructionData.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("InstructionData", (buffer) => { const result = InstructionData.validate(buffer); return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed) }; });
+
 /* ----- TYPE DEFINITION FOR Pubkey ----- */
 
 const __tn_ir_Pubkey = {
@@ -1871,9 +1942,6 @@ export class Pubkey {
 
 }
 
-__tnRegisterFootprint("Pubkey", (params) => Pubkey.__tnInvokeFootprint(params));
-__tnRegisterValidate("Pubkey", (buffer, params) => Pubkey.__tnInvokeValidate(buffer, params));
-
 export class PubkeyBuilder {
   private buffer: Uint8Array;
   private view: DataView;
@@ -1909,6 +1977,10 @@ export class PubkeyBuilder {
   }
 }
 
+__tnRegisterFootprint("Pubkey", (params) => Pubkey.__tnInvokeFootprint(params));
+__tnRegisterValidate("Pubkey", (buffer, params) => Pubkey.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Pubkey", (buffer) => { const result = Pubkey.validate(buffer); return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed) }; });
+
 /* ----- TYPE DEFINITION FOR Signature ----- */
 
 const __tn_ir_Signature = {
@@ -2012,9 +2084,6 @@ export class Signature {
 
 }
 
-__tnRegisterFootprint("Signature", (params) => Signature.__tnInvokeFootprint(params));
-__tnRegisterValidate("Signature", (buffer, params) => Signature.__tnInvokeValidate(buffer, params));
-
 export class SignatureBuilder {
   private buffer: Uint8Array;
   private view: DataView;
@@ -2050,6 +2119,10 @@ export class SignatureBuilder {
   }
 }
 
+__tnRegisterFootprint("Signature", (params) => Signature.__tnInvokeFootprint(params));
+__tnRegisterValidate("Signature", (buffer, params) => Signature.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Signature", (buffer) => { const result = Signature.validate(buffer); return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed) }; });
+
 /* ----- TYPE DEFINITION FOR Timestamp ----- */
 
 const __tn_ir_Timestamp = {
@@ -2154,9 +2227,6 @@ export class Timestamp {
 
 }
 
-__tnRegisterFootprint("Timestamp", (params) => Timestamp.__tnInvokeFootprint(params));
-__tnRegisterValidate("Timestamp", (buffer, params) => Timestamp.__tnInvokeValidate(buffer, params));
-
 export class TimestampBuilder {
   private buffer: Uint8Array;
   private view: DataView;
@@ -2189,3 +2259,7 @@ export class TimestampBuilder {
   }
 }
 
+__tnRegisterFootprint("Timestamp", (params) => Timestamp.__tnInvokeFootprint(params));
+__tnRegisterValidate("Timestamp", (buffer, params) => Timestamp.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Timestamp", (buffer) => { const result = Timestamp.validate(buffer); return { ok: result.ok, code: result.code, consumed: result.consumed === undefined ? undefined : __tnToBigInt(result.consumed) }; });
+