@thru/passkey-manager 0.2.1 → 0.2.3

package/dist/index.js

@@ -1,11 +1,12 @@
 // src/constants.ts
-var PASSKEY_MANAGER_PROGRAM_ADDRESS = "taNiWOgcxRz2DYI1Vbp6AOMdiEbC9nYwXd02dQJ4jnUUpF";
+var PASSKEY_MANAGER_PROGRAM_ADDRESS = "taUDdQyFxvM5i0HFRkEK3W45kWLyblAHSnMg4zplgUnz6Z";
 var INSTRUCTION_CREATE = 0;
 var INSTRUCTION_VALIDATE = 1;
 var INSTRUCTION_TRANSFER = 2;
 var INSTRUCTION_INVOKE = 3;
 var INSTRUCTION_ADD_AUTHORITY = 4;
 var INSTRUCTION_REMOVE_AUTHORITY = 5;
+var INSTRUCTION_REGISTER_CREDENTIAL = 6;
 var AUTHORITY_TAG_PASSKEY = 1;
 var AUTHORITY_TAG_PUBKEY = 2;
 
@@ -5030,6 +5031,229 @@ var AddAuthorityArgsBuilder = class {
     return view;
   }
 };
+var __tn_ir_CredentialLookup = {
+  typeName: "CredentialLookup",
+  root: { op: "const", value: 32n }
+};
+var CredentialLookup = class _CredentialLookup {
+  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("CredentialLookup.__tnCreateView requires a Uint8Array");
+    return new _CredentialLookup(new Uint8Array(buffer));
+  }
+  static builder() {
+    return new CredentialLookupBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    return _CredentialLookup.from_array(buffer);
+  }
+  get_wallet() {
+    const offset = 0;
+    const slice = this.buffer.subarray(offset, offset + 32);
+    return Pubkey.from_array(slice);
+  }
+  set_wallet(value) {
+    const sourceBytes = value.buffer;
+    const offset = 0;
+    this.buffer.set(sourceBytes, offset);
+  }
+  get wallet() {
+    return this.get_wallet();
+  }
+  set wallet(value) {
+    this.set_wallet(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint3(__tn_ir_CredentialLookup.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree3(__tn_ir_CredentialLookup, 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 CredentialLookup");
+    }
+    return __tnBigIntToNumber3(irResult, "CredentialLookup::footprint");
+  }
+  static validate(buffer, _opts) {
+    if (buffer.length < 32) return { ok: false, code: "tn.buffer_too_small", consumed: 32 };
+    return { ok: true, consumed: 32 };
+  }
+  static from_array(buffer) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const validation = this.validate(buffer);
+    if (!validation.ok) {
+      return null;
+    }
+    return new _CredentialLookup(buffer);
+  }
+};
+__tnRegisterFootprint3("CredentialLookup", (params) => CredentialLookup.__tnInvokeFootprint(params));
+__tnRegisterValidate3("CredentialLookup", (buffer, params) => CredentialLookup.__tnInvokeValidate(buffer, params));
+var CredentialLookupBuilder = class {
+  constructor() {
+    this.buffer = new Uint8Array(32);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  set_wallet(value) {
+    if (value.length !== 32) throw new Error("wallet expects 32 bytes");
+    this.buffer.set(value, 0);
+    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 = CredentialLookup.from_array(this.buffer.slice());
+    if (!view) throw new Error("failed to build CredentialLookup");
+    return view;
+  }
+};
+var __tn_ir_CredentialRegisteredEventData = {
+  typeName: "CredentialRegisteredEventData",
+  root: { op: "const", value: 64n }
+};
+var CredentialRegisteredEventData = class _CredentialRegisteredEventData {
+  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("CredentialRegisteredEventData.__tnCreateView requires a Uint8Array");
+    return new _CredentialRegisteredEventData(new Uint8Array(buffer));
+  }
+  static builder() {
+    return new CredentialRegisteredEventDataBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    return _CredentialRegisteredEventData.from_array(buffer);
+  }
+  get_wallet() {
+    const offset = 0;
+    const slice = this.buffer.subarray(offset, offset + 32);
+    return Pubkey.from_array(slice);
+  }
+  set_wallet(value) {
+    const sourceBytes = value.buffer;
+    const offset = 0;
+    this.buffer.set(sourceBytes, offset);
+  }
+  get wallet() {
+    return this.get_wallet();
+  }
+  set wallet(value) {
+    this.set_wallet(value);
+  }
+  get_lookup() {
+    const offset = 32;
+    const slice = this.buffer.subarray(offset, offset + 32);
+    return Pubkey.from_array(slice);
+  }
+  set_lookup(value) {
+    const sourceBytes = value.buffer;
+    const offset = 32;
+    this.buffer.set(sourceBytes, offset);
+  }
+  get lookup() {
+    return this.get_lookup();
+  }
+  set lookup(value) {
+    this.set_lookup(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint3(__tn_ir_CredentialRegisteredEventData.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree3(__tn_ir_CredentialRegisteredEventData, 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 CredentialRegisteredEventData");
+    }
+    return __tnBigIntToNumber3(irResult, "CredentialRegisteredEventData::footprint");
+  }
+  static validate(buffer, _opts) {
+    if (buffer.length < 64) return { ok: false, code: "tn.buffer_too_small", consumed: 64 };
+    return { ok: true, consumed: 64 };
+  }
+  static from_array(buffer) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const validation = this.validate(buffer);
+    if (!validation.ok) {
+      return null;
+    }
+    return new _CredentialRegisteredEventData(buffer);
+  }
+};
+__tnRegisterFootprint3("CredentialRegisteredEventData", (params) => CredentialRegisteredEventData.__tnInvokeFootprint(params));
+__tnRegisterValidate3("CredentialRegisteredEventData", (buffer, params) => CredentialRegisteredEventData.__tnInvokeValidate(buffer, params));
+var CredentialRegisteredEventDataBuilder = class {
+  constructor() {
+    this.buffer = new Uint8Array(64);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  set_wallet(value) {
+    if (value.length !== 32) throw new Error("wallet expects 32 bytes");
+    this.buffer.set(value, 0);
+    return this;
+  }
+  set_lookup(value) {
+    if (value.length !== 32) throw new Error("lookup expects 32 bytes");
+    this.buffer.set(value, 32);
+    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 = CredentialRegisteredEventData.from_array(this.buffer.slice());
+    if (!view) throw new Error("failed to build CredentialRegisteredEventData");
+    return view;
+  }
+};
 var __tn_ir_InvokeArgs = {
   typeName: "InvokeArgs",
   root: { op: "align", alignment: 1, node: { op: "add", left: { op: "add", left: { op: "align", alignment: 1, node: { op: "const", value: 32n } }, right: { op: "align", alignment: 2, node: { op: "const", value: 2n } } }, right: { op: "align", alignment: 1, node: { op: "mul", left: { op: "field", param: "instr.instr_len" }, right: { op: "const", value: 1n } } } } }
@@ -5370,7 +5594,7 @@ var InvokeArgsBuilder = class {
 };
 var __tn_ir_PasskeyEvent = {
   typeName: "PasskeyEvent",
-  root: { op: "align", alignment: 1, node: { op: "add", left: { op: "align", alignment: 1, node: { op: "const", value: 1n } }, right: { op: "align", alignment: 1, node: { op: "switch", tag: "PasskeyEvent::payload.event_type", cases: [{ value: 0, node: { op: "align", alignment: 1, node: { op: "const", value: 97n } } }, { value: 1, node: { op: "align", alignment: 1, node: { op: "const", value: 40n } } }, { value: 2, node: { op: "align", alignment: 1, node: { op: "const", value: 72n } } }] } } } }
+  root: { op: "align", alignment: 1, node: { op: "add", left: { op: "align", alignment: 1, node: { op: "const", value: 1n } }, right: { op: "align", alignment: 1, node: { op: "switch", tag: "PasskeyEvent::payload.event_type", cases: [{ value: 0, node: { op: "align", alignment: 1, node: { op: "const", value: 97n } } }, { value: 1, node: { op: "align", alignment: 1, node: { op: "const", value: 40n } } }, { value: 2, node: { op: "align", alignment: 1, node: { op: "const", value: 72n } } }, { value: 3, node: { op: "align", alignment: 1, node: { op: "const", value: 64n } } }] } } } }
 };
 var PasskeyEvent_payload_Inner = class _PasskeyEvent_payload_Inner {
   constructor(buffer, descriptor, fieldContext) {
@@ -5401,6 +5625,10 @@ var PasskeyEvent_payload_Inner = class _PasskeyEvent_payload_Inner {
     if (!this.descriptor || this.descriptor.tag !== 2) return null;
     return WalletTransferEventData.__tnCreateView(new Uint8Array(this.buffer), { fieldContext: this.__tnFieldContext ?? void 0 });
   }
+  asCredentialRegistered() {
+    if (!this.descriptor || this.descriptor.tag !== 3) return null;
+    return CredentialRegisteredEventData.__tnCreateView(new Uint8Array(this.buffer), { fieldContext: this.__tnFieldContext ?? void 0 });
+  }
 };
 var _PasskeyEvent = class _PasskeyEvent {
   constructor(buffer, params) {
@@ -5579,6 +5807,13 @@ _PasskeyEvent.payloadVariantDescriptors = Object.freeze([
     payloadSize: 72,
     payloadType: "PasskeyEvent::payload::wallet_transfer",
     createPayloadBuilder: () => __tnMaybeCallBuilder(WalletTransferEventData)
+  },
+  {
+    name: "credential_registered",
+    tag: 3,
+    payloadSize: 64,
+    payloadType: "PasskeyEvent::payload::credential_registered",
+    createPayloadBuilder: () => __tnMaybeCallBuilder(CredentialRegisteredEventData)
   }
 ]);
 var PasskeyEvent = _PasskeyEvent;
@@ -5926,6 +6161,221 @@ var CreateArgsBuilder = class {
     }
   }
 };
+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) {
+    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("RegisterCredentialArgs.__tnCreateView requires a Uint8Array");
+    return new _RegisterCredentialArgs(new Uint8Array(buffer));
+  }
+  static builder() {
+    return new RegisterCredentialArgsBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    return _RegisterCredentialArgs.from_array(buffer);
+  }
+  get_wallet_account_idx() {
+    const offset = 0;
+    return this.view.getUint16(offset, true);
+  }
+  set_wallet_account_idx(value) {
+    const offset = 0;
+    this.view.setUint16(offset, value, true);
+  }
+  get wallet_account_idx() {
+    return this.get_wallet_account_idx();
+  }
+  set wallet_account_idx(value) {
+    this.set_wallet_account_idx(value);
+  }
+  get_lookup_account_idx() {
+    const offset = 2;
+    return this.view.getUint16(offset, true);
+  }
+  set_lookup_account_idx(value) {
+    const offset = 2;
+    this.view.setUint16(offset, value, true);
+  }
+  get lookup_account_idx() {
+    return this.get_lookup_account_idx();
+  }
+  set lookup_account_idx(value) {
+    this.set_lookup_account_idx(value);
+  }
+  get_seed() {
+    const offset = 4;
+    const slice = this.buffer.subarray(offset, offset + 32);
+    return Seed32.from_array(slice);
+  }
+  set_seed(value) {
+    const sourceBytes = value.buffer;
+    const offset = 4;
+    this.buffer.set(sourceBytes, offset);
+  }
+  get seed() {
+    return this.get_seed();
+  }
+  set seed(value) {
+    this.set_seed(value);
+  }
+  get_state_proof() {
+    const offset = 36;
+    const tail = this.buffer.subarray(offset);
+    const validation = StateProof.validate(tail);
+    if (!validation.ok || validation.consumed === void 0) {
+      throw new Error("RegisterCredentialArgs: failed to read field 'state_proof' (invalid nested payload)");
+    }
+    const length = validation.consumed;
+    const slice = tail.subarray(0, length);
+    const opts = validation.params ? { params: validation.params } : void 0;
+    return StateProof.from_array(slice, opts);
+  }
+  set_state_proof(value) {
+    const sourceBytes = value.buffer;
+    const offset = 36;
+    this.buffer.set(sourceBytes, offset);
+  }
+  get state_proof() {
+    return this.get_state_proof();
+  }
+  set state_proof(value) {
+    this.set_state_proof(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint3(__tn_ir_RegisterCredentialArgs.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree3(__tn_ir_RegisterCredentialArgs, 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 RegisterCredentialArgs");
+    }
+    return __tnBigIntToNumber3(irResult, "RegisterCredentialArgs::footprint");
+  }
+  static validate(_buffer, _opts) {
+    __tnLogWarn3("RegisterCredentialArgs::validate falling back to basic length check");
+    return { ok: true, consumed: _buffer.length };
+  }
+  static from_array(buffer) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const validation = this.validate(buffer);
+    if (!validation.ok) {
+      return null;
+    }
+    return new _RegisterCredentialArgs(buffer);
+  }
+};
+__tnRegisterFootprint3("RegisterCredentialArgs", (params) => RegisterCredentialArgs.__tnInvokeFootprint(params));
+__tnRegisterValidate3("RegisterCredentialArgs", (buffer, params) => RegisterCredentialArgs.__tnInvokeValidate(buffer, params));
+var RegisterCredentialArgsBuilder = class {
+  constructor() {
+    this.__tnTail_state_proof = null;
+    this.buffer = new Uint8Array(36);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  __tnInvalidate() {
+  }
+  set_wallet_account_idx(value) {
+    this.view.setUint16(0, value, true);
+    this.__tnInvalidate();
+    return this;
+  }
+  set_lookup_account_idx(value) {
+    this.view.setUint16(2, value, true);
+    this.__tnInvalidate();
+    return this;
+  }
+  set_seed(value) {
+    if (value.length !== 32) throw new Error("seed expects 32 bytes");
+    this.buffer.set(value, 4);
+    this.__tnInvalidate();
+    return this;
+  }
+  set_state_proof(value) {
+    const bytes = __tnResolveStructFieldInput(value, "RegisterCredentialArgsBuilder::state_proof");
+    this.__tnTail_state_proof = bytes;
+    this.__tnInvalidate();
+    return this;
+  }
+  build() {
+    const fragments = this.__tnCollectTailFragments();
+    const size = this.__tnComputeSize(fragments);
+    const buffer = new Uint8Array(size);
+    this.__tnWriteInto(buffer, fragments);
+    this.__tnValidateOrThrow(buffer);
+    return buffer;
+  }
+  buildInto(target, offset = 0) {
+    const fragments = this.__tnCollectTailFragments();
+    const size = this.__tnComputeSize(fragments);
+    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);
+    return target;
+  }
+  finish() {
+    const buffer = this.build();
+    const view = RegisterCredentialArgs.from_array(buffer);
+    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;
+      })()
+    ];
+  }
+  __tnComputeSize(fragments) {
+    let total = this.buffer.length;
+    for (const fragment of fragments) {
+      total += fragment.length;
+    }
+    return total;
+  }
+  __tnWriteInto(target, fragments) {
+    target.set(this.buffer, 0);
+    let cursor = this.buffer.length;
+    for (const fragment of fragments) {
+      target.set(fragment, cursor);
+      cursor += fragment.length;
+    }
+  }
+  __tnValidateOrThrow(buffer) {
+    const result = RegisterCredentialArgs.validate(buffer);
+    if (!result.ok) {
+      throw new Error(`RegisterCredentialArgsBuilder: builder produced invalid buffer (code=${result.code ?? "unknown"})`);
+    }
+  }
+};
 var __tn_ir_PasskeyInstruction = {
   typeName: "PasskeyInstruction",
   root: { op: "align", alignment: 1, node: { op: "add", left: { op: "align", alignment: 1, node: { op: "const", value: 1n } }, right: { op: "align", alignment: 1, node: { op: "field", param: "payload.payload_size" } } } }
@@ -5971,6 +6421,10 @@ var PasskeyInstruction_payload_Inner = class _PasskeyInstruction_payload_Inner {
     if (!this.descriptor || this.descriptor.tag !== 5) return null;
     return RemoveAuthorityArgs.__tnCreateView(new Uint8Array(this.buffer), { fieldContext: this.__tnFieldContext ?? void 0 });
   }
+  asRegisterCredential() {
+    if (!this.descriptor || this.descriptor.tag !== 6) return null;
+    return RegisterCredentialArgs.__tnCreateView(new Uint8Array(this.buffer), { fieldContext: this.__tnFieldContext ?? void 0 });
+  }
 };
 var _PasskeyInstruction = class _PasskeyInstruction {
   constructor(buffer, params) {
@@ -6034,6 +6488,8 @@ var _PasskeyInstruction = class _PasskeyInstruction {
         break;
       case 5:
         break;
+      case 6:
+        break;
       default:
         return null;
     }
@@ -6214,6 +6670,13 @@ _PasskeyInstruction.payloadVariantDescriptors = Object.freeze([
     payloadSize: 1,
     payloadType: "PasskeyInstruction::payload::remove_authority",
     createPayloadBuilder: () => __tnMaybeCallBuilder(RemoveAuthorityArgs)
+  },
+  {
+    name: "register_credential",
+    tag: 6,
+    payloadSize: null,
+    payloadType: "PasskeyInstruction::payload::register_credential",
+    createPayloadBuilder: () => __tnMaybeCallBuilder(RegisterCredentialArgs)
   }
 ]);
 var PasskeyInstruction = _PasskeyInstruction;
@@ -6429,6 +6892,20 @@ function encodeRemoveAuthorityInstruction(params) {
   return new PasskeyInstructionBuilder().payload().select("remove_authority").writePayload(argsPayload).finish().build();
 }
 
+// src/instructions/register-credential.ts
+function encodeRegisterCredentialInstruction(params) {
+  const { walletAccountIdx, lookupAccountIdx, 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");
+  }
+  if (lookupAccountIdx < 0 || lookupAccountIdx > 65535) {
+    throw new Error("lookupAccountIdx must be 0-65535");
+  }
+  const argsPayload = new RegisterCredentialArgsBuilder().set_wallet_account_idx(walletAccountIdx).set_lookup_account_idx(lookupAccountIdx).set_seed(seed).set_state_proof(stateProof).build();
+  return new PasskeyInstructionBuilder().payload().select("register_credential").writePayload(argsPayload).finish().build();
+}
+
 // src/instructions/shared.ts
 function concatenateInstructions(instructions) {
   const totalLength = instructions.reduce((sum, instr) => sum + instr.length, 0);
@@ -6491,6 +6968,18 @@ async function deriveWalletAddress(seed, programAddress) {
   const hashBuffer = await crypto.subtle.digest("SHA-256", preimage);
   return new Uint8Array(hashBuffer);
 }
+async function createCredentialLookupSeed(credentialId, walletName) {
+  const nameBytes = new TextEncoder().encode(walletName);
+  const data = new Uint8Array(credentialId.length + nameBytes.length);
+  data.set(credentialId, 0);
+  data.set(nameBytes, credentialId.length);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  return new Uint8Array(hashBuffer);
+}
+async function deriveCredentialLookupAddress(credentialId, walletName, programAddress) {
+  const seed = await createCredentialLookupSeed(credentialId, walletName);
+  return deriveWalletAddress(seed, programAddress);
+}
 
 // src/context.ts
 import { encodeAddress, decodeAddress as decodeAddress2 } from "@thru/helpers";
@@ -6696,6 +7185,7 @@ export {
   INSTRUCTION_ADD_AUTHORITY,
   INSTRUCTION_CREATE,
   INSTRUCTION_INVOKE,
+  INSTRUCTION_REGISTER_CREDENTIAL,
   INSTRUCTION_REMOVE_AUTHORITY,
   INSTRUCTION_TRANSFER,
   INSTRUCTION_VALIDATE,
@@ -6714,12 +7204,15 @@ export {
   bytesToHex,
   compareBytes,
   concatenateInstructions,
+  createCredentialLookupSeed,
   createValidateChallenge,
   createWalletSeed,
+  deriveCredentialLookupAddress,
   deriveWalletAddress,
   encodeAddAuthorityInstruction,
   encodeCreateInstruction,
   encodeInvokeInstruction,
+  encodeRegisterCredentialInstruction,
   encodeRemoveAuthorityInstruction,
   encodeTransferInstruction,
   encodeValidateInstruction,