@thru/programs 0.2.22 → 0.2.23

package/dist/passkey-manager/index.js

@@ -6,7 +6,6 @@ var PASSKEY_MANAGER_PROGRAM_ADDRESS = "taUDdQyFxvM5i0HFRkEK3W45kWLyblAHSnMg4zplg
 var INSTRUCTION_CREATE = 0;
 var INSTRUCTION_VALIDATE = 1;
 var INSTRUCTION_TRANSFER = 2;
-var INSTRUCTION_INVOKE = 3;
 var INSTRUCTION_ADD_AUTHORITY = 4;
 var INSTRUCTION_REMOVE_AUTHORITY = 5;
 var INSTRUCTION_REGISTER_CREDENTIAL = 6;
@@ -293,12 +292,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}`);
@@ -309,12 +312,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) };
   }
@@ -338,7 +346,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);
@@ -355,18 +363,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) {
@@ -379,10 +391,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}'`
@@ -402,9 +414,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) {
@@ -421,6 +434,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",
@@ -553,8 +596,6 @@ var Date = class _Date {
     return new _Date(buffer);
   }
 };
-__tnRegisterFootprint("Date", (params) => Date.__tnInvokeFootprint(params));
-__tnRegisterValidate("Date", (buffer, params) => Date.__tnInvokeValidate(buffer, params));
 var DateBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(6);
@@ -586,6 +627,12 @@ var DateBuilder = class {
     return view;
   }
 };
+__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 === void 0 ? void 0 : __tnToBigInt(result.consumed) };
+});
 var __tn_ir_Duration = {
   typeName: "Duration",
   root: { op: "const", value: 12n }
@@ -680,8 +727,6 @@ var Duration = class _Duration {
     return new _Duration(buffer);
   }
 };
-__tnRegisterFootprint("Duration", (params) => Duration.__tnInvokeFootprint(params));
-__tnRegisterValidate("Duration", (buffer, params) => Duration.__tnInvokeValidate(buffer, params));
 var DurationBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(12);
@@ -710,6 +755,12 @@ var DurationBuilder = class {
     return view;
   }
 };
+__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 === void 0 ? void 0 : __tnToBigInt(result.consumed) };
+});
 var __tn_ir_FixedPoint = {
   typeName: "FixedPoint",
   root: { op: "const", value: 9n }
@@ -804,8 +855,6 @@ var FixedPoint = class _FixedPoint {
     return new _FixedPoint(buffer);
   }
 };
-__tnRegisterFootprint("FixedPoint", (params) => FixedPoint.__tnInvokeFootprint(params));
-__tnRegisterValidate("FixedPoint", (buffer, params) => FixedPoint.__tnInvokeValidate(buffer, params));
 var FixedPointBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(9);
@@ -834,6 +883,12 @@ var FixedPointBuilder = class {
     return view;
   }
 };
+__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 === void 0 ? void 0 : __tnToBigInt(result.consumed) };
+});
 var __tn_ir_Hash = {
   typeName: "Hash",
   root: { op: "const", value: 32n }
@@ -916,8 +971,6 @@ var Hash = class _Hash {
     return new _Hash(buffer);
   }
 };
-__tnRegisterFootprint("Hash", (params) => Hash.__tnInvokeFootprint(params));
-__tnRegisterValidate("Hash", (buffer, params) => Hash.__tnInvokeValidate(buffer, params));
 var HashBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(32);
@@ -945,6 +998,12 @@ var HashBuilder = class {
     return view;
   }
 };
+__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 === void 0 ? void 0 : __tnToBigInt(result.consumed) };
+});
 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 } } } } }
@@ -1182,8 +1241,6 @@ var InstructionData = _InstructionData;
   }
   InstructionData2.params = params;
 })(InstructionData || (InstructionData = {}));
-__tnRegisterFootprint("InstructionData", (params) => InstructionData.__tnInvokeFootprint(params));
-__tnRegisterValidate("InstructionData", (buffer, params) => InstructionData.__tnInvokeValidate(buffer, params));
 var InstructionDataBuilder = class {
   constructor() {
     this.__tnCachedParams = null;
@@ -1281,6 +1338,12 @@ var InstructionDataBuilder = class {
     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);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed) };
+});
 var __tn_ir_Pubkey = {
   typeName: "Pubkey",
   root: { op: "const", value: 32n }
@@ -1363,8 +1426,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);
@@ -1392,6 +1453,12 @@ 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);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed) };
+});
 var __tn_ir_Signature = {
   typeName: "Signature",
   root: { op: "const", value: 64n }
@@ -1474,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);
@@ -1503,6 +1568,12 @@ 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);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed) };
+});
 var __tn_ir_Timestamp = {
   typeName: "Timestamp",
   root: { op: "const", value: 8n }
@@ -1582,8 +1653,6 @@ var Timestamp = class _Timestamp {
     return new _Timestamp(buffer);
   }
 };
-__tnRegisterFootprint("Timestamp", (params) => Timestamp.__tnInvokeFootprint(params));
-__tnRegisterValidate("Timestamp", (buffer, params) => Timestamp.__tnInvokeValidate(buffer, params));
 var TimestampBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(8);
@@ -1608,6 +1677,12 @@ var TimestampBuilder = class {
     return view;
   }
 };
+__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 === void 0 ? void 0 : __tnToBigInt(result.consumed) };
+});
 
 // src/passkey-manager/abi/thru/blockchain/state_proof/types.ts
 var __tnWarnings2 = /* @__PURE__ */ new Set();
@@ -1900,12 +1975,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}`);
@@ -1916,12 +1995,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) };
   }
@@ -1945,7 +2029,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);
@@ -1962,18 +2046,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) {
@@ -1986,10 +2074,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}'`
@@ -2009,9 +2097,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) {
@@ -2028,6 +2117,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",
@@ -2051,6 +2170,18 @@ 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);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt2(result.consumed) };
+});
+__tnRegisterFootprint2("Pubkey", (params) => Pubkey.__tnInvokeFootprint(params));
+__tnRegisterValidate2("Pubkey", (buffer, params) => Pubkey.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate2("Pubkey", (buffer) => {
+  const result = Pubkey.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt2(result.consumed) };
+});
 var __tn_ir_StateProofHeader = {
   typeName: "StateProofHeader",
   root: { op: "const", value: 40n }
@@ -2140,8 +2271,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);
@@ -2171,6 +2300,12 @@ 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);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt2(result.consumed) };
+});
 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" } } } }
@@ -2742,8 +2877,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;
@@ -2850,6 +2983,12 @@ 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);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt2(result.consumed) };
+});
 
 // src/passkey-manager/abi/thru/program/passkey_manager/types.ts
 var __tnWarnings3 = /* @__PURE__ */ new Set();
@@ -2936,33 +3075,6 @@ function __tnCreateVariantSelector2(parent, descriptors, assign) {
     }
   };
 }
-function __tnCreateFamWriter2(parent, fieldName, assign) {
-  let hasWritten = false;
-  return {
-    write(payload) {
-      const bytes = __tnResolveBuilderInput3(
-        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 __tnMask323 = __tnHasNativeBigInt3 ? (BigInt(1) << BigInt(32)) - BigInt(1) : 4294967295;
 var __tnSignBit323 = __tnHasNativeBigInt3 ? BigInt(1) << BigInt(31) : 2147483648;
 function __tnToBigInt3(value) {
@@ -3187,12 +3299,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}`);
@@ -3203,12 +3319,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) };
   }
@@ -3232,7 +3353,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);
@@ -3249,18 +3370,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) {
@@ -3273,10 +3398,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}'`
@@ -3296,9 +3421,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) {
@@ -3315,6 +3441,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",
@@ -3338,6 +3494,24 @@ function __tnNormalizeIrError3(err) {
   if (message.length > 0) return `tn.ir.runtime_error: ${message}`;
   return "tn.ir.runtime_error";
 }
+__tnRegisterFootprint3("InstructionData", (params) => InstructionData.__tnInvokeFootprint(params));
+__tnRegisterValidate3("InstructionData", (buffer, params) => InstructionData.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("InstructionData", (buffer) => {
+  const result = InstructionData.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
+__tnRegisterFootprint3("Pubkey", (params) => Pubkey.__tnInvokeFootprint(params));
+__tnRegisterValidate3("Pubkey", (buffer, params) => Pubkey.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("Pubkey", (buffer) => {
+  const result = Pubkey.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
+__tnRegisterFootprint3("StateProof", (params) => StateProof.__tnInvokeFootprint(params));
+__tnRegisterValidate3("StateProof", (buffer, params) => StateProof.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("StateProof", (buffer) => {
+  const result = StateProof.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
 var __tn_ir_Authority = {
   typeName: "Authority",
   root: { op: "const", value: 65n }
@@ -3434,8 +3608,6 @@ var Authority = class _Authority {
     return new _Authority(buffer);
   }
 };
-__tnRegisterFootprint3("Authority", (params) => Authority.__tnInvokeFootprint(params));
-__tnRegisterValidate3("Authority", (buffer, params) => Authority.__tnInvokeValidate(buffer, params));
 var AuthorityBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(65);
@@ -3467,6 +3639,12 @@ var AuthorityBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("Authority", (params) => Authority.__tnInvokeFootprint(params));
+__tnRegisterValidate3("Authority", (buffer, params) => Authority.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("Authority", (buffer) => {
+  const result = Authority.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
 var __tn_ir_P256Point = {
   typeName: "P256Point",
   root: { op: "const", value: 32n }
@@ -3548,9 +3726,13 @@ _P256Point.__tnElementCount = 32;
 var P256Point = _P256Point;
 __tnRegisterFootprint3("P256Point", (params) => P256Point.__tnInvokeFootprint(params));
 __tnRegisterValidate3("P256Point", (buffer, params) => P256Point.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("P256Point", (buffer) => {
+  const result = P256Point.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
 var __tn_ir_RemoveAuthorityArgs = {
   typeName: "RemoveAuthorityArgs",
-  root: { op: "const", value: 1n }
+  root: { op: "const", value: 3n }
 };
 var RemoveAuthorityArgs = class _RemoveAuthorityArgs {
   constructor(buffer) {
@@ -3568,12 +3750,26 @@ var RemoveAuthorityArgs = class _RemoveAuthorityArgs {
     const buffer = builder.build();
     return _RemoveAuthorityArgs.from_array(buffer);
   }
-  get_auth_idx() {
+  get_wallet_account_idx() {
+    const offset = 0;
+    return this.view.getUint16(offset, true);
+  }
+  set_wallet_account_idx(value) {
     const offset = 0;
+    this.view.setUint16(offset, value, true);
+  }
+  get wallet_account_idx() {
+    return this.get_wallet_account_idx();
+  }
+  set wallet_account_idx(value) {
+    this.set_wallet_account_idx(value);
+  }
+  get_auth_idx() {
+    const offset = 2;
     return this.view.getUint8(offset);
   }
   set_auth_idx(value) {
-    const offset = 0;
+    const offset = 2;
     this.view.setUint8(offset, value);
   }
   get auth_idx() {
@@ -3606,13 +3802,14 @@ var RemoveAuthorityArgs = class _RemoveAuthorityArgs {
     return __tnBigIntToNumber3(irResult, "RemoveAuthorityArgs::footprint");
   }
   static validate(buffer, _opts) {
-    if (buffer.length < 1) return { ok: false, code: "tn.buffer_too_small", consumed: 1 };
-    return { ok: true, consumed: 1 };
+    if (buffer.length < 3) return { ok: false, code: "tn.buffer_too_small", consumed: 3 };
+    return { ok: true, consumed: 3 };
   }
-  static new(auth_idx) {
-    const buffer = new Uint8Array(1);
+  static new(wallet_account_idx, auth_idx) {
+    const buffer = new Uint8Array(3);
     const view = new DataView(buffer.buffer);
-    view.setUint8(0, auth_idx);
+    view.setUint16(0, wallet_account_idx, true);
+    view.setUint8(2, auth_idx);
     return new _RemoveAuthorityArgs(buffer);
   }
   static from_array(buffer) {
@@ -3627,15 +3824,17 @@ var RemoveAuthorityArgs = class _RemoveAuthorityArgs {
     return new _RemoveAuthorityArgs(buffer);
   }
 };
-__tnRegisterFootprint3("RemoveAuthorityArgs", (params) => RemoveAuthorityArgs.__tnInvokeFootprint(params));
-__tnRegisterValidate3("RemoveAuthorityArgs", (buffer, params) => RemoveAuthorityArgs.__tnInvokeValidate(buffer, params));
 var RemoveAuthorityArgsBuilder = class {
   constructor() {
-    this.buffer = new Uint8Array(1);
+    this.buffer = new Uint8Array(3);
     this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
   }
+  set_wallet_account_idx(value) {
+    this.view.setUint16(0, value, true);
+    return this;
+  }
   set_auth_idx(value) {
-    this.view.setUint8(0, value);
+    this.view.setUint8(2, value);
     return this;
   }
   build() {
@@ -3652,6 +3851,12 @@ var RemoveAuthorityArgsBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("RemoveAuthorityArgs", (params) => RemoveAuthorityArgs.__tnInvokeFootprint(params));
+__tnRegisterValidate3("RemoveAuthorityArgs", (buffer, params) => RemoveAuthorityArgs.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("RemoveAuthorityArgs", (buffer) => {
+  const result = RemoveAuthorityArgs.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
 var __tn_ir_Seed32 = {
   typeName: "Seed32",
   root: { op: "const", value: 32n }
@@ -3733,6 +3938,10 @@ _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);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
 var __tn_ir_TransferArgs = {
   typeName: "TransferArgs",
   root: { op: "const", value: 12n }
@@ -3842,8 +4051,6 @@ var TransferArgs = class _TransferArgs {
     return new _TransferArgs(buffer);
   }
 };
-__tnRegisterFootprint3("TransferArgs", (params) => TransferArgs.__tnInvokeFootprint(params));
-__tnRegisterValidate3("TransferArgs", (buffer, params) => TransferArgs.__tnInvokeValidate(buffer, params));
 var TransferArgsBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(12);
@@ -3876,9 +4083,15 @@ var TransferArgsBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("TransferArgs", (params) => TransferArgs.__tnInvokeFootprint(params));
+__tnRegisterValidate3("TransferArgs", (buffer, params) => TransferArgs.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("TransferArgs", (buffer) => {
+  const result = TransferArgs.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
 var __tn_ir_ValidateArgs = {
   typeName: "ValidateArgs",
-  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: "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: 2, node: { op: "const", value: 2n } } }, right: { op: "align", alignment: 2, node: { op: "const", value: 2n } } }, right: { op: "align", alignment: 1, node: { op: "mul", left: { op: "field", param: "authenticator_data.authenticator_data_len" }, right: { op: "const", value: 1n } } } }, right: { op: "align", alignment: 1, node: { op: "mul", left: { op: "field", param: "client_data.client_data_len" }, right: { op: "const", value: 1n } } } } }
+  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: 2, node: { op: "const", value: 2n } } }, right: { op: "align", alignment: 2, node: { op: "const", value: 2n } } }, right: { op: "align", alignment: 1, node: { op: "mul", left: { op: "field", param: "authenticator_data.authenticator_data_len" }, right: { op: "const", value: 1n } } } }, right: { op: "align", alignment: 1, node: { op: "mul", left: { op: "field", param: "client_data.client_data_len" }, right: { op: "const", value: 1n } } } }, right: { op: "align", alignment: 1, node: { op: "call", typeName: "InstructionData", args: [{ name: "data.data_size", source: "data.data_size" }] } } } }
 };
 var _ValidateArgs = class _ValidateArgs {
   constructor(buffer, params, fieldContext) {
@@ -3930,14 +4143,6 @@ var _ValidateArgs = class _ValidateArgs {
     }
     throw new Error("ValidateArgs: field reference '" + path + "' is not available; provide fieldContext when creating this view");
   }
-  static builder() {
-    return new ValidateArgsBuilder();
-  }
-  static fromBuilder(builder) {
-    const buffer = builder.build();
-    const params = builder.dynamicParams();
-    return _ValidateArgs.from_array(buffer, { params });
-  }
   static __tnComputeSequentialLayout(view, buffer) {
     const offsets = /* @__PURE__ */ Object.create(null);
     const __tnLength = buffer.length;
@@ -3975,7 +4180,7 @@ var _ValidateArgs = class _ValidateArgs {
     offsets["client_data"] = __tnCursorMutable;
     if (__tnCursorMutable + __tnArrayBytes_client_data > __tnLength) return null;
     __tnCursorMutable += __tnArrayBytes_client_data;
-    return { params: null, offsets, derived: null };
+    return null;
   }
   static __tnExtractParams(view, buffer) {
     if (buffer.length < 69) {
@@ -4159,6 +4364,29 @@ var _ValidateArgs = class _ValidateArgs {
   set client_data(value) {
     this.set_client_data(value);
   }
+  get_target_instruction() {
+    const offset = this.__tnGetDynamicOffset("target_instruction");
+    const tail = this.buffer.subarray(offset);
+    const validation = InstructionData.validate(tail);
+    if (!validation.ok || validation.consumed === void 0) {
+      throw new Error("ValidateArgs: failed to read field 'target_instruction' (invalid nested payload)");
+    }
+    const length = validation.consumed;
+    const slice = tail.subarray(0, length);
+    const opts = validation.params ? { params: validation.params } : void 0;
+    return InstructionData.from_array(slice, opts);
+  }
+  set_target_instruction(value) {
+    const sourceBytes = value.buffer;
+    const offset = this.__tnGetDynamicOffset("target_instruction");
+    this.buffer.set(sourceBytes, offset);
+  }
+  get target_instruction() {
+    return this.get_target_instruction();
+  }
+  set target_instruction(value) {
+    this.set_target_instruction(value);
+  }
   static __tnFootprintInternal(__tnParams) {
     return __tnEvalFootprint3(__tn_ir_ValidateArgs.root, { params: __tnParams });
   }
@@ -4274,147 +4502,10 @@ var ValidateArgs = _ValidateArgs;
 })(ValidateArgs || (ValidateArgs = {}));
 __tnRegisterFootprint3("ValidateArgs", (params) => ValidateArgs.__tnInvokeFootprint(params));
 __tnRegisterValidate3("ValidateArgs", (buffer, params) => ValidateArgs.__tnInvokeValidate(buffer, params));
-var ValidateArgsBuilder = class {
-  constructor() {
-    this.__tnCachedParams = null;
-    this.__tnLastBuffer = null;
-    this.__tnLastParams = null;
-    this.__tnFam_authenticator_data = null;
-    this.__tnFam_authenticator_dataCount = null;
-    this.__tnFam_client_data = null;
-    this.__tnFam_client_dataCount = null;
-    this.buffer = new Uint8Array(71);
-    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
-  }
-  __tnInvalidate() {
-    this.__tnCachedParams = null;
-    this.__tnLastBuffer = null;
-    this.__tnLastParams = null;
-  }
-  set_wallet_account_idx(value) {
-    this.view.setUint16(0, value, true);
-    this.__tnInvalidate();
-    return this;
-  }
-  set_auth_idx(value) {
-    this.view.setUint8(2, value);
-    this.__tnInvalidate();
-    return this;
-  }
-  set_signature_r(value) {
-    if (value.length !== 32) throw new Error("signature_r expects 32 bytes");
-    this.buffer.set(value, 3);
-    this.__tnInvalidate();
-    return this;
-  }
-  set_signature_s(value) {
-    if (value.length !== 32) throw new Error("signature_s expects 32 bytes");
-    this.buffer.set(value, 35);
-    this.__tnInvalidate();
-    return this;
-  }
-  set_authenticator_data_len(value) {
-    this.view.setUint16(67, value, true);
-    this.__tnInvalidate();
-    return this;
-  }
-  set_client_data_len(value) {
-    this.view.setUint16(69, value, true);
-    this.__tnInvalidate();
-    return this;
-  }
-  authenticator_data() {
-    if (!this.__tnFamWriter_authenticator_data) {
-      this.__tnFamWriter_authenticator_data = __tnCreateFamWriter2(this, "authenticator_data", (payload) => {
-        const bytes = new Uint8Array(payload);
-        const elementCount = bytes.length;
-        this.__tnFam_authenticator_data = bytes;
-        this.__tnFam_authenticator_dataCount = elementCount;
-        this.set_authenticator_data_len(elementCount);
-        this.__tnInvalidate();
-      });
-    }
-    return this.__tnFamWriter_authenticator_data;
-  }
-  client_data() {
-    if (!this.__tnFamWriter_client_data) {
-      this.__tnFamWriter_client_data = __tnCreateFamWriter2(this, "client_data", (payload) => {
-        const bytes = new Uint8Array(payload);
-        const elementCount = bytes.length;
-        this.__tnFam_client_data = bytes;
-        this.__tnFam_client_dataCount = elementCount;
-        this.set_client_data_len(elementCount);
-        this.__tnInvalidate();
-      });
-    }
-    return this.__tnFamWriter_client_data;
-  }
-  build() {
-    const params = this.__tnComputeParams();
-    const size = ValidateArgs.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 = ValidateArgs.footprintFromParams(params);
-    if (target.length - offset < size) throw new Error("ValidateArgsBuilder: 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 = ValidateArgs.from_array(buffer, { params });
-    if (!view) throw new Error("ValidateArgsBuilder: failed to finalize view");
-    return view;
-  }
-  finishView() {
-    return this.finish();
-  }
-  dynamicParams() {
-    return this.__tnComputeParams();
-  }
-  __tnComputeParams() {
-    if (this.__tnCachedParams) return this.__tnCachedParams;
-    const params = ValidateArgs.Params.fromValues({
-      authenticator_data_authenticator_data_len: (() => {
-        if (this.__tnFam_authenticator_dataCount === null) throw new Error("ValidateArgsBuilder: field 'authenticator_data' must be written before computing params");
-        return __tnToBigInt3(this.__tnFam_authenticator_dataCount);
-      })(),
-      client_data_client_data_len: (() => {
-        if (this.__tnFam_client_dataCount === null) throw new Error("ValidateArgsBuilder: field 'client_data' must be written before computing params");
-        return __tnToBigInt3(this.__tnFam_client_dataCount);
-      })()
-    });
-    this.__tnCachedParams = params;
-    return params;
-  }
-  __tnWriteInto(target) {
-    target.set(this.buffer, 0);
-    let cursor = this.buffer.length;
-    const __tnLocal_authenticator_data_bytes = this.__tnFam_authenticator_data;
-    if (!__tnLocal_authenticator_data_bytes) throw new Error("ValidateArgsBuilder: field 'authenticator_data' must be written before build");
-    target.set(__tnLocal_authenticator_data_bytes, cursor);
-    cursor += __tnLocal_authenticator_data_bytes.length;
-    const __tnLocal_client_data_bytes = this.__tnFam_client_data;
-    if (!__tnLocal_client_data_bytes) throw new Error("ValidateArgsBuilder: field 'client_data' must be written before build");
-    target.set(__tnLocal_client_data_bytes, cursor);
-    cursor += __tnLocal_client_data_bytes.length;
-  }
-  __tnValidateOrThrow(buffer, params) {
-    const result = ValidateArgs.validate(buffer, { params });
-    if (!result.ok) {
-      throw new Error(`${ValidateArgs}Builder: builder produced invalid buffer (code=${result.code ?? "unknown"})`);
-    }
-    this.__tnLastParams = result.params ?? params;
-    this.__tnLastBuffer = buffer;
-  }
-};
+__tnRegisterDynamicValidate3("ValidateArgs", (buffer) => {
+  const result = ValidateArgs.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
 var __tn_ir_WalletAccount = {
   typeName: "WalletAccount",
   root: { op: "const", value: 9n }
@@ -4509,8 +4600,6 @@ var WalletAccount = class _WalletAccount {
     return new _WalletAccount(buffer);
   }
 };
-__tnRegisterFootprint3("WalletAccount", (params) => WalletAccount.__tnInvokeFootprint(params));
-__tnRegisterValidate3("WalletAccount", (buffer, params) => WalletAccount.__tnInvokeValidate(buffer, params));
 var WalletAccountBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(9);
@@ -4539,7 +4628,13 @@ var WalletAccountBuilder = class {
     return view;
   }
 };
-var __tn_ir_WalletCreatedEventData = {
+__tnRegisterFootprint3("WalletAccount", (params) => WalletAccount.__tnInvokeFootprint(params));
+__tnRegisterValidate3("WalletAccount", (buffer, params) => WalletAccount.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("WalletAccount", (buffer) => {
+  const result = WalletAccount.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
+var __tn_ir_WalletCreatedEventData = {
   typeName: "WalletCreatedEventData",
   root: { op: "const", value: 97n }
 };
@@ -4630,8 +4725,6 @@ var WalletCreatedEventData = class _WalletCreatedEventData {
     return new _WalletCreatedEventData(buffer);
   }
 };
-__tnRegisterFootprint3("WalletCreatedEventData", (params) => WalletCreatedEventData.__tnInvokeFootprint(params));
-__tnRegisterValidate3("WalletCreatedEventData", (buffer, params) => WalletCreatedEventData.__tnInvokeValidate(buffer, params));
 var WalletCreatedEventDataBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(97);
@@ -4661,6 +4754,12 @@ var WalletCreatedEventDataBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("WalletCreatedEventData", (params) => WalletCreatedEventData.__tnInvokeFootprint(params));
+__tnRegisterValidate3("WalletCreatedEventData", (buffer, params) => WalletCreatedEventData.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("WalletCreatedEventData", (buffer) => {
+  const result = WalletCreatedEventData.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
 var __tn_ir_WalletTransferEventData = {
   typeName: "WalletTransferEventData",
   root: { op: "const", value: 72n }
@@ -4766,8 +4865,6 @@ var WalletTransferEventData = class _WalletTransferEventData {
     return new _WalletTransferEventData(buffer);
   }
 };
-__tnRegisterFootprint3("WalletTransferEventData", (params) => WalletTransferEventData.__tnInvokeFootprint(params));
-__tnRegisterValidate3("WalletTransferEventData", (buffer, params) => WalletTransferEventData.__tnInvokeValidate(buffer, params));
 var WalletTransferEventDataBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(72);
@@ -4802,6 +4899,12 @@ var WalletTransferEventDataBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("WalletTransferEventData", (params) => WalletTransferEventData.__tnInvokeFootprint(params));
+__tnRegisterValidate3("WalletTransferEventData", (buffer, params) => WalletTransferEventData.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("WalletTransferEventData", (buffer) => {
+  const result = WalletTransferEventData.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
 var __tn_ir_WalletValidatedEventData = {
   typeName: "WalletValidatedEventData",
   root: { op: "const", value: 40n }
@@ -4891,8 +4994,6 @@ var WalletValidatedEventData = class _WalletValidatedEventData {
     return new _WalletValidatedEventData(buffer);
   }
 };
-__tnRegisterFootprint3("WalletValidatedEventData", (params) => WalletValidatedEventData.__tnInvokeFootprint(params));
-__tnRegisterValidate3("WalletValidatedEventData", (buffer, params) => WalletValidatedEventData.__tnInvokeValidate(buffer, params));
 var WalletValidatedEventDataBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(40);
@@ -4922,9 +5023,15 @@ var WalletValidatedEventDataBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("WalletValidatedEventData", (params) => WalletValidatedEventData.__tnInvokeFootprint(params));
+__tnRegisterValidate3("WalletValidatedEventData", (buffer, params) => WalletValidatedEventData.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("WalletValidatedEventData", (buffer) => {
+  const result = WalletValidatedEventData.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
 var __tn_ir_AddAuthorityArgs = {
   typeName: "AddAuthorityArgs",
-  root: { op: "const", value: 65n }
+  root: { op: "const", value: 67n }
 };
 var AddAuthorityArgs = class _AddAuthorityArgs {
   constructor(buffer) {
@@ -4942,14 +5049,28 @@ var AddAuthorityArgs = class _AddAuthorityArgs {
     const buffer = builder.build();
     return _AddAuthorityArgs.from_array(buffer);
   }
-  get_authority() {
+  get_wallet_account_idx() {
+    const offset = 0;
+    return this.view.getUint16(offset, true);
+  }
+  set_wallet_account_idx(value) {
     const offset = 0;
+    this.view.setUint16(offset, value, true);
+  }
+  get wallet_account_idx() {
+    return this.get_wallet_account_idx();
+  }
+  set wallet_account_idx(value) {
+    this.set_wallet_account_idx(value);
+  }
+  get_authority() {
+    const offset = 2;
     const slice = this.buffer.subarray(offset, offset + 65);
     return Authority.from_array(slice);
   }
   set_authority(value) {
     const sourceBytes = value.buffer;
-    const offset = 0;
+    const offset = 2;
     this.buffer.set(sourceBytes, offset);
   }
   get authority() {
@@ -4982,8 +5103,8 @@ var AddAuthorityArgs = class _AddAuthorityArgs {
     return __tnBigIntToNumber3(irResult, "AddAuthorityArgs::footprint");
   }
   static validate(buffer, _opts) {
-    if (buffer.length < 65) return { ok: false, code: "tn.buffer_too_small", consumed: 65 };
-    return { ok: true, consumed: 65 };
+    if (buffer.length < 67) return { ok: false, code: "tn.buffer_too_small", consumed: 67 };
+    return { ok: true, consumed: 67 };
   }
   static from_array(buffer) {
     if (!buffer || buffer.length === void 0) {
@@ -4997,16 +5118,18 @@ var AddAuthorityArgs = class _AddAuthorityArgs {
     return new _AddAuthorityArgs(buffer);
   }
 };
-__tnRegisterFootprint3("AddAuthorityArgs", (params) => AddAuthorityArgs.__tnInvokeFootprint(params));
-__tnRegisterValidate3("AddAuthorityArgs", (buffer, params) => AddAuthorityArgs.__tnInvokeValidate(buffer, params));
 var AddAuthorityArgsBuilder = class {
   constructor() {
-    this.buffer = new Uint8Array(65);
+    this.buffer = new Uint8Array(67);
     this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
   }
+  set_wallet_account_idx(value) {
+    this.view.setUint16(0, value, true);
+    return this;
+  }
   set_authority(value) {
     if (value.length !== 65) throw new Error("authority expects 65 bytes");
-    this.buffer.set(value, 0);
+    this.buffer.set(value, 2);
     return this;
   }
   build() {
@@ -5023,6 +5146,12 @@ var AddAuthorityArgsBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("AddAuthorityArgs", (params) => AddAuthorityArgs.__tnInvokeFootprint(params));
+__tnRegisterValidate3("AddAuthorityArgs", (buffer, params) => AddAuthorityArgs.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("AddAuthorityArgs", (buffer) => {
+  const result = AddAuthorityArgs.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
 var __tn_ir_CredentialLookup = {
   typeName: "CredentialLookup",
   root: { op: "const", value: 32n }
@@ -5098,8 +5227,6 @@ var CredentialLookup = class _CredentialLookup {
     return new _CredentialLookup(buffer);
   }
 };
-__tnRegisterFootprint3("CredentialLookup", (params) => CredentialLookup.__tnInvokeFootprint(params));
-__tnRegisterValidate3("CredentialLookup", (buffer, params) => CredentialLookup.__tnInvokeValidate(buffer, params));
 var CredentialLookupBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(32);
@@ -5124,6 +5251,12 @@ var CredentialLookupBuilder = class {
     return view;
   }
 };
+__tnRegisterFootprint3("CredentialLookup", (params) => CredentialLookup.__tnInvokeFootprint(params));
+__tnRegisterValidate3("CredentialLookup", (buffer, params) => CredentialLookup.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("CredentialLookup", (buffer) => {
+  const result = CredentialLookup.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
 var __tn_ir_CredentialRegisteredEventData = {
   typeName: "CredentialRegisteredEventData",
   root: { op: "const", value: 64n }
@@ -5215,8 +5348,6 @@ var CredentialRegisteredEventData = class _CredentialRegisteredEventData {
     return new _CredentialRegisteredEventData(buffer);
   }
 };
-__tnRegisterFootprint3("CredentialRegisteredEventData", (params) => CredentialRegisteredEventData.__tnInvokeFootprint(params));
-__tnRegisterValidate3("CredentialRegisteredEventData", (buffer, params) => CredentialRegisteredEventData.__tnInvokeValidate(buffer, params));
 var CredentialRegisteredEventDataBuilder = class {
   constructor() {
     this.buffer = new Uint8Array(64);
@@ -5246,344 +5377,12 @@ var CredentialRegisteredEventDataBuilder = class {
     return view;
   }
 };
-var __tn_ir_InvokeArgs = {
-  typeName: "InvokeArgs",
-  root: { op: "align", alignment: 1, node: { op: "add", left: { op: "add", left: { op: "align", alignment: 1, node: { op: "const", value: 32n } }, right: { op: "align", alignment: 2, node: { op: "const", value: 2n } } }, right: { op: "align", alignment: 1, node: { op: "mul", left: { op: "field", param: "instr.instr_len" }, right: { op: "const", value: 1n } } } } }
-};
-var _InvokeArgs = class _InvokeArgs {
-  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 = _InvokeArgs.__tnExtractParams(this.view, buffer);
-      if (!derived) {
-        throw new Error("InvokeArgs: failed to derive dynamic parameters");
-      }
-      this.__tnParams = derived.params;
-    }
-  }
-  static __tnCreateView(buffer, opts) {
-    if (!buffer || buffer.length === void 0) throw new Error("InvokeArgs.__tnCreateView requires a Uint8Array");
-    let params = opts?.params ?? null;
-    if (!params) {
-      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-      const derived = _InvokeArgs.__tnExtractParams(view, buffer);
-      if (!derived) throw new Error("InvokeArgs.__tnCreateView: failed to derive params");
-      params = derived.params;
-    }
-    const instance = new _InvokeArgs(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" ? __tnBigIntToNumber3(value, "InvokeArgs::__tnResolveFieldRef") : value;
-    }
-    if (this.__tnFieldContext && Object.prototype.hasOwnProperty.call(this.__tnFieldContext, path)) {
-      const contextValue = this.__tnFieldContext[path];
-      return typeof contextValue === "bigint" ? __tnBigIntToNumber3(contextValue, "InvokeArgs::__tnResolveFieldRef") : contextValue;
-    }
-    throw new Error("InvokeArgs: field reference '" + path + "' is not available; provide fieldContext when creating this view");
-  }
-  static builder() {
-    return new InvokeArgsBuilder();
-  }
-  static fromBuilder(builder) {
-    const buffer = builder.build();
-    const params = builder.dynamicParams();
-    return _InvokeArgs.from_array(buffer, { params });
-  }
-  static __tnExtractParams(view, buffer) {
-    if (buffer.length < 34) {
-      return null;
-    }
-    const __tnParam_instr_instr_len = __tnToBigInt3(view.getUint16(32, true));
-    const __tnExtractedParams = _InvokeArgs.Params.fromValues({
-      instr_instr_len: __tnParam_instr_instr_len
-    });
-    return { params: __tnExtractedParams, derived: null };
-  }
-  get_program_pubkey() {
-    const offset = 0;
-    const slice = this.buffer.subarray(offset, offset + 32);
-    return Pubkey.from_array(slice);
-  }
-  set_program_pubkey(value) {
-    const sourceBytes = value.buffer;
-    const offset = 0;
-    this.buffer.set(sourceBytes, offset);
-  }
-  get program_pubkey() {
-    return this.get_program_pubkey();
-  }
-  set program_pubkey(value) {
-    this.set_program_pubkey(value);
-  }
-  get_instr_len() {
-    const offset = 32;
-    return this.view.getUint16(offset, true);
-  }
-  set_instr_len(value) {
-    const offset = 32;
-    this.view.setUint16(offset, value, true);
-  }
-  get instr_len() {
-    return this.get_instr_len();
-  }
-  set instr_len(value) {
-    this.set_instr_len(value);
-  }
-  get_instr_length() {
-    return this.__tnResolveFieldRef("instr_len");
-  }
-  get_instr_at(index) {
-    const offset = 34;
-    return this.view.getUint8(offset + index * 1);
-  }
-  get_instr() {
-    const len = this.get_instr_length();
-    const result = [];
-    for (let i = 0; i < len; i++) {
-      result.push(this.get_instr_at(i));
-    }
-    return result;
-  }
-  set_instr_at(index, value) {
-    const offset = 34;
-    this.view.setUint8(offset + index * 1, value);
-  }
-  set_instr(value) {
-    const len = Math.min(this.get_instr_length(), value.length);
-    for (let i = 0; i < len; i++) {
-      this.set_instr_at(i, value[i]);
-    }
-  }
-  get instr() {
-    return this.get_instr();
-  }
-  set instr(value) {
-    this.set_instr(value);
-  }
-  static __tnFootprintInternal(__tnParams) {
-    return __tnEvalFootprint3(__tn_ir_InvokeArgs.root, { params: __tnParams });
-  }
-  static __tnValidateInternal(buffer, __tnParams) {
-    return __tnValidateIrTree3(__tn_ir_InvokeArgs, buffer, __tnParams);
-  }
-  static __tnInvokeFootprint(__tnParams) {
-    return this.__tnFootprintInternal(__tnParams);
-  }
-  static __tnInvokeValidate(buffer, __tnParams) {
-    return this.__tnValidateInternal(buffer, __tnParams);
-  }
-  static footprintIr(instr_instr_len) {
-    const params = _InvokeArgs.Params.fromValues({
-      instr_instr_len
-    });
-    return this.footprintIrFromParams(params);
-  }
-  static __tnPackParams(params) {
-    const record = /* @__PURE__ */ Object.create(null);
-    record["instr.instr_len"] = params.instr_instr_len;
-    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 InvokeArgs");
-    return __tnBigIntToNumber3(irResult, "InvokeArgs::footprintFromParams");
-  }
-  static footprintFromValues(input) {
-    const params = _InvokeArgs.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 ? __tnBigIntToNumber3(irResult.consumed, "InvokeArgs::validate") : void 0, params };
-    }
-    const consumed = irResult.consumed ? __tnBigIntToNumber3(irResult.consumed, "InvokeArgs::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 _InvokeArgs(buffer, cached);
-    return state;
-  }
-};
-_InvokeArgs.flexibleArrayWriters = Object.freeze([
-  { field: "instr", method: "instr", sizeField: "instr_len", paramKey: "instr_len", elementSize: 1 }
-]);
-var InvokeArgs = _InvokeArgs;
-((InvokeArgs2) => {
-  InvokeArgs2.ParamKeys = Object.freeze({
-    instr_instr_len: "instr.instr_len"
-  });
-  InvokeArgs2.Params = {
-    fromValues(input) {
-      return {
-        instr_instr_len: __tnToBigInt3(input.instr_instr_len)
-      };
-    },
-    fromBuilder(source) {
-      if (source.dynamicParams) {
-        return source.dynamicParams();
-      }
-      if (source.params) {
-        return source.params;
-      }
-      return source;
-    }
-  };
-  function params(input) {
-    return InvokeArgs2.Params.fromValues(input);
-  }
-  InvokeArgs2.params = params;
-})(InvokeArgs || (InvokeArgs = {}));
-__tnRegisterFootprint3("InvokeArgs", (params) => InvokeArgs.__tnInvokeFootprint(params));
-__tnRegisterValidate3("InvokeArgs", (buffer, params) => InvokeArgs.__tnInvokeValidate(buffer, params));
-var InvokeArgsBuilder = class {
-  constructor() {
-    this.__tnCachedParams = null;
-    this.__tnLastBuffer = null;
-    this.__tnLastParams = null;
-    this.__tnFam_instr = null;
-    this.__tnFam_instrCount = null;
-    this.buffer = new Uint8Array(34);
-    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_pubkey(value) {
-    if (value.length !== 32) throw new Error("program_pubkey expects 32 bytes");
-    this.buffer.set(value, 0);
-    this.__tnInvalidate();
-    return this;
-  }
-  set_instr_len(value) {
-    this.view.setUint16(32, value, true);
-    this.__tnInvalidate();
-    return this;
-  }
-  instr() {
-    if (!this.__tnFamWriter_instr) {
-      this.__tnFamWriter_instr = __tnCreateFamWriter2(this, "instr", (payload) => {
-        const bytes = new Uint8Array(payload);
-        const elementCount = bytes.length;
-        this.__tnFam_instr = bytes;
-        this.__tnFam_instrCount = elementCount;
-        this.set_instr_len(elementCount);
-        this.__tnInvalidate();
-      });
-    }
-    return this.__tnFamWriter_instr;
-  }
-  build() {
-    const params = this.__tnComputeParams();
-    const size = InvokeArgs.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 = InvokeArgs.footprintFromParams(params);
-    if (target.length - offset < size) throw new Error("InvokeArgsBuilder: 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 = InvokeArgs.from_array(buffer, { params });
-    if (!view) throw new Error("InvokeArgsBuilder: failed to finalize view");
-    return view;
-  }
-  finishView() {
-    return this.finish();
-  }
-  dynamicParams() {
-    return this.__tnComputeParams();
-  }
-  __tnComputeParams() {
-    if (this.__tnCachedParams) return this.__tnCachedParams;
-    const params = InvokeArgs.Params.fromValues({
-      instr_instr_len: (() => {
-        if (this.__tnFam_instrCount === null) throw new Error("InvokeArgsBuilder: field 'instr' must be written before computing params");
-        return __tnToBigInt3(this.__tnFam_instrCount);
-      })()
-    });
-    this.__tnCachedParams = params;
-    return params;
-  }
-  __tnWriteInto(target) {
-    target.set(this.buffer, 0);
-    let cursor = this.buffer.length;
-    const __tnLocal_instr_bytes = this.__tnFam_instr;
-    if (!__tnLocal_instr_bytes) throw new Error("InvokeArgsBuilder: field 'instr' must be written before build");
-    target.set(__tnLocal_instr_bytes, cursor);
-    cursor += __tnLocal_instr_bytes.length;
-  }
-  __tnValidateOrThrow(buffer, params) {
-    const result = InvokeArgs.validate(buffer, { params });
-    if (!result.ok) {
-      throw new Error(`${InvokeArgs}Builder: builder produced invalid buffer (code=${result.code ?? "unknown"})`);
-    }
-    this.__tnLastParams = result.params ?? params;
-    this.__tnLastBuffer = buffer;
-  }
-};
+__tnRegisterFootprint3("CredentialRegisteredEventData", (params) => CredentialRegisteredEventData.__tnInvokeFootprint(params));
+__tnRegisterValidate3("CredentialRegisteredEventData", (buffer, params) => CredentialRegisteredEventData.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("CredentialRegisteredEventData", (buffer) => {
+  const result = CredentialRegisteredEventData.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
 var __tn_ir_PasskeyEvent = {
   typeName: "PasskeyEvent",
   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: "PasskeyEvent::payload.event_type", cases: [{ value: 0, node: { op: "align", alignment: 1, node: { op: "const", value: 97n } } }, { value: 1, node: { op: "align", alignment: 1, node: { op: "const", value: 40n } } }, { value: 2, node: { op: "align", alignment: 1, node: { op: "const", value: 72n } } }, { value: 3, node: { op: "align", alignment: 1, node: { op: "const", value: 64n } } }] } } } }
@@ -5834,8 +5633,6 @@ var PasskeyEvent = _PasskeyEvent;
   }
   PasskeyEvent2.params = params;
 })(PasskeyEvent || (PasskeyEvent = {}));
-__tnRegisterFootprint3("PasskeyEvent", (params) => PasskeyEvent.__tnInvokeFootprint(params));
-__tnRegisterValidate3("PasskeyEvent", (buffer, params) => PasskeyEvent.__tnInvokeValidate(buffer, params));
 var PasskeyEventBuilder = class {
   constructor() {
     this.__tnField_event_type = null;
@@ -5935,6 +5732,12 @@ var PasskeyEventBuilder = class {
     this.__tnLastBuffer = buffer;
   }
 };
+__tnRegisterFootprint3("PasskeyEvent", (params) => PasskeyEvent.__tnInvokeFootprint(params));
+__tnRegisterValidate3("PasskeyEvent", (buffer, params) => PasskeyEvent.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("PasskeyEvent", (buffer) => {
+  const result = PasskeyEvent.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
 var __tn_ir_CreateArgs = {
   typeName: "CreateArgs",
   root: { op: "align", alignment: 1, node: { 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: 65n } } }, 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" }] } } } }
@@ -6063,8 +5866,6 @@ var CreateArgs = class _CreateArgs {
     return new _CreateArgs(buffer);
   }
 };
-__tnRegisterFootprint3("CreateArgs", (params) => CreateArgs.__tnInvokeFootprint(params));
-__tnRegisterValidate3("CreateArgs", (buffer, params) => CreateArgs.__tnInvokeValidate(buffer, params));
 var CreateArgsBuilder = class {
   constructor() {
     this.__tnTail_state_proof = null;
@@ -6153,6 +5954,12 @@ var CreateArgsBuilder = class {
     }
   }
 };
+__tnRegisterFootprint3("CreateArgs", (params) => CreateArgs.__tnInvokeFootprint(params));
+__tnRegisterValidate3("CreateArgs", (buffer, params) => CreateArgs.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("CreateArgs", (buffer) => {
+  const result = CreateArgs.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
 var __tn_ir_RegisterCredentialArgs = {
   typeName: "RegisterCredentialArgs",
   root: { op: "align", alignment: 1, node: { 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: 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" }] } } } }
@@ -6279,8 +6086,6 @@ var RegisterCredentialArgs = class _RegisterCredentialArgs {
     return new _RegisterCredentialArgs(buffer);
   }
 };
-__tnRegisterFootprint3("RegisterCredentialArgs", (params) => RegisterCredentialArgs.__tnInvokeFootprint(params));
-__tnRegisterValidate3("RegisterCredentialArgs", (buffer, params) => RegisterCredentialArgs.__tnInvokeValidate(buffer, params));
 var RegisterCredentialArgsBuilder = class {
   constructor() {
     this.__tnTail_state_proof = null;
@@ -6368,6 +6173,12 @@ var RegisterCredentialArgsBuilder = class {
     }
   }
 };
+__tnRegisterFootprint3("RegisterCredentialArgs", (params) => RegisterCredentialArgs.__tnInvokeFootprint(params));
+__tnRegisterValidate3("RegisterCredentialArgs", (buffer, params) => RegisterCredentialArgs.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("RegisterCredentialArgs", (buffer) => {
+  const result = RegisterCredentialArgs.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
 var __tn_ir_PasskeyInstruction = {
   typeName: "PasskeyInstruction",
   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" } } } }
@@ -6401,10 +6212,6 @@ var PasskeyInstruction_payload_Inner = class _PasskeyInstruction_payload_Inner {
     if (!this.descriptor || this.descriptor.tag !== 2) return null;
     return TransferArgs.__tnCreateView(new Uint8Array(this.buffer), { fieldContext: this.__tnFieldContext ?? void 0 });
   }
-  asInvoke() {
-    if (!this.descriptor || this.descriptor.tag !== 3) return null;
-    return InvokeArgs.__tnCreateView(new Uint8Array(this.buffer), { fieldContext: this.__tnFieldContext ?? void 0 });
-  }
   asAddAuthority() {
     if (!this.descriptor || this.descriptor.tag !== 4) return null;
     return AddAuthorityArgs.__tnCreateView(new Uint8Array(this.buffer), { fieldContext: this.__tnFieldContext ?? void 0 });
@@ -6474,8 +6281,6 @@ var _PasskeyInstruction = class _PasskeyInstruction {
         break;
       case 2:
         break;
-      case 3:
-        break;
       case 4:
         break;
       case 5:
@@ -6633,7 +6438,7 @@ _PasskeyInstruction.payloadVariantDescriptors = Object.freeze([
     tag: 1,
     payloadSize: null,
     payloadType: "PasskeyInstruction::payload::validate",
-    createPayloadBuilder: () => __tnMaybeCallBuilder(ValidateArgs)
+    createPayloadBuilder: () => null
   },
   {
     name: "transfer",
@@ -6642,24 +6447,17 @@ _PasskeyInstruction.payloadVariantDescriptors = Object.freeze([
     payloadType: "PasskeyInstruction::payload::transfer",
     createPayloadBuilder: () => __tnMaybeCallBuilder(TransferArgs)
   },
-  {
-    name: "invoke",
-    tag: 3,
-    payloadSize: null,
-    payloadType: "PasskeyInstruction::payload::invoke",
-    createPayloadBuilder: () => __tnMaybeCallBuilder(InvokeArgs)
-  },
   {
     name: "add_authority",
     tag: 4,
-    payloadSize: 65,
+    payloadSize: 67,
     payloadType: "PasskeyInstruction::payload::add_authority",
     createPayloadBuilder: () => __tnMaybeCallBuilder(AddAuthorityArgs)
   },
   {
     name: "remove_authority",
     tag: 5,
-    payloadSize: 1,
+    payloadSize: 3,
     payloadType: "PasskeyInstruction::payload::remove_authority",
     createPayloadBuilder: () => __tnMaybeCallBuilder(RemoveAuthorityArgs)
   },
@@ -6699,8 +6497,6 @@ var PasskeyInstruction = _PasskeyInstruction;
   }
   PasskeyInstruction2.params = params;
 })(PasskeyInstruction || (PasskeyInstruction = {}));
-__tnRegisterFootprint3("PasskeyInstruction", (params) => PasskeyInstruction.__tnInvokeFootprint(params));
-__tnRegisterValidate3("PasskeyInstruction", (buffer, params) => PasskeyInstruction.__tnInvokeValidate(buffer, params));
 var PasskeyInstructionBuilder = class {
   constructor() {
     this.__tnField_tag = null;
@@ -6805,6 +6601,12 @@ var PasskeyInstructionBuilder = class {
     this.__tnLastBuffer = buffer;
   }
 };
+__tnRegisterFootprint3("PasskeyInstruction", (params) => PasskeyInstruction.__tnInvokeFootprint(params));
+__tnRegisterValidate3("PasskeyInstruction", (buffer, params) => PasskeyInstruction.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("PasskeyInstruction", (buffer) => {
+  const result = PasskeyInstruction.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+});
 
 // src/passkey-manager/instructions/create.ts
 function buildAuthority(authority) {
@@ -6833,16 +6635,81 @@ function encodeCreateInstruction(params) {
   return new PasskeyInstructionBuilder().payload().select("create").writePayload(argsPayload).finish().build();
 }
 
+// src/passkey-manager/target-instruction.ts
+function buildTargetInstructionBytes({
+  programIdx,
+  instructionData
+}) {
+  if (!Number.isInteger(programIdx) || programIdx < 0 || programIdx > 65535) {
+    throw new Error("programIdx must be 0-65535");
+  }
+  if (!(instructionData instanceof Uint8Array)) {
+    throw new Error("instructionData must be a Uint8Array");
+  }
+  const builder = new InstructionDataBuilder();
+  builder.set_program_idx(programIdx);
+  builder.data().write(instructionData).finish();
+  const buffer = builder.build();
+  const view = InstructionData.from_array(buffer);
+  if (!view) {
+    throw new Error("generated InstructionData failed validation");
+  }
+  return buffer;
+}
+
 // src/passkey-manager/instructions/validate.ts
+var U8_SIZE = Uint8Array.BYTES_PER_ELEMENT;
+var U16_SIZE = Uint16Array.BYTES_PER_ELEMENT;
+var P256_COORDINATE_SIZE = 32;
+var VALIDATE_FIXED_PREFIX_SIZE = U16_SIZE + U8_SIZE + P256_COORDINATE_SIZE + P256_COORDINATE_SIZE + U16_SIZE + U16_SIZE;
+function writeU16LE(target, offset, value) {
+  target[offset] = value & 255;
+  target[offset + 1] = value >> 8 & 255;
+}
 function encodeValidateInstruction(params) {
-  const { walletAccountIdx, authIdx, signatureR, signatureS, authenticatorData, clientDataJSON } = params;
+  const {
+    walletAccountIdx,
+    authIdx,
+    targetInstruction,
+    signatureR,
+    signatureS,
+    authenticatorData,
+    clientDataJSON
+  } = params;
   if (walletAccountIdx < 0 || walletAccountIdx > 65535) {
     throw new Error("walletAccountIdx must be 0-65535");
   }
   if (authIdx < 0 || authIdx > 255) throw new Error("authIdx must be 0-255");
   if (signatureR.length !== 32) throw new Error("signatureR must be 32 bytes");
   if (signatureS.length !== 32) throw new Error("signatureS must be 32 bytes");
-  const argsPayload = new ValidateArgsBuilder().set_wallet_account_idx(walletAccountIdx).set_auth_idx(authIdx).set_signature_r(signatureR).set_signature_s(signatureS).authenticator_data().write(authenticatorData).finish().client_data().write(clientDataJSON).finish().build();
+  if (authenticatorData.length > 65535) {
+    throw new Error("authenticatorData length must be 0-65535");
+  }
+  if (clientDataJSON.length > 65535) {
+    throw new Error("clientDataJSON length must be 0-65535");
+  }
+  const targetInstructionBytes = buildTargetInstructionBytes(targetInstruction);
+  const argsPayload = new Uint8Array(
+    VALIDATE_FIXED_PREFIX_SIZE + authenticatorData.length + clientDataJSON.length + targetInstructionBytes.length
+  );
+  let offset = 0;
+  writeU16LE(argsPayload, offset, walletAccountIdx);
+  offset += 2;
+  argsPayload[offset] = authIdx;
+  offset += 1;
+  argsPayload.set(signatureR, offset);
+  offset += signatureR.length;
+  argsPayload.set(signatureS, offset);
+  offset += signatureS.length;
+  writeU16LE(argsPayload, offset, authenticatorData.length);
+  offset += 2;
+  writeU16LE(argsPayload, offset, clientDataJSON.length);
+  offset += 2;
+  argsPayload.set(authenticatorData, offset);
+  offset += authenticatorData.length;
+  argsPayload.set(clientDataJSON, offset);
+  offset += clientDataJSON.length;
+  argsPayload.set(targetInstructionBytes, offset);
   return new PasskeyInstructionBuilder().payload().select("validate").writePayload(argsPayload).finish().build();
 }
 
@@ -6860,27 +6727,25 @@ function encodeTransferInstruction(params) {
   return new PasskeyInstructionBuilder().payload().select("transfer").writePayload(argsPayload).finish().build();
 }
 
-// src/passkey-manager/instructions/invoke.ts
-function encodeInvokeInstruction(programPubkey, instruction) {
-  if (programPubkey.length !== 32) {
-    throw new Error("Program pubkey must be 32 bytes");
-  }
-  const argsPayload = new InvokeArgsBuilder().set_program_pubkey(programPubkey).instr().write(instruction).finish().build();
-  return new PasskeyInstructionBuilder().payload().select("invoke").writePayload(argsPayload).finish().build();
-}
-
 // src/passkey-manager/instructions/add-authority.ts
 function encodeAddAuthorityInstruction(params) {
+  const { walletAccountIdx } = params;
+  if (walletAccountIdx < 0 || walletAccountIdx > 65535) {
+    throw new Error("walletAccountIdx must be 0-65535");
+  }
   const authorityBytes = buildAuthority(params.authority);
-  const argsPayload = new AddAuthorityArgsBuilder().set_authority(authorityBytes).build();
+  const argsPayload = new AddAuthorityArgsBuilder().set_wallet_account_idx(walletAccountIdx).set_authority(authorityBytes).build();
   return new PasskeyInstructionBuilder().payload().select("add_authority").writePayload(argsPayload).finish().build();
 }
 
 // src/passkey-manager/instructions/remove-authority.ts
 function encodeRemoveAuthorityInstruction(params) {
-  const { authIdx } = params;
+  const { walletAccountIdx, authIdx } = params;
+  if (walletAccountIdx < 0 || walletAccountIdx > 65535) {
+    throw new Error("walletAccountIdx must be 0-65535");
+  }
   if (authIdx < 0 || authIdx > 255) throw new Error("authIdx must be 0-255");
-  const argsPayload = new RemoveAuthorityArgsBuilder().set_auth_idx(authIdx).build();
+  const argsPayload = new RemoveAuthorityArgsBuilder().set_wallet_account_idx(walletAccountIdx).set_auth_idx(authIdx).build();
   return new PasskeyInstructionBuilder().payload().select("remove_authority").writePayload(argsPayload).finish().build();
 }
 
@@ -6898,38 +6763,51 @@ function encodeRegisterCredentialInstruction(params) {
   return new PasskeyInstructionBuilder().payload().select("register_credential").writePayload(argsPayload).finish().build();
 }
 
-// src/passkey-manager/instructions/shared.ts
-function concatenateInstructions(instructions) {
-  const totalLength = instructions.reduce((sum, instr) => sum + instr.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const instr of instructions) {
-    result.set(instr, offset);
-    offset += instr.length;
+// src/passkey-manager/challenge.ts
+var VALIDATE_CHALLENGE_DOMAIN = "thru.passkey.validate";
+function writeU64LE(target, offset, value) {
+  let remaining = value;
+  for (let i = 0; i < 8; i++) {
+    target[offset + i] = Number(remaining & 0xffn);
+    remaining >>= 8n;
   }
-  return result;
 }
-
-// src/passkey-manager/challenge.ts
-async function createValidateChallenge(nonce, accountAddresses, trailingInstructionData) {
+async function createValidateChallenge(nonce, accountAddresses, walletAccountIdx, authIdx, targetInstruction) {
+  const targetInstructionBytes = buildTargetInstructionBytes(targetInstruction);
   const encoder = new TextEncoder();
+  const domainBytes = encoder.encode(VALIDATE_CHALLENGE_DOMAIN);
   const accountBytes = accountAddresses.map((address) => {
-    return encoder.encode(address);
+    const bytes = encoder.encode(address);
+    if (bytes.length !== 46) {
+      throw new Error("accountAddresses must contain ta addresses");
+    }
+    return bytes;
   });
-  const totalSize = accountBytes.reduce((sum, bytes) => sum + bytes.length, 8) + trailingInstructionData.length;
+  if (walletAccountIdx < 0 || walletAccountIdx > 65535) {
+    throw new Error("walletAccountIdx must be 0-65535");
+  }
+  if (authIdx < 0 || authIdx > 255) throw new Error("authIdx must be 0-255");
+  if (accountBytes.length > 65535) throw new Error("accountAddresses length must be 0-65535");
+  const totalSize = domainBytes.length + 8 + 2 + 1 + 2 + accountBytes.reduce((sum, bytes) => sum + bytes.length, 0) + targetInstructionBytes.length;
   const challengeData = new Uint8Array(totalSize);
   let offset = 0;
-  let v = nonce;
-  for (let i = 0; i < 8; i++) {
-    challengeData[offset + i] = Number(v & 0xffn);
-    v >>= 8n;
-  }
+  challengeData.set(domainBytes, offset);
+  offset += domainBytes.length;
+  writeU64LE(challengeData, offset, nonce);
   offset += 8;
+  challengeData[offset] = walletAccountIdx & 255;
+  challengeData[offset + 1] = walletAccountIdx >> 8 & 255;
+  offset += 2;
+  challengeData[offset] = authIdx & 255;
+  offset += 1;
+  challengeData[offset] = accountBytes.length & 255;
+  challengeData[offset + 1] = accountBytes.length >> 8 & 255;
+  offset += 2;
   for (const bytes of accountBytes) {
     challengeData.set(bytes, offset);
     offset += bytes.length;
   }
-  challengeData.set(trailingInstructionData, offset);
+  challengeData.set(targetInstructionBytes, offset);
   const hashBuffer = await crypto.subtle.digest("SHA-256", challengeData);
   return new Uint8Array(hashBuffer);
 }
@@ -7298,6 +7176,6 @@ function bigIntToBytesBE(value, length) {
   return out;
 }
 
-export { AUTHORITY_TAG_PASSKEY, AUTHORITY_TAG_PUBKEY, FEE_PAYER_ADDRESS, INSTRUCTION_ADD_AUTHORITY, INSTRUCTION_CREATE, INSTRUCTION_INVOKE, INSTRUCTION_REGISTER_CREDENTIAL, INSTRUCTION_REMOVE_AUTHORITY, INSTRUCTION_TRANSFER, INSTRUCTION_VALIDATE, P256_HALF_N, P256_N, PASSKEY_MANAGER_PROGRAM_ADDRESS, arrayBufferToBase64Url, base64UrlToArrayBuffer, base64UrlToBytes, bigIntToBytesBE, buildAccountContext, buildPasskeyReadWriteAccounts, bytesEqual, bytesToBase64, bytesToBase64Url, bytesToBigIntBE, bytesToHex, compareBytes, concatenateInstructions, createCredentialLookupSeed, createValidateChallenge, createWalletSeed, deriveCredentialLookupAddress, deriveWalletAddress, encodeAddAuthorityInstruction, encodeCreateInstruction, encodeInvokeInstruction, encodeRegisterCredentialInstruction, encodeRemoveAuthorityInstruction, encodeTransferInstruction, encodeValidateInstruction, fetchWalletNonce, findPasskeyAuthorityIndexForIdentity, findPasskeyAuthorityIndexInWalletData, formatAuthorityPubkey, hexToBytes, isPasskeyAuthorityCheckable, normalizeLowS, normalizeSignatureComponent, parseCredentialLookupWallet, parseDerSignature, parseWalletAuthorities, parseWalletNonce, preparePasskeyAuthorityTargets, resolvePasskeyAuthorityIndex, uniqueAccounts };
+export { AUTHORITY_TAG_PASSKEY, AUTHORITY_TAG_PUBKEY, FEE_PAYER_ADDRESS, INSTRUCTION_ADD_AUTHORITY, INSTRUCTION_CREATE, INSTRUCTION_REGISTER_CREDENTIAL, INSTRUCTION_REMOVE_AUTHORITY, INSTRUCTION_TRANSFER, INSTRUCTION_VALIDATE, P256_HALF_N, P256_N, PASSKEY_MANAGER_PROGRAM_ADDRESS, VALIDATE_CHALLENGE_DOMAIN, arrayBufferToBase64Url, base64UrlToArrayBuffer, base64UrlToBytes, bigIntToBytesBE, buildAccountContext, buildPasskeyReadWriteAccounts, bytesEqual, bytesToBase64, bytesToBase64Url, bytesToBigIntBE, bytesToHex, compareBytes, createCredentialLookupSeed, createValidateChallenge, createWalletSeed, deriveCredentialLookupAddress, deriveWalletAddress, encodeAddAuthorityInstruction, encodeCreateInstruction, encodeRegisterCredentialInstruction, encodeRemoveAuthorityInstruction, encodeTransferInstruction, encodeValidateInstruction, fetchWalletNonce, findPasskeyAuthorityIndexForIdentity, findPasskeyAuthorityIndexInWalletData, formatAuthorityPubkey, hexToBytes, isPasskeyAuthorityCheckable, normalizeLowS, normalizeSignatureComponent, parseCredentialLookupWallet, parseDerSignature, parseWalletAuthorities, parseWalletNonce, preparePasskeyAuthorityTargets, resolvePasskeyAuthorityIndex, uniqueAccounts };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map