@thru/programs 0.2.27 → 0.2.28

package/dist/passkey-manager/index.cjs

@@ -2,17 +2,6 @@
 
 var helpers = require('@thru/sdk/helpers');
 
-// src/passkey-manager/constants.ts
-var PASSKEY_MANAGER_PROGRAM_ADDRESS = "taUDdQyFxvM5i0HFRkEK3W45kWLyblAHSnMg4zplgUnz6Z";
-var INSTRUCTION_CREATE = 0;
-var INSTRUCTION_VALIDATE = 1;
-var INSTRUCTION_TRANSFER = 2;
-var INSTRUCTION_ADD_AUTHORITY = 4;
-var INSTRUCTION_REMOVE_AUTHORITY = 5;
-var INSTRUCTION_REGISTER_CREDENTIAL = 6;
-var AUTHORITY_TAG_PASSKEY = 1;
-var AUTHORITY_TAG_PUBKEY = 2;
-
 // src/passkey-manager/abi/thru/common/primitives/types.ts
 var __tnWarnings = /* @__PURE__ */ new Set();
 var __tnHasNativeBigInt = typeof BigInt === "function";
@@ -632,7 +621,8 @@ __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed), params };
 });
 var __tn_ir_Duration = {
   typeName: "Duration",
@@ -760,7 +750,8 @@ __tnRegisterFootprint("Duration", (params) => Duration.__tnInvokeFootprint(param
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed), params };
 });
 var __tn_ir_FixedPoint = {
   typeName: "FixedPoint",
@@ -888,7 +879,8 @@ __tnRegisterFootprint("FixedPoint", (params) => FixedPoint.__tnInvokeFootprint(p
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed), params };
 });
 var __tn_ir_Hash = {
   typeName: "Hash",
@@ -1003,7 +995,8 @@ __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed), params };
 });
 var __tn_ir_InstructionData = {
   typeName: "InstructionData",
@@ -1275,7 +1268,7 @@ var InstructionDataBuilder = class {
         const elementCount = bytes.length;
         this.__tnFam_data = bytes;
         this.__tnFam_dataCount = elementCount;
-        this.set_data_size(elementCount);
+        this.set_data_size(__tnToBigInt(elementCount));
         this.__tnInvalidate();
       });
     }
@@ -1343,7 +1336,8 @@ __tnRegisterFootprint("InstructionData", (params) => InstructionData.__tnInvokeF
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed), params };
 });
 var __tn_ir_Pubkey = {
   typeName: "Pubkey",
@@ -1458,7 +1452,8 @@ __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed), params };
 });
 var __tn_ir_Signature = {
   typeName: "Signature",
@@ -1573,7 +1568,8 @@ __tnRegisterFootprint("Signature", (params) => Signature.__tnInvokeFootprint(par
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed), params };
 });
 var __tn_ir_Timestamp = {
   typeName: "Timestamp",
@@ -1682,7 +1678,8 @@ __tnRegisterFootprint("Timestamp", (params) => Timestamp.__tnInvokeFootprint(par
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed), params };
 });
 
 // src/passkey-manager/abi/thru/blockchain/state_proof/types.ts
@@ -2175,13 +2172,15 @@ __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt2(result.consumed), params };
 });
 __tnRegisterFootprint2("Pubkey", (params) => Pubkey.__tnInvokeFootprint(params));
 __tnRegisterValidate2("Pubkey", (buffer, params) => Pubkey.__tnInvokeValidate(buffer, params));
 __tnRegisterDynamicValidate2("Pubkey", (buffer) => {
   const result = Pubkey.validate(buffer);
-  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt2(result.consumed) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt2(result.consumed), params };
 });
 var __tn_ir_StateProofHeader = {
   typeName: "StateProofHeader",
@@ -2305,7 +2304,8 @@ __tnRegisterFootprint2("StateProofHeader", (params) => StateProofHeader.__tnInvo
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt2(result.consumed), params };
 });
 var __tn_ir_StateProof = {
   typeName: "StateProof",
@@ -2988,7 +2988,8 @@ __tnRegisterFootprint2("StateProof", (params) => StateProof.__tnInvokeFootprint(
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt2(result.consumed), params };
 });
 
 // src/passkey-manager/abi/thru/program/passkey_manager/types.ts
@@ -3076,6 +3077,33 @@ 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) {
@@ -3499,19 +3527,22 @@ __tnRegisterFootprint3("InstructionData", (params) => InstructionData.__tnInvoke
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 __tnRegisterFootprint3("StateProof", (params) => StateProof.__tnInvokeFootprint(params));
 __tnRegisterValidate3("StateProof", (buffer, params) => StateProof.__tnInvokeValidate(buffer, params));
 __tnRegisterDynamicValidate3("StateProof", (buffer) => {
   const result = StateProof.validate(buffer);
-  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 var __tn_ir_Authority = {
   typeName: "Authority",
@@ -3644,6 +3675,131 @@ __tnRegisterFootprint3("Authority", (params) => Authority.__tnInvokeFootprint(pa
 __tnRegisterValidate3("Authority", (buffer, params) => Authority.__tnInvokeValidate(buffer, params));
 __tnRegisterDynamicValidate3("Authority", (buffer) => {
   const result = Authority.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
+var __tn_ir_AuthorityRecord = {
+  typeName: "AuthorityRecord",
+  root: { op: "const", value: 73n }
+};
+var AuthorityRecord = class _AuthorityRecord {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  static __tnCreateView(buffer, opts) {
+    if (!buffer || buffer.length === void 0) throw new Error("AuthorityRecord.__tnCreateView requires a Uint8Array");
+    return new _AuthorityRecord(new Uint8Array(buffer));
+  }
+  static builder() {
+    return new AuthorityRecordBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    return _AuthorityRecord.from_array(buffer);
+  }
+  get_authority() {
+    const offset = 0;
+    const slice = this.buffer.subarray(offset, offset + 65);
+    return Authority.from_array(slice);
+  }
+  set_authority(value) {
+    const sourceBytes = value.buffer;
+    const offset = 0;
+    this.buffer.set(sourceBytes, offset);
+  }
+  get authority() {
+    return this.get_authority();
+  }
+  set authority(value) {
+    this.set_authority(value);
+  }
+  get_expires_at_block_time_seconds() {
+    const offset = 65;
+    return this.view.getBigUint64(offset, true);
+  }
+  set_expires_at_block_time_seconds(value) {
+    const offset = 65;
+    this.view.setBigUint64(offset, value, true);
+  }
+  get expires_at_block_time_seconds() {
+    return this.get_expires_at_block_time_seconds();
+  }
+  set expires_at_block_time_seconds(value) {
+    this.set_expires_at_block_time_seconds(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint3(__tn_ir_AuthorityRecord.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree3(__tn_ir_AuthorityRecord, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr() {
+    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  }
+  static footprint() {
+    const irResult = this.footprintIr();
+    const maxSafe = __tnToBigInt3(Number.MAX_SAFE_INTEGER);
+    if (__tnBigIntGreaterThan3(irResult, maxSafe)) {
+      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for AuthorityRecord");
+    }
+    return __tnBigIntToNumber3(irResult, "AuthorityRecord::footprint");
+  }
+  static validate(buffer, _opts) {
+    if (buffer.length < 73) return { ok: false, code: "tn.buffer_too_small", consumed: 73 };
+    return { ok: true, consumed: 73 };
+  }
+  static from_array(buffer) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const validation = this.validate(buffer);
+    if (!validation.ok) {
+      return null;
+    }
+    return new _AuthorityRecord(buffer);
+  }
+};
+var AuthorityRecordBuilder = class {
+  constructor() {
+    this.buffer = new Uint8Array(73);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  set_authority(value) {
+    if (value.length !== 65) throw new Error("authority expects 65 bytes");
+    this.buffer.set(value, 0);
+    return this;
+  }
+  set_expires_at_block_time_seconds(value) {
+    const cast = __tnToBigInt3(value);
+    this.view.setBigUint64(65, cast, true);
+    return this;
+  }
+  build() {
+    return this.buffer.slice();
+  }
+  buildInto(target, offset = 0) {
+    if (target.length - offset < this.buffer.length) throw new Error("target buffer too small");
+    target.set(this.buffer, offset);
+    return target;
+  }
+  finish() {
+    const view = AuthorityRecord.from_array(this.buffer.slice());
+    if (!view) throw new Error("failed to build AuthorityRecord");
+    return view;
+  }
+};
+__tnRegisterFootprint3("AuthorityRecord", (params) => AuthorityRecord.__tnInvokeFootprint(params));
+__tnRegisterValidate3("AuthorityRecord", (buffer, params) => AuthorityRecord.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("AuthorityRecord", (buffer) => {
+  const result = AuthorityRecord.validate(buffer);
   return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed) };
 });
 var __tn_ir_P256Point = {
@@ -3729,7 +3885,8 @@ __tnRegisterFootprint3("P256Point", (params) => P256Point.__tnInvokeFootprint(pa
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 var __tn_ir_RemoveAuthorityArgs = {
   typeName: "RemoveAuthorityArgs",
@@ -3856,7 +4013,8 @@ __tnRegisterFootprint3("RemoveAuthorityArgs", (params) => RemoveAuthorityArgs.__
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 var __tn_ir_Seed32 = {
   typeName: "Seed32",
@@ -3941,7 +4099,8 @@ __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 var __tn_ir_TransferArgs = {
   typeName: "TransferArgs",
@@ -4088,7 +4247,8 @@ __tnRegisterFootprint3("TransferArgs", (params) => TransferArgs.__tnInvokeFootpr
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 var __tn_ir_ValidateArgs = {
   typeName: "ValidateArgs",
@@ -4144,9 +4304,18 @@ 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;
+    let __tnParamSeq_data_data_size = null;
     let __tnFieldValue_authenticator_data_len = null;
     let __tnFieldValue_client_data_len = null;
     let __tnCursorMutable = 0;
@@ -4181,7 +4350,17 @@ var _ValidateArgs = class _ValidateArgs {
     offsets["client_data"] = __tnCursorMutable;
     if (__tnCursorMutable + __tnArrayBytes_client_data > __tnLength) return null;
     __tnCursorMutable += __tnArrayBytes_client_data;
-    return null;
+    offsets["target_instruction"] = __tnCursorMutable;
+    const __tnTyperefResult_target_instruction = __tnInvokeDynamicValidate3("InstructionData", buffer.subarray(__tnCursorMutable));
+    if (!__tnTyperefResult_target_instruction.ok || __tnTyperefResult_target_instruction.consumed === void 0) return null;
+    const __tnTyperefParams_target_instruction = __tnTyperefResult_target_instruction.params ?? null;
+    if (!__tnTyperefParams_target_instruction || __tnTyperefParams_target_instruction["data_data_size"] === void 0) return null;
+    __tnParamSeq_data_data_size = __tnTyperefParams_target_instruction["data_data_size"];
+    __tnCursorMutable += __tnBigIntToNumber3(__tnTyperefResult_target_instruction.consumed, "ValidateArgs::target_instruction");
+    const params = /* @__PURE__ */ Object.create(null);
+    if (__tnParamSeq_data_data_size === null) return null;
+    params["data_data_size"] = __tnParamSeq_data_data_size;
+    return { params, offsets, derived: null };
   }
   static __tnExtractParams(view, buffer) {
     if (buffer.length < 69) {
@@ -4192,9 +4371,15 @@ var _ValidateArgs = class _ValidateArgs {
       return null;
     }
     const __tnParam_client_data_client_data_len = __tnToBigInt3(view.getUint16(69, true));
+    const __tnLayout = _ValidateArgs.__tnComputeSequentialLayout(view, buffer);
+    if (!__tnLayout || !__tnLayout.params) return null;
+    const __tnSeqParams = __tnLayout.params;
+    const __tnParamSeq_data_data_size = __tnSeqParams["data_data_size"];
+    if (__tnParamSeq_data_data_size === void 0) return null;
     const __tnExtractedParams = _ValidateArgs.Params.fromValues({
       authenticator_data_authenticator_data_len: __tnParam_authenticator_data_authenticator_data_len,
-      client_data_client_data_len: __tnParam_client_data_client_data_len
+      client_data_client_data_len: __tnParam_client_data_client_data_len,
+      data_data_size: __tnParamSeq_data_data_size
     });
     return { params: __tnExtractedParams, derived: null };
   }
@@ -4400,10 +4585,11 @@ var _ValidateArgs = class _ValidateArgs {
   static __tnInvokeValidate(buffer, __tnParams) {
     return this.__tnValidateInternal(buffer, __tnParams);
   }
-  static footprintIr(authenticator_data_authenticator_data_len, client_data_client_data_len) {
+  static footprintIr(authenticator_data_authenticator_data_len, client_data_client_data_len, data_data_size) {
     const params = _ValidateArgs.Params.fromValues({
       authenticator_data_authenticator_data_len,
-      client_data_client_data_len
+      client_data_client_data_len,
+      data_data_size
     });
     return this.footprintIrFromParams(params);
   }
@@ -4411,6 +4597,7 @@ var _ValidateArgs = class _ValidateArgs {
     const record = /* @__PURE__ */ Object.create(null);
     record["authenticator_data.authenticator_data_len"] = params.authenticator_data_authenticator_data_len;
     record["client_data.client_data_len"] = params.client_data_client_data_len;
+    record["data.data_size"] = params.data_data_size;
     return record;
   }
   static footprintIrFromParams(params) {
@@ -4477,13 +4664,15 @@ var ValidateArgs = _ValidateArgs;
 ((ValidateArgs2) => {
   ValidateArgs2.ParamKeys = Object.freeze({
     authenticator_data_authenticator_data_len: "authenticator_data.authenticator_data_len",
-    client_data_client_data_len: "client_data.client_data_len"
+    client_data_client_data_len: "client_data.client_data_len",
+    data_data_size: "data.data_size"
   });
   ValidateArgs2.Params = {
     fromValues(input) {
       return {
         authenticator_data_authenticator_data_len: __tnToBigInt3(input.authenticator_data_authenticator_data_len),
-        client_data_client_data_len: __tnToBigInt3(input.client_data_client_data_len)
+        client_data_client_data_len: __tnToBigInt3(input.client_data_client_data_len),
+        data_data_size: __tnToBigInt3(input.data_data_size)
       };
     },
     fromBuilder(source) {
@@ -4501,139 +4690,408 @@ var ValidateArgs = _ValidateArgs;
   }
   ValidateArgs2.params = params;
 })(ValidateArgs || (ValidateArgs = {}));
-__tnRegisterFootprint3("ValidateArgs", (params) => ValidateArgs.__tnInvokeFootprint(params));
-__tnRegisterValidate3("ValidateArgs", (buffer, params) => ValidateArgs.__tnInvokeValidate(buffer, params));
-__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 }
-};
-var WalletAccount = class _WalletAccount {
-  constructor(buffer) {
-    this.buffer = buffer;
-    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+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.__tnTail_target_instruction = null;
+    this.__tnTailParams_target_instruction = null;
+    this.buffer = new Uint8Array(71);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
   }
-  static __tnCreateView(buffer, opts) {
-    if (!buffer || buffer.length === void 0) throw new Error("WalletAccount.__tnCreateView requires a Uint8Array");
-    return new _WalletAccount(new Uint8Array(buffer));
+  __tnInvalidate() {
+    this.__tnCachedParams = null;
+    this.__tnLastBuffer = null;
+    this.__tnLastParams = null;
   }
-  static builder() {
-    return new WalletAccountBuilder();
+  set_wallet_account_idx(value) {
+    this.view.setUint16(0, value, true);
+    this.__tnInvalidate();
+    return this;
   }
-  static fromBuilder(builder) {
-    const buffer = builder.build();
-    return _WalletAccount.from_array(buffer);
+  set_auth_idx(value) {
+    this.view.setUint8(2, value);
+    this.__tnInvalidate();
+    return this;
   }
-  get_num_auth() {
-    const offset = 0;
-    return this.view.getUint8(offset);
+  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_num_auth(value) {
-    const offset = 0;
-    this.view.setUint8(offset, value);
+  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;
   }
-  get num_auth() {
-    return this.get_num_auth();
+  set_authenticator_data_len(value) {
+    this.view.setUint16(67, value, true);
+    this.__tnInvalidate();
+    return this;
   }
-  set num_auth(value) {
-    this.set_num_auth(value);
+  set_client_data_len(value) {
+    this.view.setUint16(69, value, true);
+    this.__tnInvalidate();
+    return this;
   }
-  get_nonce() {
-    const offset = 1;
-    return this.view.getBigUint64(offset, true);
+  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;
   }
-  set_nonce(value) {
-    const offset = 1;
-    this.view.setBigUint64(offset, value, true);
+  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;
   }
-  get nonce() {
-    return this.get_nonce();
+  set_target_instruction(value) {
+    const bytes = __tnResolveStructFieldInput(value, "ValidateArgsBuilder::target_instruction");
+    const validation = __tnInvokeDynamicValidate3("InstructionData", bytes);
+    if (!validation.ok || validation.consumed === void 0) throw new Error("ValidateArgsBuilder: field 'target_instruction' failed validation");
+    if (__tnBigIntToNumber3(validation.consumed, "ValidateArgsBuilder::target_instruction") !== bytes.length) throw new Error("ValidateArgsBuilder: field 'target_instruction' validation did not consume the full buffer");
+    this.__tnTail_target_instruction = bytes;
+    this.__tnTailParams_target_instruction = validation.params ?? null;
+    this.__tnInvalidate();
+    return this;
   }
-  set nonce(value) {
-    this.set_nonce(value);
+  build() {
+    const params = this.__tnComputeParams();
+    const size = ValidateArgs.footprintFromParams(params);
+    const buffer = new Uint8Array(size);
+    this.__tnWriteInto(buffer);
+    this.__tnValidateOrThrow(buffer, params);
+    return buffer;
   }
-  static __tnFootprintInternal(__tnParams) {
-    return __tnEvalFootprint3(__tn_ir_WalletAccount.root, { params: __tnParams });
+  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;
   }
-  static __tnValidateInternal(buffer, __tnParams) {
-    return __tnValidateIrTree3(__tn_ir_WalletAccount, buffer, __tnParams);
+  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;
   }
-  static __tnInvokeFootprint(__tnParams) {
-    return this.__tnFootprintInternal(__tnParams);
+  finishView() {
+    return this.finish();
   }
-  static __tnInvokeValidate(buffer, __tnParams) {
-    return this.__tnValidateInternal(buffer, __tnParams);
+  dynamicParams() {
+    return this.__tnComputeParams();
   }
-  static footprintIr() {
-    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  __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);
+      })(),
+      data_data_size: (() => {
+        const params2 = this.__tnTailParams_target_instruction;
+        if (!params2 || params2["data_data_size"] === void 0) throw new Error("ValidateArgsBuilder: field 'target_instruction' must be written before computing params");
+        return params2["data_data_size"];
+      })()
+    });
+    this.__tnCachedParams = params;
+    return params;
   }
-  static footprint() {
-    const irResult = this.footprintIr();
-    const maxSafe = __tnToBigInt3(Number.MAX_SAFE_INTEGER);
-    if (__tnBigIntGreaterThan3(irResult, maxSafe)) {
-      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for WalletAccount");
+  __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;
+    const __tnLocal_target_instruction_bytes = this.__tnTail_target_instruction;
+    if (!__tnLocal_target_instruction_bytes) throw new Error("ValidateArgsBuilder: field 'target_instruction' must be written before build");
+    target.set(__tnLocal_target_instruction_bytes, cursor);
+    cursor += __tnLocal_target_instruction_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"})`);
     }
-    return __tnBigIntToNumber3(irResult, "WalletAccount::footprint");
+    this.__tnLastParams = result.params ?? params;
+    this.__tnLastBuffer = buffer;
   }
-  static validate(buffer, _opts) {
-    if (buffer.length < 9) return { ok: false, code: "tn.buffer_too_small", consumed: 9 };
-    return { ok: true, consumed: 9 };
+};
+__tnRegisterFootprint3("ValidateArgs", (params) => ValidateArgs.__tnInvokeFootprint(params));
+__tnRegisterValidate3("ValidateArgs", (buffer, params) => ValidateArgs.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate3("ValidateArgs", (buffer) => {
+  const result = ValidateArgs.validate(buffer);
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
+});
+var __tn_ir_WalletAccount = {
+  typeName: "WalletAccount",
+  root: { op: "align", alignment: 1, node: { op: "add", left: { op: "add", left: { op: "align", alignment: 1, node: { op: "const", value: 1n } }, right: { op: "align", alignment: 8, node: { op: "const", value: 8n } } }, right: { op: "align", alignment: 1, node: { op: "mul", left: { op: "add", left: { op: "field", param: "authorities.num_auth" }, right: { op: "const", value: 1n } }, right: { op: "const", value: 73n } } } } }
+};
+var WalletAccount = class _WalletAccount {
+  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 = _WalletAccount.__tnExtractParams(this.view, buffer);
+      if (!derived) {
+        throw new Error("WalletAccount: failed to derive dynamic parameters");
+      }
+      this.__tnParams = derived.params;
+    }
   }
-  static new(num_auth, nonce) {
-    const buffer = new Uint8Array(9);
-    const view = new DataView(buffer.buffer);
-    view.setUint8(0, num_auth);
-    view.setBigUint64(1, nonce, true);
-    return new _WalletAccount(buffer);
+  static __tnCreateView(buffer, opts) {
+    if (!buffer || buffer.length === void 0) throw new Error("WalletAccount.__tnCreateView requires a Uint8Array");
+    let params = opts?.params ?? null;
+    if (!params) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      const derived = _WalletAccount.__tnExtractParams(view, buffer);
+      if (!derived) throw new Error("WalletAccount.__tnCreateView: failed to derive params");
+      params = derived.params;
+    }
+    const instance = new _WalletAccount(new Uint8Array(buffer), params, opts?.fieldContext);
+    return instance;
   }
-  static from_array(buffer) {
-    if (!buffer || buffer.length === void 0) {
-      return null;
+  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, "WalletAccount::__tnResolveFieldRef") : value;
     }
-    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    const validation = this.validate(buffer);
-    if (!validation.ok) {
+    if (this.__tnFieldContext && Object.prototype.hasOwnProperty.call(this.__tnFieldContext, path)) {
+      const contextValue = this.__tnFieldContext[path];
+      return typeof contextValue === "bigint" ? __tnBigIntToNumber3(contextValue, "WalletAccount::__tnResolveFieldRef") : contextValue;
+    }
+    throw new Error("WalletAccount: field reference '" + path + "' is not available; provide fieldContext when creating this view");
+  }
+  static __tnExtractParams(view, buffer) {
+    if (buffer.length < 1) {
       return null;
     }
-    return new _WalletAccount(buffer);
+    const __tnParam_authorities_num_auth = __tnToBigInt3(view.getUint8(0));
+    const __tnExtractedParams = _WalletAccount.Params.fromValues({
+      authorities_num_auth: __tnParam_authorities_num_auth
+    });
+    return { params: __tnExtractedParams, derived: null };
   }
-};
-var WalletAccountBuilder = class {
-  constructor() {
-    this.buffer = new Uint8Array(9);
-    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  get_num_auth() {
+    const offset = 0;
+    return this.view.getUint8(offset);
   }
   set_num_auth(value) {
-    this.view.setUint8(0, value);
-    return this;
+    const offset = 0;
+    this.view.setUint8(offset, value);
+  }
+  get num_auth() {
+    return this.get_num_auth();
+  }
+  set num_auth(value) {
+    this.set_num_auth(value);
+  }
+  get_nonce() {
+    const offset = 1;
+    return this.view.getBigUint64(offset, true);
   }
   set_nonce(value) {
-    const cast = __tnToBigInt3(value);
-    this.view.setBigUint64(1, cast, true);
-    return this;
+    const offset = 1;
+    this.view.setBigUint64(offset, value, true);
   }
-  build() {
-    return this.buffer.slice();
+  get nonce() {
+    return this.get_nonce();
   }
-  buildInto(target, offset = 0) {
-    if (target.length - offset < this.buffer.length) throw new Error("target buffer too small");
-    target.set(this.buffer, offset);
-    return target;
+  set nonce(value) {
+    this.set_nonce(value);
   }
-  finish() {
-    const view = WalletAccount.from_array(this.buffer.slice());
-    if (!view) throw new Error("failed to build WalletAccount");
-    return view;
+  get_authorities_length() {
+    return this.__tnResolveFieldRef("num_auth") + 1;
+  }
+  get_authorities_at(index) {
+    const offset = 9;
+    const slice = this.buffer.subarray(offset + index * 73, offset + (index + 1) * 73);
+    return AuthorityRecord.from_array(slice);
+  }
+  get_authorities() {
+    const len = this.get_authorities_length();
+    const result = [];
+    for (let i = 0; i < len; i++) {
+      result.push(this.get_authorities_at(i));
+    }
+    return result;
+  }
+  set_authorities_at(index, value) {
+    const offset = 9;
+    const slice = this.buffer.subarray(offset + index * 73, offset + (index + 1) * 73);
+    slice.set(value["buffer"]);
+  }
+  set_authorities(value) {
+    const len = Math.min(this.get_authorities_length(), value.length);
+    for (let i = 0; i < len; i++) {
+      this.set_authorities_at(i, value[i]);
+    }
+  }
+  get authorities() {
+    return this.get_authorities();
+  }
+  set authorities(value) {
+    this.set_authorities(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint3(__tn_ir_WalletAccount.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree3(__tn_ir_WalletAccount, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr(authorities_num_auth) {
+    const params = _WalletAccount.Params.fromValues({
+      authorities_num_auth
+    });
+    return this.footprintIrFromParams(params);
+  }
+  static __tnPackParams(params) {
+    const record = /* @__PURE__ */ Object.create(null);
+    record["authorities.num_auth"] = params.authorities_num_auth;
+    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 WalletAccount");
+    return __tnBigIntToNumber3(irResult, "WalletAccount::footprintFromParams");
+  }
+  static footprintFromValues(input) {
+    const params = _WalletAccount.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, "WalletAccount::validate") : void 0, params };
+    }
+    const consumed = irResult.consumed ? __tnBigIntToNumber3(irResult.consumed, "WalletAccount::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 _WalletAccount(buffer, cached);
+    return state;
   }
 };
+((WalletAccount2) => {
+  WalletAccount2.ParamKeys = Object.freeze({
+    authorities_num_auth: "authorities.num_auth"
+  });
+  WalletAccount2.Params = {
+    fromValues(input) {
+      return {
+        authorities_num_auth: __tnToBigInt3(input.authorities_num_auth)
+      };
+    },
+    fromBuilder(source) {
+      if (source.dynamicParams) {
+        return source.dynamicParams();
+      }
+      if (source.params) {
+        return source.params;
+      }
+      return source;
+    }
+  };
+  function params(input) {
+    return WalletAccount2.Params.fromValues(input);
+  }
+  WalletAccount2.params = params;
+})(WalletAccount || (WalletAccount = {}));
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 var __tn_ir_WalletCreatedEventData = {
   typeName: "WalletCreatedEventData",
@@ -4759,7 +5217,8 @@ __tnRegisterFootprint3("WalletCreatedEventData", (params) => WalletCreatedEventD
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 var __tn_ir_WalletTransferEventData = {
   typeName: "WalletTransferEventData",
@@ -4904,7 +5363,8 @@ __tnRegisterFootprint3("WalletTransferEventData", (params) => WalletTransferEven
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 var __tn_ir_WalletValidatedEventData = {
   typeName: "WalletValidatedEventData",
@@ -5028,11 +5488,12 @@ __tnRegisterFootprint3("WalletValidatedEventData", (params) => WalletValidatedEv
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 var __tn_ir_AddAuthorityArgs = {
   typeName: "AddAuthorityArgs",
-  root: { op: "const", value: 67n }
+  root: { op: "const", value: 75n }
 };
 var AddAuthorityArgs = class _AddAuthorityArgs {
   constructor(buffer) {
@@ -5064,21 +5525,21 @@ var AddAuthorityArgs = class _AddAuthorityArgs {
   set wallet_account_idx(value) {
     this.set_wallet_account_idx(value);
   }
-  get_authority() {
+  get_authority_record() {
     const offset = 2;
-    const slice = this.buffer.subarray(offset, offset + 65);
-    return Authority.from_array(slice);
+    const slice = this.buffer.subarray(offset, offset + 73);
+    return AuthorityRecord.from_array(slice);
   }
-  set_authority(value) {
+  set_authority_record(value) {
     const sourceBytes = value.buffer;
     const offset = 2;
     this.buffer.set(sourceBytes, offset);
   }
-  get authority() {
-    return this.get_authority();
+  get authority_record() {
+    return this.get_authority_record();
   }
-  set authority(value) {
-    this.set_authority(value);
+  set authority_record(value) {
+    this.set_authority_record(value);
   }
   static __tnFootprintInternal(__tnParams) {
     return __tnEvalFootprint3(__tn_ir_AddAuthorityArgs.root, { params: __tnParams });
@@ -5104,8 +5565,8 @@ var AddAuthorityArgs = class _AddAuthorityArgs {
     return __tnBigIntToNumber3(irResult, "AddAuthorityArgs::footprint");
   }
   static validate(buffer, _opts) {
-    if (buffer.length < 67) return { ok: false, code: "tn.buffer_too_small", consumed: 67 };
-    return { ok: true, consumed: 67 };
+    if (buffer.length < 75) return { ok: false, code: "tn.buffer_too_small", consumed: 75 };
+    return { ok: true, consumed: 75 };
   }
   static from_array(buffer) {
     if (!buffer || buffer.length === void 0) {
@@ -5121,15 +5582,15 @@ var AddAuthorityArgs = class _AddAuthorityArgs {
 };
 var AddAuthorityArgsBuilder = class {
   constructor() {
-    this.buffer = new Uint8Array(67);
+    this.buffer = new Uint8Array(75);
     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");
+  set_authority_record(value) {
+    if (value.length !== 73) throw new Error("authority_record expects 73 bytes");
     this.buffer.set(value, 2);
     return this;
   }
@@ -5151,7 +5612,8 @@ __tnRegisterFootprint3("AddAuthorityArgs", (params) => AddAuthorityArgs.__tnInvo
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 var __tn_ir_CredentialLookup = {
   typeName: "CredentialLookup",
@@ -5256,7 +5718,8 @@ __tnRegisterFootprint3("CredentialLookup", (params) => CredentialLookup.__tnInvo
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 var __tn_ir_CredentialRegisteredEventData = {
   typeName: "CredentialRegisteredEventData",
@@ -5382,7 +5845,8 @@ __tnRegisterFootprint3("CredentialRegisteredEventData", (params) => CredentialRe
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 var __tn_ir_PasskeyEvent = {
   typeName: "PasskeyEvent",
@@ -5737,30 +6201,93 @@ __tnRegisterFootprint3("PasskeyEvent", (params) => PasskeyEvent.__tnInvokeFootpr
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 var __tn_ir_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" }] } } } }
+  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: 73n } } }, right: { op: "align", alignment: 1, node: { op: "const", value: 32n } } }, right: { op: "align", alignment: 1, node: { op: "call", typeName: "StateProof", args: [{ name: "proof_body.hdr.type_slot", source: "proof_body.hdr.type_slot" }, { name: "proof_body.payload_size", source: "proof_body.payload_size" }] } } } }
 };
 var CreateArgs = class _CreateArgs {
-  constructor(buffer) {
+  constructor(buffer, params) {
     this.buffer = buffer;
     this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    if (params) {
+      this.__tnParams = params;
+    } else {
+      const derived = _CreateArgs.__tnExtractParams(this.view, buffer);
+      if (!derived) {
+        throw new Error("CreateArgs: failed to derive dynamic parameters");
+      }
+      this.__tnParams = derived.params;
+    }
   }
   static __tnCreateView(buffer, opts) {
     if (!buffer || buffer.length === void 0) throw new Error("CreateArgs.__tnCreateView requires a Uint8Array");
-    return new _CreateArgs(new Uint8Array(buffer));
+    let params = opts?.params ?? null;
+    if (!params) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      const derived = _CreateArgs.__tnExtractParams(view, buffer);
+      if (!derived) throw new Error("CreateArgs.__tnCreateView: failed to derive params");
+      params = derived.params;
+    }
+    const instance = new _CreateArgs(new Uint8Array(buffer), params);
+    return instance;
+  }
+  dynamicParams() {
+    return this.__tnParams;
   }
   static builder() {
     return new CreateArgsBuilder();
   }
   static fromBuilder(builder) {
     const buffer = builder.build();
-    return _CreateArgs.from_array(buffer);
+    const params = builder.dynamicParams();
+    return _CreateArgs.from_array(buffer, { params });
   }
-  get_wallet_account_idx() {
-    const offset = 0;
+  static __tnComputeSequentialLayout(view, buffer) {
+    const __tnLength = buffer.length;
+    let __tnParamSeq_proof_body_hdr_type_slot = null;
+    let __tnParamSeq_proof_body_payload_size = null;
+    let __tnCursorMutable = 0;
+    if (__tnCursorMutable + 2 > __tnLength) return null;
+    view.getUint16(__tnCursorMutable, true);
+    __tnCursorMutable += 2;
+    if (__tnCursorMutable + 65 > __tnLength) return null;
+    __tnCursorMutable += 65;
+    if (__tnCursorMutable + 32 > __tnLength) return null;
+    __tnCursorMutable += 32;
+    const __tnTyperefResult_state_proof = __tnInvokeDynamicValidate3("StateProof", buffer.subarray(__tnCursorMutable));
+    if (!__tnTyperefResult_state_proof.ok || __tnTyperefResult_state_proof.consumed === void 0) return null;
+    const __tnTyperefParams_state_proof = __tnTyperefResult_state_proof.params ?? null;
+    if (!__tnTyperefParams_state_proof || __tnTyperefParams_state_proof["proof_body_hdr_type_slot"] === void 0) return null;
+    __tnParamSeq_proof_body_hdr_type_slot = __tnTyperefParams_state_proof["proof_body_hdr_type_slot"];
+    if (!__tnTyperefParams_state_proof || __tnTyperefParams_state_proof["proof_body_payload_size"] === void 0) return null;
+    __tnParamSeq_proof_body_payload_size = __tnTyperefParams_state_proof["proof_body_payload_size"];
+    __tnCursorMutable += __tnBigIntToNumber3(__tnTyperefResult_state_proof.consumed, "CreateArgs::state_proof");
+    const params = /* @__PURE__ */ Object.create(null);
+    if (__tnParamSeq_proof_body_hdr_type_slot === null) return null;
+    params["proof_body_hdr_type_slot"] = __tnParamSeq_proof_body_hdr_type_slot;
+    if (__tnParamSeq_proof_body_payload_size === null) return null;
+    params["proof_body_payload_size"] = __tnParamSeq_proof_body_payload_size;
+    return { params, offsets: null, derived: null };
+  }
+  static __tnExtractParams(view, buffer) {
+    const __tnLayout = _CreateArgs.__tnComputeSequentialLayout(view, buffer);
+    if (!__tnLayout || !__tnLayout.params) return null;
+    const __tnSeqParams = __tnLayout.params;
+    const __tnParamSeq_proof_body_hdr_type_slot = __tnSeqParams["proof_body_hdr_type_slot"];
+    if (__tnParamSeq_proof_body_hdr_type_slot === void 0) return null;
+    const __tnParamSeq_proof_body_payload_size = __tnSeqParams["proof_body_payload_size"];
+    if (__tnParamSeq_proof_body_payload_size === void 0) return null;
+    const __tnExtractedParams = _CreateArgs.Params.fromValues({
+      proof_body_hdr_type_slot: __tnParamSeq_proof_body_hdr_type_slot,
+      proof_body_payload_size: __tnParamSeq_proof_body_payload_size
+    });
+    return { params: __tnExtractedParams, derived: null };
+  }
+  get_wallet_account_idx() {
+    const offset = 0;
     return this.view.getUint16(offset, true);
   }
   set_wallet_account_idx(value) {
@@ -5773,30 +6300,30 @@ var CreateArgs = class _CreateArgs {
   set wallet_account_idx(value) {
     this.set_wallet_account_idx(value);
   }
-  get_authority() {
+  get_authority_record() {
     const offset = 2;
-    const slice = this.buffer.subarray(offset, offset + 65);
-    return Authority.from_array(slice);
+    const slice = this.buffer.subarray(offset, offset + 73);
+    return AuthorityRecord.from_array(slice);
   }
-  set_authority(value) {
+  set_authority_record(value) {
     const sourceBytes = value.buffer;
     const offset = 2;
     this.buffer.set(sourceBytes, offset);
   }
-  get authority() {
-    return this.get_authority();
+  get authority_record() {
+    return this.get_authority_record();
   }
-  set authority(value) {
-    this.set_authority(value);
+  set authority_record(value) {
+    this.set_authority_record(value);
   }
   get_seed() {
-    const offset = 67;
+    const offset = 75;
     const slice = this.buffer.subarray(offset, offset + 32);
     return Seed32.from_array(slice);
   }
   set_seed(value) {
     const sourceBytes = value.buffer;
-    const offset = 67;
+    const offset = 75;
     this.buffer.set(sourceBytes, offset);
   }
   get seed() {
@@ -5806,7 +6333,7 @@ var CreateArgs = class _CreateArgs {
     this.set_seed(value);
   }
   get_state_proof() {
-    const offset = 99;
+    const offset = 107;
     const tail = this.buffer.subarray(offset);
     const validation = StateProof.validate(tail);
     if (!validation.ok || validation.consumed === void 0) {
@@ -5819,7 +6346,7 @@ var CreateArgs = class _CreateArgs {
   }
   set_state_proof(value) {
     const sourceBytes = value.buffer;
-    const offset = 99;
+    const offset = 107;
     this.buffer.set(sourceBytes, offset);
   }
   get state_proof() {
@@ -5840,146 +6367,294 @@ var CreateArgs = class _CreateArgs {
   static __tnInvokeValidate(buffer, __tnParams) {
     return this.__tnValidateInternal(buffer, __tnParams);
   }
-  static footprintIr() {
-    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  static footprintIr(proof_body_hdr_type_slot, proof_body_payload_size) {
+    const params = _CreateArgs.Params.fromValues({
+      proof_body_hdr_type_slot,
+      proof_body_payload_size
+    });
+    return this.footprintIrFromParams(params);
   }
-  static footprint() {
-    const irResult = this.footprintIr();
+  static __tnPackParams(params) {
+    const record = /* @__PURE__ */ Object.create(null);
+    record["proof_body.hdr.type_slot"] = params.proof_body_hdr_type_slot;
+    record["proof_body.payload_size"] = params.proof_body_payload_size;
+    return record;
+  }
+  static footprintIrFromParams(params) {
+    const __tnParams = this.__tnPackParams(params);
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static footprintFromParams(params) {
+    const irResult = this.footprintIrFromParams(params);
     const maxSafe = __tnToBigInt3(Number.MAX_SAFE_INTEGER);
-    if (__tnBigIntGreaterThan3(irResult, maxSafe)) {
-      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for CreateArgs");
-    }
-    return __tnBigIntToNumber3(irResult, "CreateArgs::footprint");
+    if (__tnBigIntGreaterThan3(irResult, maxSafe)) throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for CreateArgs");
+    return __tnBigIntToNumber3(irResult, "CreateArgs::footprintFromParams");
+  }
+  static footprintFromValues(input) {
+    const params = _CreateArgs.params(input);
+    return this.footprintFromParams(params);
   }
-  static validate(_buffer, _opts) {
-    __tnLogWarn3("CreateArgs::validate falling back to basic length check");
-    return { ok: true, consumed: _buffer.length };
+  static footprint(params) {
+    return this.footprintFromParams(params);
   }
-  static from_array(buffer) {
+  static validate(buffer, opts) {
+    if (!buffer || buffer.length === void 0) {
+      return { ok: false, code: "tn.invalid_buffer" };
+    }
+    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    let params = opts?.params ?? null;
+    if (!params) {
+      return { ok: false, code: "tn.param_extraction_failed" };
+    }
+    const __tnParamsRec = this.__tnPackParams(params);
+    const irResult = this.__tnValidateInternal(buffer, __tnParamsRec);
+    if (!irResult.ok) {
+      return { ok: false, code: irResult.code, consumed: irResult.consumed ? __tnBigIntToNumber3(irResult.consumed, "CreateArgs::validate") : void 0, params };
+    }
+    const consumed = irResult.consumed ? __tnBigIntToNumber3(irResult.consumed, "CreateArgs::validate") : void 0;
+    return { ok: true, consumed, params };
+  }
+  static from_array(buffer, opts) {
     if (!buffer || buffer.length === void 0) {
       return null;
     }
     new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    const validation = this.validate(buffer);
+    let params = opts?.params ?? null;
+    if (!params) {
+      __tnLogWarn3("CreateArgs::from_array requires params when IR extraction is unavailable");
+      return null;
+    }
+    const validation = this.validate(buffer, { params });
     if (!validation.ok) {
       return null;
     }
-    return new _CreateArgs(buffer);
+    const cached = validation.params ?? params;
+    const state = new _CreateArgs(buffer, cached);
+    return state;
   }
 };
+((CreateArgs2) => {
+  CreateArgs2.ParamKeys = Object.freeze({
+    proof_body_hdr_type_slot: "proof_body.hdr.type_slot",
+    proof_body_payload_size: "proof_body.payload_size"
+  });
+  CreateArgs2.Params = {
+    fromValues(input) {
+      return {
+        proof_body_hdr_type_slot: __tnToBigInt3(input.proof_body_hdr_type_slot),
+        proof_body_payload_size: __tnToBigInt3(input.proof_body_payload_size)
+      };
+    },
+    fromBuilder(source) {
+      if (source.dynamicParams) {
+        return source.dynamicParams();
+      }
+      if (source.params) {
+        return source.params;
+      }
+      return source;
+    }
+  };
+  function params(input) {
+    return CreateArgs2.Params.fromValues(input);
+  }
+  CreateArgs2.params = params;
+})(CreateArgs || (CreateArgs = {}));
 var CreateArgsBuilder = class {
   constructor() {
+    this.__tnCachedParams = null;
+    this.__tnLastBuffer = null;
+    this.__tnLastParams = null;
     this.__tnTail_state_proof = null;
-    this.buffer = new Uint8Array(99);
+    this.__tnTailParams_state_proof = null;
+    this.buffer = new Uint8Array(107);
     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_authority(value) {
-    if (value.length !== 65) throw new Error("authority expects 65 bytes");
+  set_authority_record(value) {
+    if (value.length !== 73) throw new Error("authority_record expects 73 bytes");
     this.buffer.set(value, 2);
     this.__tnInvalidate();
     return this;
   }
   set_seed(value) {
     if (value.length !== 32) throw new Error("seed expects 32 bytes");
-    this.buffer.set(value, 67);
+    this.buffer.set(value, 75);
     this.__tnInvalidate();
     return this;
   }
   set_state_proof(value) {
     const bytes = __tnResolveStructFieldInput(value, "CreateArgsBuilder::state_proof");
+    const validation = __tnInvokeDynamicValidate3("StateProof", bytes);
+    if (!validation.ok || validation.consumed === void 0) throw new Error("CreateArgsBuilder: field 'state_proof' failed validation");
+    if (__tnBigIntToNumber3(validation.consumed, "CreateArgsBuilder::state_proof") !== bytes.length) throw new Error("CreateArgsBuilder: field 'state_proof' validation did not consume the full buffer");
     this.__tnTail_state_proof = bytes;
+    this.__tnTailParams_state_proof = validation.params ?? null;
     this.__tnInvalidate();
     return this;
   }
   build() {
-    const fragments = this.__tnCollectTailFragments();
-    const size = this.__tnComputeSize(fragments);
+    const params = this.__tnComputeParams();
+    const size = CreateArgs.footprintFromParams(params);
     const buffer = new Uint8Array(size);
-    this.__tnWriteInto(buffer, fragments);
-    this.__tnValidateOrThrow(buffer);
+    this.__tnWriteInto(buffer);
+    this.__tnValidateOrThrow(buffer, params);
     return buffer;
   }
   buildInto(target, offset = 0) {
-    const fragments = this.__tnCollectTailFragments();
-    const size = this.__tnComputeSize(fragments);
+    const params = this.__tnComputeParams();
+    const size = CreateArgs.footprintFromParams(params);
     if (target.length - offset < size) throw new Error("CreateArgsBuilder: target buffer too small");
     const slice = target.subarray(offset, offset + size);
-    this.__tnWriteInto(slice, fragments);
-    this.__tnValidateOrThrow(slice);
+    this.__tnWriteInto(slice);
+    this.__tnValidateOrThrow(slice, params);
     return target;
   }
   finish() {
     const buffer = this.build();
-    const view = CreateArgs.from_array(buffer);
+    const params = this.__tnLastParams ?? this.__tnComputeParams();
+    const view = CreateArgs.from_array(buffer, { params });
     if (!view) throw new Error("CreateArgsBuilder: failed to finalize view");
     return view;
   }
   finishView() {
     return this.finish();
   }
-  __tnCollectTailFragments() {
-    return [
-      (() => {
-        const bytes = this.__tnTail_state_proof;
-        if (!bytes) throw new Error("CreateArgsBuilder: field 'state_proof' must be set before build()");
-        return bytes;
-      })()
-    ];
+  dynamicParams() {
+    return this.__tnComputeParams();
   }
-  __tnComputeSize(fragments) {
-    let total = this.buffer.length;
-    for (const fragment of fragments) {
-      total += fragment.length;
-    }
-    return total;
+  __tnComputeParams() {
+    if (this.__tnCachedParams) return this.__tnCachedParams;
+    const params = CreateArgs.Params.fromValues({
+      proof_body_hdr_type_slot: (() => {
+        const params2 = this.__tnTailParams_state_proof;
+        if (!params2 || params2["proof_body_hdr_type_slot"] === void 0) throw new Error("CreateArgsBuilder: field 'state_proof' must be written before computing params");
+        return params2["proof_body_hdr_type_slot"];
+      })(),
+      proof_body_payload_size: (() => {
+        const params2 = this.__tnTailParams_state_proof;
+        if (!params2 || params2["proof_body_payload_size"] === void 0) throw new Error("CreateArgsBuilder: field 'state_proof' must be written before computing params");
+        return params2["proof_body_payload_size"];
+      })()
+    });
+    this.__tnCachedParams = params;
+    return params;
   }
-  __tnWriteInto(target, fragments) {
+  __tnWriteInto(target) {
     target.set(this.buffer, 0);
     let cursor = this.buffer.length;
-    for (const fragment of fragments) {
-      target.set(fragment, cursor);
-      cursor += fragment.length;
-    }
+    const __tnLocal_state_proof_bytes = this.__tnTail_state_proof;
+    if (!__tnLocal_state_proof_bytes) throw new Error("CreateArgsBuilder: field 'state_proof' must be written before build");
+    target.set(__tnLocal_state_proof_bytes, cursor);
+    cursor += __tnLocal_state_proof_bytes.length;
   }
-  __tnValidateOrThrow(buffer) {
-    const result = CreateArgs.validate(buffer);
+  __tnValidateOrThrow(buffer, params) {
+    const result = CreateArgs.validate(buffer, { params });
     if (!result.ok) {
-      throw new Error(`CreateArgsBuilder: builder produced invalid buffer (code=${result.code ?? "unknown"})`);
+      throw new Error(`${CreateArgs}Builder: builder produced invalid buffer (code=${result.code ?? "unknown"})`);
     }
+    this.__tnLastParams = result.params ?? params;
+    this.__tnLastBuffer = buffer;
   }
 };
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 var __tn_ir_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" }] } } } }
 };
 var RegisterCredentialArgs = class _RegisterCredentialArgs {
-  constructor(buffer) {
+  constructor(buffer, params) {
     this.buffer = buffer;
     this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    if (params) {
+      this.__tnParams = params;
+    } else {
+      const derived = _RegisterCredentialArgs.__tnExtractParams(this.view, buffer);
+      if (!derived) {
+        throw new Error("RegisterCredentialArgs: failed to derive dynamic parameters");
+      }
+      this.__tnParams = derived.params;
+    }
   }
   static __tnCreateView(buffer, opts) {
     if (!buffer || buffer.length === void 0) throw new Error("RegisterCredentialArgs.__tnCreateView requires a Uint8Array");
-    return new _RegisterCredentialArgs(new Uint8Array(buffer));
+    let params = opts?.params ?? null;
+    if (!params) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      const derived = _RegisterCredentialArgs.__tnExtractParams(view, buffer);
+      if (!derived) throw new Error("RegisterCredentialArgs.__tnCreateView: failed to derive params");
+      params = derived.params;
+    }
+    const instance = new _RegisterCredentialArgs(new Uint8Array(buffer), params);
+    return instance;
+  }
+  dynamicParams() {
+    return this.__tnParams;
   }
   static builder() {
     return new RegisterCredentialArgsBuilder();
   }
   static fromBuilder(builder) {
     const buffer = builder.build();
-    return _RegisterCredentialArgs.from_array(buffer);
+    const params = builder.dynamicParams();
+    return _RegisterCredentialArgs.from_array(buffer, { params });
+  }
+  static __tnComputeSequentialLayout(view, buffer) {
+    const __tnLength = buffer.length;
+    let __tnParamSeq_proof_body_hdr_type_slot = null;
+    let __tnParamSeq_proof_body_payload_size = null;
+    let __tnCursorMutable = 0;
+    if (__tnCursorMutable + 2 > __tnLength) return null;
+    view.getUint16(__tnCursorMutable, true);
+    __tnCursorMutable += 2;
+    if (__tnCursorMutable + 2 > __tnLength) return null;
+    view.getUint16(__tnCursorMutable, true);
+    __tnCursorMutable += 2;
+    if (__tnCursorMutable + 32 > __tnLength) return null;
+    __tnCursorMutable += 32;
+    const __tnTyperefResult_state_proof = __tnInvokeDynamicValidate3("StateProof", buffer.subarray(__tnCursorMutable));
+    if (!__tnTyperefResult_state_proof.ok || __tnTyperefResult_state_proof.consumed === void 0) return null;
+    const __tnTyperefParams_state_proof = __tnTyperefResult_state_proof.params ?? null;
+    if (!__tnTyperefParams_state_proof || __tnTyperefParams_state_proof["proof_body_hdr_type_slot"] === void 0) return null;
+    __tnParamSeq_proof_body_hdr_type_slot = __tnTyperefParams_state_proof["proof_body_hdr_type_slot"];
+    if (!__tnTyperefParams_state_proof || __tnTyperefParams_state_proof["proof_body_payload_size"] === void 0) return null;
+    __tnParamSeq_proof_body_payload_size = __tnTyperefParams_state_proof["proof_body_payload_size"];
+    __tnCursorMutable += __tnBigIntToNumber3(__tnTyperefResult_state_proof.consumed, "RegisterCredentialArgs::state_proof");
+    const params = /* @__PURE__ */ Object.create(null);
+    if (__tnParamSeq_proof_body_hdr_type_slot === null) return null;
+    params["proof_body_hdr_type_slot"] = __tnParamSeq_proof_body_hdr_type_slot;
+    if (__tnParamSeq_proof_body_payload_size === null) return null;
+    params["proof_body_payload_size"] = __tnParamSeq_proof_body_payload_size;
+    return { params, offsets: null, derived: null };
+  }
+  static __tnExtractParams(view, buffer) {
+    const __tnLayout = _RegisterCredentialArgs.__tnComputeSequentialLayout(view, buffer);
+    if (!__tnLayout || !__tnLayout.params) return null;
+    const __tnSeqParams = __tnLayout.params;
+    const __tnParamSeq_proof_body_hdr_type_slot = __tnSeqParams["proof_body_hdr_type_slot"];
+    if (__tnParamSeq_proof_body_hdr_type_slot === void 0) return null;
+    const __tnParamSeq_proof_body_payload_size = __tnSeqParams["proof_body_payload_size"];
+    if (__tnParamSeq_proof_body_payload_size === void 0) return null;
+    const __tnExtractedParams = _RegisterCredentialArgs.Params.fromValues({
+      proof_body_hdr_type_slot: __tnParamSeq_proof_body_hdr_type_slot,
+      proof_body_payload_size: __tnParamSeq_proof_body_payload_size
+    });
+    return { params: __tnExtractedParams, derived: null };
   }
   get_wallet_account_idx() {
     const offset = 0;
@@ -6060,40 +6735,113 @@ var RegisterCredentialArgs = class _RegisterCredentialArgs {
   static __tnInvokeValidate(buffer, __tnParams) {
     return this.__tnValidateInternal(buffer, __tnParams);
   }
-  static footprintIr() {
-    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  static footprintIr(proof_body_hdr_type_slot, proof_body_payload_size) {
+    const params = _RegisterCredentialArgs.Params.fromValues({
+      proof_body_hdr_type_slot,
+      proof_body_payload_size
+    });
+    return this.footprintIrFromParams(params);
   }
-  static footprint() {
-    const irResult = this.footprintIr();
+  static __tnPackParams(params) {
+    const record = /* @__PURE__ */ Object.create(null);
+    record["proof_body.hdr.type_slot"] = params.proof_body_hdr_type_slot;
+    record["proof_body.payload_size"] = params.proof_body_payload_size;
+    return record;
+  }
+  static footprintIrFromParams(params) {
+    const __tnParams = this.__tnPackParams(params);
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static footprintFromParams(params) {
+    const irResult = this.footprintIrFromParams(params);
     const maxSafe = __tnToBigInt3(Number.MAX_SAFE_INTEGER);
-    if (__tnBigIntGreaterThan3(irResult, maxSafe)) {
-      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for RegisterCredentialArgs");
-    }
-    return __tnBigIntToNumber3(irResult, "RegisterCredentialArgs::footprint");
+    if (__tnBigIntGreaterThan3(irResult, maxSafe)) throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for RegisterCredentialArgs");
+    return __tnBigIntToNumber3(irResult, "RegisterCredentialArgs::footprintFromParams");
   }
-  static validate(_buffer, _opts) {
-    __tnLogWarn3("RegisterCredentialArgs::validate falling back to basic length check");
-    return { ok: true, consumed: _buffer.length };
+  static footprintFromValues(input) {
+    const params = _RegisterCredentialArgs.params(input);
+    return this.footprintFromParams(params);
   }
-  static from_array(buffer) {
+  static footprint(params) {
+    return this.footprintFromParams(params);
+  }
+  static validate(buffer, opts) {
+    if (!buffer || buffer.length === void 0) {
+      return { ok: false, code: "tn.invalid_buffer" };
+    }
+    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    let params = opts?.params ?? null;
+    if (!params) {
+      return { ok: false, code: "tn.param_extraction_failed" };
+    }
+    const __tnParamsRec = this.__tnPackParams(params);
+    const irResult = this.__tnValidateInternal(buffer, __tnParamsRec);
+    if (!irResult.ok) {
+      return { ok: false, code: irResult.code, consumed: irResult.consumed ? __tnBigIntToNumber3(irResult.consumed, "RegisterCredentialArgs::validate") : void 0, params };
+    }
+    const consumed = irResult.consumed ? __tnBigIntToNumber3(irResult.consumed, "RegisterCredentialArgs::validate") : void 0;
+    return { ok: true, consumed, params };
+  }
+  static from_array(buffer, opts) {
     if (!buffer || buffer.length === void 0) {
       return null;
     }
     new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-    const validation = this.validate(buffer);
+    let params = opts?.params ?? null;
+    if (!params) {
+      __tnLogWarn3("RegisterCredentialArgs::from_array requires params when IR extraction is unavailable");
+      return null;
+    }
+    const validation = this.validate(buffer, { params });
     if (!validation.ok) {
       return null;
     }
-    return new _RegisterCredentialArgs(buffer);
+    const cached = validation.params ?? params;
+    const state = new _RegisterCredentialArgs(buffer, cached);
+    return state;
   }
 };
+((RegisterCredentialArgs2) => {
+  RegisterCredentialArgs2.ParamKeys = Object.freeze({
+    proof_body_hdr_type_slot: "proof_body.hdr.type_slot",
+    proof_body_payload_size: "proof_body.payload_size"
+  });
+  RegisterCredentialArgs2.Params = {
+    fromValues(input) {
+      return {
+        proof_body_hdr_type_slot: __tnToBigInt3(input.proof_body_hdr_type_slot),
+        proof_body_payload_size: __tnToBigInt3(input.proof_body_payload_size)
+      };
+    },
+    fromBuilder(source) {
+      if (source.dynamicParams) {
+        return source.dynamicParams();
+      }
+      if (source.params) {
+        return source.params;
+      }
+      return source;
+    }
+  };
+  function params(input) {
+    return RegisterCredentialArgs2.Params.fromValues(input);
+  }
+  RegisterCredentialArgs2.params = params;
+})(RegisterCredentialArgs || (RegisterCredentialArgs = {}));
 var RegisterCredentialArgsBuilder = class {
   constructor() {
+    this.__tnCachedParams = null;
+    this.__tnLastBuffer = null;
+    this.__tnLastParams = null;
     this.__tnTail_state_proof = null;
+    this.__tnTailParams_state_proof = null;
     this.buffer = new Uint8Array(36);
     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);
@@ -6113,72 +6861,84 @@ var RegisterCredentialArgsBuilder = class {
   }
   set_state_proof(value) {
     const bytes = __tnResolveStructFieldInput(value, "RegisterCredentialArgsBuilder::state_proof");
+    const validation = __tnInvokeDynamicValidate3("StateProof", bytes);
+    if (!validation.ok || validation.consumed === void 0) throw new Error("RegisterCredentialArgsBuilder: field 'state_proof' failed validation");
+    if (__tnBigIntToNumber3(validation.consumed, "RegisterCredentialArgsBuilder::state_proof") !== bytes.length) throw new Error("RegisterCredentialArgsBuilder: field 'state_proof' validation did not consume the full buffer");
     this.__tnTail_state_proof = bytes;
+    this.__tnTailParams_state_proof = validation.params ?? null;
     this.__tnInvalidate();
     return this;
   }
   build() {
-    const fragments = this.__tnCollectTailFragments();
-    const size = this.__tnComputeSize(fragments);
+    const params = this.__tnComputeParams();
+    const size = RegisterCredentialArgs.footprintFromParams(params);
     const buffer = new Uint8Array(size);
-    this.__tnWriteInto(buffer, fragments);
-    this.__tnValidateOrThrow(buffer);
+    this.__tnWriteInto(buffer);
+    this.__tnValidateOrThrow(buffer, params);
     return buffer;
   }
   buildInto(target, offset = 0) {
-    const fragments = this.__tnCollectTailFragments();
-    const size = this.__tnComputeSize(fragments);
+    const params = this.__tnComputeParams();
+    const size = RegisterCredentialArgs.footprintFromParams(params);
     if (target.length - offset < size) throw new Error("RegisterCredentialArgsBuilder: target buffer too small");
     const slice = target.subarray(offset, offset + size);
-    this.__tnWriteInto(slice, fragments);
-    this.__tnValidateOrThrow(slice);
+    this.__tnWriteInto(slice);
+    this.__tnValidateOrThrow(slice, params);
     return target;
   }
   finish() {
     const buffer = this.build();
-    const view = RegisterCredentialArgs.from_array(buffer);
+    const params = this.__tnLastParams ?? this.__tnComputeParams();
+    const view = RegisterCredentialArgs.from_array(buffer, { params });
     if (!view) throw new Error("RegisterCredentialArgsBuilder: failed to finalize view");
     return view;
   }
   finishView() {
     return this.finish();
   }
-  __tnCollectTailFragments() {
-    return [
-      (() => {
-        const bytes = this.__tnTail_state_proof;
-        if (!bytes) throw new Error("RegisterCredentialArgsBuilder: field 'state_proof' must be set before build()");
-        return bytes;
-      })()
-    ];
+  dynamicParams() {
+    return this.__tnComputeParams();
   }
-  __tnComputeSize(fragments) {
-    let total = this.buffer.length;
-    for (const fragment of fragments) {
-      total += fragment.length;
-    }
-    return total;
+  __tnComputeParams() {
+    if (this.__tnCachedParams) return this.__tnCachedParams;
+    const params = RegisterCredentialArgs.Params.fromValues({
+      proof_body_hdr_type_slot: (() => {
+        const params2 = this.__tnTailParams_state_proof;
+        if (!params2 || params2["proof_body_hdr_type_slot"] === void 0) throw new Error("RegisterCredentialArgsBuilder: field 'state_proof' must be written before computing params");
+        return params2["proof_body_hdr_type_slot"];
+      })(),
+      proof_body_payload_size: (() => {
+        const params2 = this.__tnTailParams_state_proof;
+        if (!params2 || params2["proof_body_payload_size"] === void 0) throw new Error("RegisterCredentialArgsBuilder: field 'state_proof' must be written before computing params");
+        return params2["proof_body_payload_size"];
+      })()
+    });
+    this.__tnCachedParams = params;
+    return params;
   }
-  __tnWriteInto(target, fragments) {
+  __tnWriteInto(target) {
     target.set(this.buffer, 0);
     let cursor = this.buffer.length;
-    for (const fragment of fragments) {
-      target.set(fragment, cursor);
-      cursor += fragment.length;
-    }
+    const __tnLocal_state_proof_bytes = this.__tnTail_state_proof;
+    if (!__tnLocal_state_proof_bytes) throw new Error("RegisterCredentialArgsBuilder: field 'state_proof' must be written before build");
+    target.set(__tnLocal_state_proof_bytes, cursor);
+    cursor += __tnLocal_state_proof_bytes.length;
   }
-  __tnValidateOrThrow(buffer) {
-    const result = RegisterCredentialArgs.validate(buffer);
+  __tnValidateOrThrow(buffer, params) {
+    const result = RegisterCredentialArgs.validate(buffer, { params });
     if (!result.ok) {
-      throw new Error(`RegisterCredentialArgsBuilder: builder produced invalid buffer (code=${result.code ?? "unknown"})`);
+      throw new Error(`${RegisterCredentialArgs}Builder: builder produced invalid buffer (code=${result.code ?? "unknown"})`);
     }
+    this.__tnLastParams = result.params ?? params;
+    this.__tnLastBuffer = buffer;
   }
 };
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 var __tn_ir_PasskeyInstruction = {
   typeName: "PasskeyInstruction",
@@ -6439,7 +7199,7 @@ _PasskeyInstruction.payloadVariantDescriptors = Object.freeze([
     tag: 1,
     payloadSize: null,
     payloadType: "PasskeyInstruction::payload::validate",
-    createPayloadBuilder: () => null
+    createPayloadBuilder: () => __tnMaybeCallBuilder(ValidateArgs)
   },
   {
     name: "transfer",
@@ -6451,7 +7211,7 @@ _PasskeyInstruction.payloadVariantDescriptors = Object.freeze([
   {
     name: "add_authority",
     tag: 4,
-    payloadSize: 67,
+    payloadSize: 75,
     payloadType: "PasskeyInstruction::payload::add_authority",
     createPayloadBuilder: () => __tnMaybeCallBuilder(AddAuthorityArgs)
   },
@@ -6606,35 +7366,108 @@ __tnRegisterFootprint3("PasskeyInstruction", (params) => PasskeyInstruction.__tn
 __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) };
+  const params = result.params;
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt3(result.consumed), params };
 });
 
+// src/passkey-manager/constants.ts
+var PASSKEY_MANAGER_PROGRAM_ADDRESS = "tabsq39mzj3DZlutXOGG6VtfMj8fUvI0HIOXfZm7TLLY6N";
+var INSTRUCTION_CREATE = 0;
+var INSTRUCTION_VALIDATE = 1;
+var INSTRUCTION_TRANSFER = 2;
+var INSTRUCTION_ADD_AUTHORITY = 4;
+var INSTRUCTION_REMOVE_AUTHORITY = 5;
+var INSTRUCTION_REGISTER_CREDENTIAL = 6;
+var AUTHORITY_TAG_PASSKEY = 1;
+var AUTHORITY_TAG_PUBKEY = 2;
+var AUTHORITY_BYTES = Authority.footprint();
+var AUTHORITY_RECORD_BYTES = AuthorityRecord.footprint();
+var LONG_LIVED_AUTHORITY_EXPIRY_SECONDS = 0xffffffffffffffffn;
+
 // src/passkey-manager/instructions/create.ts
+var AUTHORITY_DATA_BYTES = AUTHORITY_BYTES - 1;
+var PUBKEY_BYTES = AUTHORITY_DATA_BYTES / 2;
+var U64_MAX = 0xffffffffffffffffn;
 function buildAuthority(authority) {
-  const data = new Array(64).fill(0);
+  const data = new Array(AUTHORITY_DATA_BYTES).fill(0);
   if (authority.tag === 1) {
-    if (authority.pubkeyX.length !== 32) throw new Error("pubkeyX must be 32 bytes");
-    if (authority.pubkeyY.length !== 32) throw new Error("pubkeyY must be 32 bytes");
-    for (let i = 0; i < 32; i++) data[i] = authority.pubkeyX[i];
-    for (let i = 0; i < 32; i++) data[32 + i] = authority.pubkeyY[i];
+    if (authority.pubkeyX.length !== PUBKEY_BYTES) throw new Error("pubkeyX must be 32 bytes");
+    if (authority.pubkeyY.length !== PUBKEY_BYTES) throw new Error("pubkeyY must be 32 bytes");
+    for (let i = 0; i < PUBKEY_BYTES; i++) data[i] = authority.pubkeyX[i];
+    for (let i = 0; i < PUBKEY_BYTES; i++) data[PUBKEY_BYTES + i] = authority.pubkeyY[i];
   } else if (authority.tag === 2) {
-    if (authority.pubkey.length !== 32) throw new Error("pubkey must be 32 bytes");
-    for (let i = 0; i < 32; i++) data[i] = authority.pubkey[i];
+    if (authority.pubkey.length !== PUBKEY_BYTES) throw new Error("pubkey must be 32 bytes");
+    for (let i = 0; i < PUBKEY_BYTES; i++) data[i] = authority.pubkey[i];
   } else {
     throw new Error("Invalid authority tag");
   }
   return new AuthorityBuilder().set_tag(authority.tag).set_data(data).build();
 }
+function copyGeneratedBuffer(view, label) {
+  const buffer = view.buffer;
+  if (!buffer) {
+    throw new Error(`${label} did not expose a generated buffer`);
+  }
+  return buffer.slice();
+}
+function assertU64(value, label) {
+  if (value < 0n || value > U64_MAX) {
+    throw new Error(`${label} must fit in u64`);
+  }
+}
+function createAuthorityRecord(authority, expiresAtBlockTimeSeconds = LONG_LIVED_AUTHORITY_EXPIRY_SECONDS) {
+  return { authority, expiresAtBlockTimeSeconds };
+}
+function createSessionAuthorityRecord(params) {
+  return createAuthorityRecord(
+    { tag: 2, pubkey: params.pubkey },
+    params.expiresAtBlockTimeSeconds
+  );
+}
+function buildAuthorityRecord(record) {
+  assertU64(record.expiresAtBlockTimeSeconds, "expiresAtBlockTimeSeconds");
+  const authority = Authority.from_array(buildAuthority(record.authority));
+  if (!authority) {
+    throw new Error("Failed to build authority");
+  }
+  const authorityRecord = AuthorityRecord.__tnCreateView(
+    new Uint8Array(AUTHORITY_RECORD_BYTES)
+  );
+  authorityRecord.set_authority(authority);
+  authorityRecord.set_expires_at_block_time_seconds(
+    record.expiresAtBlockTimeSeconds
+  );
+  return copyGeneratedBuffer(authorityRecord, "AuthorityRecord");
+}
 function encodeCreateInstruction(params) {
-  const { walletAccountIdx, authority, seed, stateProof } = params;
+  const { walletAccountIdx, authorityRecord, seed, stateProof } = params;
   if (seed.length !== 32) throw new Error("seed must be 32 bytes");
   if (walletAccountIdx < 0 || walletAccountIdx > 65535) {
     throw new Error("walletAccountIdx must be 0-65535");
   }
-  const authorityBytes = buildAuthority(authority);
-  const argsPayload = new CreateArgsBuilder().set_wallet_account_idx(walletAccountIdx).set_authority(authorityBytes).set_seed(seed).set_state_proof(stateProof).build();
+  const authorityRecordBytes = buildAuthorityRecord(authorityRecord);
+  const argsPayload = new CreateArgsBuilder().set_wallet_account_idx(walletAccountIdx).set_authority_record(authorityRecordBytes).set_seed(seed).set_state_proof(stateProof).build();
   return new PasskeyInstructionBuilder().payload().select("create").writePayload(argsPayload).finish().build();
 }
+function writeU16LE(target, offset, value) {
+  target[offset] = value & 255;
+  target[offset + 1] = value >> 8 & 255;
+}
+function encodeLegacyCreateInstruction(params) {
+  const { walletAccountIdx, authorityRecord, seed, stateProof } = params;
+  if (seed.length !== 32) throw new Error("seed must be 32 bytes");
+  if (walletAccountIdx < 0 || walletAccountIdx > 65535) {
+    throw new Error("walletAccountIdx must be 0-65535");
+  }
+  const authorityBytes = buildAuthority(authorityRecord.authority);
+  const output = new Uint8Array(1 + 2 + authorityBytes.length + seed.length + stateProof.length);
+  output[0] = INSTRUCTION_CREATE;
+  writeU16LE(output, 1, walletAccountIdx);
+  output.set(authorityBytes, 3);
+  output.set(seed, 3 + authorityBytes.length);
+  output.set(stateProof, 3 + authorityBytes.length + seed.length);
+  return output;
+}
 
 // src/passkey-manager/target-instruction.ts
 function buildTargetInstructionBytes({
@@ -6659,14 +7492,6 @@ function buildTargetInstructionBytes({
 }
 
 // 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,
@@ -6690,28 +7515,10 @@ function encodeValidateInstruction(params) {
     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();
+  const argsBuilder = new ValidateArgsBuilder().set_wallet_account_idx(walletAccountIdx).set_auth_idx(authIdx).set_signature_r(signatureR).set_signature_s(signatureS).set_target_instruction(targetInstructionBytes);
+  argsBuilder.authenticator_data().write(authenticatorData).finish();
+  argsBuilder.client_data().write(clientDataJSON).finish();
+  return new PasskeyInstructionBuilder().payload().select("validate").writePayload(argsBuilder).finish().build();
 }
 
 // src/passkey-manager/instructions/transfer.ts
@@ -6728,16 +7535,39 @@ function encodeTransferInstruction(params) {
   return new PasskeyInstructionBuilder().payload().select("transfer").writePayload(argsPayload).finish().build();
 }
 
+// src/passkey-manager/instructions/invoke.ts
+function encodeInvokeInstruction(_programPubkey, _instruction) {
+  throw new Error(
+    "encodeInvokeInstruction is from the legacy passkey-manager ABI. Migrate this flow to encodeValidateInstruction({ targetInstruction }) against the upgraded passkey manager."
+  );
+}
+
 // 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_wallet_account_idx(walletAccountIdx).set_authority(authorityBytes).build();
+  const authorityRecordBytes = buildAuthorityRecord(params.authorityRecord);
+  const argsPayload = new AddAuthorityArgsBuilder().set_wallet_account_idx(walletAccountIdx).set_authority_record(authorityRecordBytes).build();
   return new PasskeyInstructionBuilder().payload().select("add_authority").writePayload(argsPayload).finish().build();
 }
+function writeU16LE2(target, offset, value) {
+  target[offset] = value & 255;
+  target[offset + 1] = value >> 8 & 255;
+}
+function encodeLegacyAddAuthorityInstruction(params) {
+  const { walletAccountIdx } = params;
+  if (walletAccountIdx < 0 || walletAccountIdx > 65535) {
+    throw new Error("walletAccountIdx must be 0-65535");
+  }
+  const authorityBytes = buildAuthority(params.authorityRecord.authority);
+  const output = new Uint8Array(1 + 2 + authorityBytes.length);
+  output[0] = INSTRUCTION_ADD_AUTHORITY;
+  writeU16LE2(output, 1, walletAccountIdx);
+  output.set(authorityBytes, 3);
+  return output;
+}
 
 // src/passkey-manager/instructions/remove-authority.ts
 function encodeRemoveAuthorityInstruction(params) {
@@ -6764,6 +7594,21 @@ 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, instruction) => sum + instruction.length,
+    0
+  );
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const instruction of instructions) {
+    result.set(instruction, offset);
+    offset += instruction.length;
+  }
+  return result;
+}
+
 // src/passkey-manager/challenge.ts
 var VALIDATE_CHALLENGE_DOMAIN = "thru.passkey.validate";
 function writeU64LE(target, offset, value) {
@@ -6978,50 +7823,79 @@ function buildPasskeyReadWriteAccounts(userAccounts, feePayerPublicKey, programA
   };
   return { readWriteAddresses, findAccountIndex };
 }
+var LEGACY_WALLET_HEADER_BYTES = 9;
+var LEGACY_AUTHORITY_BYTES = 65;
+var AUTHORITY_DATA_BYTES2 = 64;
 function parseWalletNonce(data) {
   const account = WalletAccount.from_array(data);
-  if (!account) return 0n;
+  if (!account) return parseLegacyWalletNonce(data) ?? 0n;
   return account.get_nonce();
 }
 async function fetchWalletNonce(sdk, walletAddress) {
   const account = await sdk.accounts.get(walletAddress);
   const data = account.data?.data;
   if (!data) return 0n;
-  const parsed = WalletAccount.from_array(data);
-  if (!parsed) return 0n;
-  return parsed.get_nonce();
-}
-var AUTHORITY_HEADER_BYTES = 9;
-var AUTHORITY_ENTRY_BYTES = 65;
-function readU64LE(data, offset) {
-  if (offset + 8 > data.length) {
-    throw new Error("Out of bounds");
-  }
-  let value = 0n;
-  for (let i = 0; i < 8; i++) {
-    value |= BigInt(data[offset + i]) << 8n * BigInt(i);
-  }
-  return value;
+  return parseWalletNonce(data);
 }
 function parseWalletAuthorities(data) {
-  if (data.length < AUTHORITY_HEADER_BYTES) {
-    throw new Error("Wallet data too small");
-  }
-  const numAuth = data[0];
-  const nonce = readU64LE(data, 1);
-  const count = numAuth + 1;
-  const required = AUTHORITY_HEADER_BYTES + count * AUTHORITY_ENTRY_BYTES;
-  if (data.length < required) {
+  const account = WalletAccount.from_array(data);
+  if (!account) {
+    const legacy = parseLegacyWalletAuthorities(data);
+    if (legacy) return legacy;
     throw new Error("Wallet data truncated");
   }
   const authorities = [];
-  for (let idx = 0; idx < count; idx++) {
-    const offset = AUTHORITY_HEADER_BYTES + idx * AUTHORITY_ENTRY_BYTES;
+  account.get_authorities().forEach((record, idx) => {
+    const authority = record.get_authority();
+    const tag = authority.get_tag();
+    const payload = Uint8Array.from(authority.get_data());
+    const expiresAtBlockTimeSeconds = record.get_expires_at_block_time_seconds();
+    if (tag === 1) {
+      authorities.push({
+        idx,
+        expiresAtBlockTimeSeconds,
+        kind: "passkey",
+        x: payload.slice(0, 32),
+        y: payload.slice(32, 64)
+      });
+      return;
+    }
+    if (tag === 2) {
+      authorities.push({
+        idx,
+        expiresAtBlockTimeSeconds,
+        kind: "pubkey",
+        pubkey: payload.slice(0, 32)
+      });
+      return;
+    }
+    authorities.push({ idx, expiresAtBlockTimeSeconds, kind: "unknown", tag, data: payload });
+  });
+  return { nonce: account.get_nonce(), authorities, layout: "authorityRecord" };
+}
+function parseLegacyWalletNonce(data) {
+  if (data.length < LEGACY_WALLET_HEADER_BYTES) return null;
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  return view.getBigUint64(1, true);
+}
+function parseLegacyWalletAuthorities(data) {
+  if (data.length < LEGACY_WALLET_HEADER_BYTES) return null;
+  const numAuth = data[0];
+  const authorityCount = numAuth + 1;
+  const requiredLength = LEGACY_WALLET_HEADER_BYTES + authorityCount * LEGACY_AUTHORITY_BYTES;
+  if (data.length < requiredLength) return null;
+  const nonce = parseLegacyWalletNonce(data);
+  if (nonce === null) return null;
+  const authorities = [];
+  for (let idx = 0; idx < authorityCount; idx += 1) {
+    const offset = LEGACY_WALLET_HEADER_BYTES + idx * LEGACY_AUTHORITY_BYTES;
     const tag = data[offset];
-    const payload = data.slice(offset + 1, offset + AUTHORITY_ENTRY_BYTES);
+    const payload = data.slice(offset + 1, offset + 1 + AUTHORITY_DATA_BYTES2);
+    const expiresAtBlockTimeSeconds = LONG_LIVED_AUTHORITY_EXPIRY_SECONDS;
     if (tag === 1) {
       authorities.push({
         idx,
+        expiresAtBlockTimeSeconds,
         kind: "passkey",
         x: payload.slice(0, 32),
         y: payload.slice(32, 64)
@@ -7029,12 +7903,17 @@ function parseWalletAuthorities(data) {
       continue;
     }
     if (tag === 2) {
-      authorities.push({ idx, kind: "pubkey", pubkey: payload.slice(0, 32) });
+      authorities.push({
+        idx,
+        expiresAtBlockTimeSeconds,
+        kind: "pubkey",
+        pubkey: payload.slice(0, 32)
+      });
       continue;
     }
-    authorities.push({ idx, kind: "unknown", tag, data: payload });
+    authorities.push({ idx, expiresAtBlockTimeSeconds, kind: "unknown", tag, data: payload });
   }
-  return { nonce, authorities };
+  return { nonce, authorities, layout: "legacyAuthority" };
 }
 function formatAuthorityPubkey(pubkey) {
   return helpers.encodeAddress(pubkey);
@@ -7185,6 +8064,8 @@ Object.defineProperty(exports, "encodeAddress", {
   enumerable: true,
   get: function () { return helpers.encodeAddress; }
 });
+exports.AUTHORITY_BYTES = AUTHORITY_BYTES;
+exports.AUTHORITY_RECORD_BYTES = AUTHORITY_RECORD_BYTES;
 exports.AUTHORITY_TAG_PASSKEY = AUTHORITY_TAG_PASSKEY;
 exports.AUTHORITY_TAG_PUBKEY = AUTHORITY_TAG_PUBKEY;
 exports.FEE_PAYER_ADDRESS = FEE_PAYER_ADDRESS;
@@ -7194,6 +8075,7 @@ exports.INSTRUCTION_REGISTER_CREDENTIAL = INSTRUCTION_REGISTER_CREDENTIAL;
 exports.INSTRUCTION_REMOVE_AUTHORITY = INSTRUCTION_REMOVE_AUTHORITY;
 exports.INSTRUCTION_TRANSFER = INSTRUCTION_TRANSFER;
 exports.INSTRUCTION_VALIDATE = INSTRUCTION_VALIDATE;
+exports.LONG_LIVED_AUTHORITY_EXPIRY_SECONDS = LONG_LIVED_AUTHORITY_EXPIRY_SECONDS;
 exports.P256_HALF_N = P256_HALF_N;
 exports.P256_N = P256_N;
 exports.PASSKEY_MANAGER_PROGRAM_ADDRESS = PASSKEY_MANAGER_PROGRAM_ADDRESS;
@@ -7203,6 +8085,8 @@ exports.base64UrlToArrayBuffer = base64UrlToArrayBuffer;
 exports.base64UrlToBytes = base64UrlToBytes;
 exports.bigIntToBytesBE = bigIntToBytesBE;
 exports.buildAccountContext = buildAccountContext;
+exports.buildAuthority = buildAuthority;
+exports.buildAuthorityRecord = buildAuthorityRecord;
 exports.buildPasskeyReadWriteAccounts = buildPasskeyReadWriteAccounts;
 exports.bytesEqual = bytesEqual;
 exports.bytesToBase64 = bytesToBase64;
@@ -7210,13 +8094,19 @@ exports.bytesToBase64Url = bytesToBase64Url;
 exports.bytesToBigIntBE = bytesToBigIntBE;
 exports.bytesToHex = bytesToHex;
 exports.compareBytes = compareBytes;
+exports.concatenateInstructions = concatenateInstructions;
+exports.createAuthorityRecord = createAuthorityRecord;
 exports.createCredentialLookupSeed = createCredentialLookupSeed;
+exports.createSessionAuthorityRecord = createSessionAuthorityRecord;
 exports.createValidateChallenge = createValidateChallenge;
 exports.createWalletSeed = createWalletSeed;
 exports.deriveCredentialLookupAddress = deriveCredentialLookupAddress;
 exports.deriveWalletAddress = deriveWalletAddress;
 exports.encodeAddAuthorityInstruction = encodeAddAuthorityInstruction;
 exports.encodeCreateInstruction = encodeCreateInstruction;
+exports.encodeInvokeInstruction = encodeInvokeInstruction;
+exports.encodeLegacyAddAuthorityInstruction = encodeLegacyAddAuthorityInstruction;
+exports.encodeLegacyCreateInstruction = encodeLegacyCreateInstruction;
 exports.encodeRegisterCredentialInstruction = encodeRegisterCredentialInstruction;
 exports.encodeRemoveAuthorityInstruction = encodeRemoveAuthorityInstruction;
 exports.encodeTransferInstruction = encodeTransferInstruction;