@qorechain/sdk 0.6.0 → 0.7.0

package/dist/index.cjs

@@ -278,6 +278,35 @@ var RestClient = class {
   getInflationRate() {
     return this.get("/qorechain/inflation/v1/rate");
   }
+  // --- Abstract-account authenticator lanes (v3.1.85) ----------------------
+  /**
+   * The canonical authenticator permission taxonomy
+   * (`/qorechain/abstractaccount/v1/permission_schema`): the valid permission
+   * strings, the message-typeURL→permission mapping, the never-delegable
+   * key-management typeURLs, and a `schema_version` for drift detection.
+   */
+  getPermissionSchema() {
+    return this.get(
+      "/qorechain/abstractaccount/v1/permission_schema"
+    );
+  }
+  /** Abstract-account module config (`/qorechain/abstractaccount/v1/config`). */
+  getAbstractAccountConfig() {
+    return this.get("/qorechain/abstractaccount/v1/config");
+  }
+  /** All abstract accounts (`/qorechain/abstractaccount/v1/accounts`). */
+  getAbstractAccounts() {
+    return this.get("/qorechain/abstractaccount/v1/accounts");
+  }
+  /**
+   * A single abstract account by address
+   * (`/qorechain/abstractaccount/v1/accounts/{address}`).
+   */
+  getAbstractAccount(address) {
+    return this.get(
+      `/qorechain/abstractaccount/v1/accounts/${encodeURIComponent(address)}`
+    );
+  }
 };
 
 // src/query/jsonrpc.ts
@@ -5751,6 +5780,8 @@ __export(tx_exports5, {
   MsgRegisterPQCKeyResponse: () => MsgRegisterPQCKeyResponse,
   MsgRegisterPQCKeyV2: () => MsgRegisterPQCKeyV2,
   MsgRegisterPQCKeyV2Response: () => MsgRegisterPQCKeyV2Response,
+  MsgRotatePQCKey: () => MsgRotatePQCKey,
+  MsgRotatePQCKeyResponse: () => MsgRotatePQCKeyResponse,
   protobufPackage: () => protobufPackage5
 });
 var protobufPackage5 = "qorechain.pqc.v1";
@@ -6205,6 +6236,160 @@ var MsgMigratePQCKeyResponse = {
     return message;
   }
 };
+function createBaseMsgRotatePQCKey() {
+  return {
+    sender: "",
+    oldPublicKey: new Uint8Array(0),
+    newPublicKey: new Uint8Array(0),
+    oldSignature: new Uint8Array(0),
+    newSignature: new Uint8Array(0)
+  };
+}
+var MsgRotatePQCKey = {
+  encode(message, writer = new wire.BinaryWriter()) {
+    if (message.sender !== "") {
+      writer.uint32(10).string(message.sender);
+    }
+    if (message.oldPublicKey.length !== 0) {
+      writer.uint32(18).bytes(message.oldPublicKey);
+    }
+    if (message.newPublicKey.length !== 0) {
+      writer.uint32(26).bytes(message.newPublicKey);
+    }
+    if (message.oldSignature.length !== 0) {
+      writer.uint32(34).bytes(message.oldSignature);
+    }
+    if (message.newSignature.length !== 0) {
+      writer.uint32(42).bytes(message.newSignature);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMsgRotatePQCKey();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.sender = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.oldPublicKey = reader.bytes();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.newPublicKey = reader.bytes();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.oldSignature = reader.bytes();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.newSignature = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      sender: isSet6(object.sender) ? globalThis.String(object.sender) : "",
+      oldPublicKey: isSet6(object.oldPublicKey) ? bytesFromBase644(object.oldPublicKey) : isSet6(object.old_public_key) ? bytesFromBase644(object.old_public_key) : new Uint8Array(0),
+      newPublicKey: isSet6(object.newPublicKey) ? bytesFromBase644(object.newPublicKey) : isSet6(object.new_public_key) ? bytesFromBase644(object.new_public_key) : new Uint8Array(0),
+      oldSignature: isSet6(object.oldSignature) ? bytesFromBase644(object.oldSignature) : isSet6(object.old_signature) ? bytesFromBase644(object.old_signature) : new Uint8Array(0),
+      newSignature: isSet6(object.newSignature) ? bytesFromBase644(object.newSignature) : isSet6(object.new_signature) ? bytesFromBase644(object.new_signature) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.sender !== "") {
+      obj.sender = message.sender;
+    }
+    if (message.oldPublicKey.length !== 0) {
+      obj.oldPublicKey = base64FromBytes4(message.oldPublicKey);
+    }
+    if (message.newPublicKey.length !== 0) {
+      obj.newPublicKey = base64FromBytes4(message.newPublicKey);
+    }
+    if (message.oldSignature.length !== 0) {
+      obj.oldSignature = base64FromBytes4(message.oldSignature);
+    }
+    if (message.newSignature.length !== 0) {
+      obj.newSignature = base64FromBytes4(message.newSignature);
+    }
+    return obj;
+  },
+  create(base) {
+    return MsgRotatePQCKey.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMsgRotatePQCKey();
+    message.sender = object.sender ?? "";
+    message.oldPublicKey = object.oldPublicKey ?? new Uint8Array(0);
+    message.newPublicKey = object.newPublicKey ?? new Uint8Array(0);
+    message.oldSignature = object.oldSignature ?? new Uint8Array(0);
+    message.newSignature = object.newSignature ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseMsgRotatePQCKeyResponse() {
+  return {};
+}
+var MsgRotatePQCKeyResponse = {
+  encode(_, writer = new wire.BinaryWriter()) {
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMsgRotatePQCKeyResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(_) {
+    return {};
+  },
+  toJSON(_) {
+    const obj = {};
+    return obj;
+  },
+  create(base) {
+    return MsgRotatePQCKeyResponse.fromPartial(base ?? {});
+  },
+  fromPartial(_) {
+    const message = createBaseMsgRotatePQCKeyResponse();
+    return message;
+  }
+};
 function createBaseMsgDeprecateAlgorithm() {
   return { authority: "", algorithmId: 0, migrationBlocks: "0", replacementAlgorithmId: 0 };
 }
@@ -6487,6 +6672,20 @@ var MsgDefinition5 = {
       responseStream: false,
       options: {}
     },
+    /**
+     * RotatePQCKey replaces an account's PQC key with a NEW key of the SAME
+     * algorithm — for rotating a compromised key or moving a legacy-derived key to
+     * the canonical derivation. Dual-signed (old proves ownership, new proves
+     * control); needs no active algorithm migration.
+     */
+    rotatePQCKey: {
+      name: "RotatePQCKey",
+      requestType: MsgRotatePQCKey,
+      requestStream: false,
+      responseType: MsgRotatePQCKeyResponse,
+      responseStream: false,
+      options: {}
+    },
     /** DeprecateAlgorithm starts the migration period for an algorithm (governance). */
     deprecateAlgorithm: {
       name: "DeprecateAlgorithm",
@@ -8361,6 +8560,10 @@ __export(tx_exports9, {
   MsgCreateAbstractAccount: () => MsgCreateAbstractAccount,
   MsgCreateAbstractAccountResponse: () => MsgCreateAbstractAccountResponse,
   MsgDefinition: () => MsgDefinition9,
+  MsgExecuteCosmos: () => MsgExecuteCosmos,
+  MsgExecuteCosmosResponse: () => MsgExecuteCosmosResponse,
+  MsgExecuteEVM: () => MsgExecuteEVM,
+  MsgExecuteEVMResponse: () => MsgExecuteEVMResponse,
   MsgRegisterAuthenticator: () => MsgRegisterAuthenticator,
   MsgRegisterAuthenticatorResponse: () => MsgRegisterAuthenticatorResponse,
   MsgRevokeAuthenticator: () => MsgRevokeAuthenticator,
@@ -9040,95 +9243,626 @@ var MsgRevokeAuthenticatorResponse = {
     return message;
   }
 };
-var MsgDefinition9 = {
-  name: "Msg",
-  fullName: "qorechain.abstractaccount.v1.Msg",
-  methods: {
-    createAbstractAccount: {
-      name: "CreateAbstractAccount",
-      requestType: MsgCreateAbstractAccount,
-      requestStream: false,
-      responseType: MsgCreateAbstractAccountResponse,
-      responseStream: false,
-      options: {}
-    },
-    updateSpendingRules: {
-      name: "UpdateSpendingRules",
-      requestType: MsgUpdateSpendingRules,
-      requestStream: false,
-      responseType: MsgUpdateSpendingRulesResponse,
-      responseStream: false,
-      options: {}
-    },
-    registerAuthenticator: {
-      name: "RegisterAuthenticator",
-      requestType: MsgRegisterAuthenticator,
-      requestStream: false,
-      responseType: MsgRegisterAuthenticatorResponse,
-      responseStream: false,
-      options: {}
-    },
-    revokeAuthenticator: {
-      name: "RevokeAuthenticator",
-      requestType: MsgRevokeAuthenticator,
-      requestStream: false,
-      responseType: MsgRevokeAuthenticatorResponse,
-      responseStream: false,
-      options: {}
-    }
-  }
-};
-function bytesFromBase646(b64) {
-  if (globalThis.Buffer) {
-    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
-  } else {
-    const bin = globalThis.atob(b64);
-    const arr = new Uint8Array(bin.length);
-    for (let i = 0; i < bin.length; ++i) {
-      arr[i] = bin.charCodeAt(i);
-    }
-    return arr;
-  }
-}
-function base64FromBytes6(arr) {
-  if (globalThis.Buffer) {
-    return globalThis.Buffer.from(arr).toString("base64");
-  } else {
-    const bin = [];
-    arr.forEach((byte) => {
-      bin.push(globalThis.String.fromCharCode(byte));
-    });
-    return globalThis.btoa(bin.join(""));
-  }
-}
-function isSet10(value) {
-  return value !== null && value !== void 0;
-}
-
-// src/codegen/qorechain/crossvm/v1/tx.ts
-var tx_exports10 = {};
-__export(tx_exports10, {
-  MsgCrossVMCall: () => MsgCrossVMCall,
-  MsgCrossVMCallResponse: () => MsgCrossVMCallResponse,
-  MsgDefinition: () => MsgDefinition10,
-  MsgProcessQueue: () => MsgProcessQueue,
-  MsgProcessQueueResponse: () => MsgProcessQueueResponse,
-  protobufPackage: () => protobufPackage10
-});
-var protobufPackage10 = "qorechain.crossvm.v1";
-function createBaseMsgCrossVMCall() {
-  return { sender: "", sourceVm: "", targetVm: "", targetContract: "", payload: new Uint8Array(0), funds: [] };
+function createBaseMsgExecuteEVM() {
+  return {
+    relayer: "",
+    account: "",
+    scheme: "",
+    pubkey: new Uint8Array(0),
+    signature: new Uint8Array(0),
+    to: "",
+    value: "",
+    data: new Uint8Array(0),
+    gasLimit: "0",
+    nonce: "0"
+  };
 }
-var MsgCrossVMCall = {
+var MsgExecuteEVM = {
   encode(message, writer = new wire.BinaryWriter()) {
-    if (message.sender !== "") {
-      writer.uint32(10).string(message.sender);
+    if (message.relayer !== "") {
+      writer.uint32(10).string(message.relayer);
     }
-    if (message.sourceVm !== "") {
-      writer.uint32(18).string(message.sourceVm);
+    if (message.account !== "") {
+      writer.uint32(18).string(message.account);
     }
-    if (message.targetVm !== "") {
-      writer.uint32(26).string(message.targetVm);
+    if (message.scheme !== "") {
+      writer.uint32(26).string(message.scheme);
+    }
+    if (message.pubkey.length !== 0) {
+      writer.uint32(34).bytes(message.pubkey);
+    }
+    if (message.signature.length !== 0) {
+      writer.uint32(42).bytes(message.signature);
+    }
+    if (message.to !== "") {
+      writer.uint32(50).string(message.to);
+    }
+    if (message.value !== "") {
+      writer.uint32(58).string(message.value);
+    }
+    if (message.data.length !== 0) {
+      writer.uint32(66).bytes(message.data);
+    }
+    if (message.gasLimit !== "0") {
+      writer.uint32(72).uint64(message.gasLimit);
+    }
+    if (message.nonce !== "0") {
+      writer.uint32(80).uint64(message.nonce);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMsgExecuteEVM();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.relayer = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.account = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.scheme = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.pubkey = reader.bytes();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.signature = reader.bytes();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.to = reader.string();
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.value = reader.string();
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+          message.data = reader.bytes();
+          continue;
+        }
+        case 9: {
+          if (tag !== 72) {
+            break;
+          }
+          message.gasLimit = reader.uint64().toString();
+          continue;
+        }
+        case 10: {
+          if (tag !== 80) {
+            break;
+          }
+          message.nonce = reader.uint64().toString();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      relayer: isSet10(object.relayer) ? globalThis.String(object.relayer) : "",
+      account: isSet10(object.account) ? globalThis.String(object.account) : "",
+      scheme: isSet10(object.scheme) ? globalThis.String(object.scheme) : "",
+      pubkey: isSet10(object.pubkey) ? bytesFromBase646(object.pubkey) : new Uint8Array(0),
+      signature: isSet10(object.signature) ? bytesFromBase646(object.signature) : new Uint8Array(0),
+      to: isSet10(object.to) ? globalThis.String(object.to) : "",
+      value: isSet10(object.value) ? globalThis.String(object.value) : "",
+      data: isSet10(object.data) ? bytesFromBase646(object.data) : new Uint8Array(0),
+      gasLimit: isSet10(object.gasLimit) ? globalThis.String(object.gasLimit) : isSet10(object.gas_limit) ? globalThis.String(object.gas_limit) : "0",
+      nonce: isSet10(object.nonce) ? globalThis.String(object.nonce) : "0"
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.relayer !== "") {
+      obj.relayer = message.relayer;
+    }
+    if (message.account !== "") {
+      obj.account = message.account;
+    }
+    if (message.scheme !== "") {
+      obj.scheme = message.scheme;
+    }
+    if (message.pubkey.length !== 0) {
+      obj.pubkey = base64FromBytes6(message.pubkey);
+    }
+    if (message.signature.length !== 0) {
+      obj.signature = base64FromBytes6(message.signature);
+    }
+    if (message.to !== "") {
+      obj.to = message.to;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    if (message.data.length !== 0) {
+      obj.data = base64FromBytes6(message.data);
+    }
+    if (message.gasLimit !== "0") {
+      obj.gasLimit = message.gasLimit;
+    }
+    if (message.nonce !== "0") {
+      obj.nonce = message.nonce;
+    }
+    return obj;
+  },
+  create(base) {
+    return MsgExecuteEVM.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMsgExecuteEVM();
+    message.relayer = object.relayer ?? "";
+    message.account = object.account ?? "";
+    message.scheme = object.scheme ?? "";
+    message.pubkey = object.pubkey ?? new Uint8Array(0);
+    message.signature = object.signature ?? new Uint8Array(0);
+    message.to = object.to ?? "";
+    message.value = object.value ?? "";
+    message.data = object.data ?? new Uint8Array(0);
+    message.gasLimit = object.gasLimit ?? "0";
+    message.nonce = object.nonce ?? "0";
+    return message;
+  }
+};
+function createBaseMsgExecuteEVMResponse() {
+  return { success: false, ret: new Uint8Array(0), gasUsed: "0", vmError: "" };
+}
+var MsgExecuteEVMResponse = {
+  encode(message, writer = new wire.BinaryWriter()) {
+    if (message.success !== false) {
+      writer.uint32(8).bool(message.success);
+    }
+    if (message.ret.length !== 0) {
+      writer.uint32(18).bytes(message.ret);
+    }
+    if (message.gasUsed !== "0") {
+      writer.uint32(24).uint64(message.gasUsed);
+    }
+    if (message.vmError !== "") {
+      writer.uint32(34).string(message.vmError);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMsgExecuteEVMResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.success = reader.bool();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.ret = reader.bytes();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.gasUsed = reader.uint64().toString();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.vmError = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      success: isSet10(object.success) ? globalThis.Boolean(object.success) : false,
+      ret: isSet10(object.ret) ? bytesFromBase646(object.ret) : new Uint8Array(0),
+      gasUsed: isSet10(object.gasUsed) ? globalThis.String(object.gasUsed) : isSet10(object.gas_used) ? globalThis.String(object.gas_used) : "0",
+      vmError: isSet10(object.vmError) ? globalThis.String(object.vmError) : isSet10(object.vm_error) ? globalThis.String(object.vm_error) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.success !== false) {
+      obj.success = message.success;
+    }
+    if (message.ret.length !== 0) {
+      obj.ret = base64FromBytes6(message.ret);
+    }
+    if (message.gasUsed !== "0") {
+      obj.gasUsed = message.gasUsed;
+    }
+    if (message.vmError !== "") {
+      obj.vmError = message.vmError;
+    }
+    return obj;
+  },
+  create(base) {
+    return MsgExecuteEVMResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMsgExecuteEVMResponse();
+    message.success = object.success ?? false;
+    message.ret = object.ret ?? new Uint8Array(0);
+    message.gasUsed = object.gasUsed ?? "0";
+    message.vmError = object.vmError ?? "";
+    return message;
+  }
+};
+function createBaseMsgExecuteCosmos() {
+  return {
+    relayer: "",
+    account: "",
+    scheme: "",
+    pubkey: new Uint8Array(0),
+    signature: new Uint8Array(0),
+    to: "",
+    amount: [],
+    nonce: "0"
+  };
+}
+var MsgExecuteCosmos = {
+  encode(message, writer = new wire.BinaryWriter()) {
+    if (message.relayer !== "") {
+      writer.uint32(10).string(message.relayer);
+    }
+    if (message.account !== "") {
+      writer.uint32(18).string(message.account);
+    }
+    if (message.scheme !== "") {
+      writer.uint32(26).string(message.scheme);
+    }
+    if (message.pubkey.length !== 0) {
+      writer.uint32(34).bytes(message.pubkey);
+    }
+    if (message.signature.length !== 0) {
+      writer.uint32(42).bytes(message.signature);
+    }
+    if (message.to !== "") {
+      writer.uint32(50).string(message.to);
+    }
+    for (const v of message.amount) {
+      Coin.encode(v, writer.uint32(58).fork()).join();
+    }
+    if (message.nonce !== "0") {
+      writer.uint32(64).uint64(message.nonce);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMsgExecuteCosmos();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.relayer = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.account = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.scheme = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.pubkey = reader.bytes();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.signature = reader.bytes();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.to = reader.string();
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.amount.push(Coin.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 8: {
+          if (tag !== 64) {
+            break;
+          }
+          message.nonce = reader.uint64().toString();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      relayer: isSet10(object.relayer) ? globalThis.String(object.relayer) : "",
+      account: isSet10(object.account) ? globalThis.String(object.account) : "",
+      scheme: isSet10(object.scheme) ? globalThis.String(object.scheme) : "",
+      pubkey: isSet10(object.pubkey) ? bytesFromBase646(object.pubkey) : new Uint8Array(0),
+      signature: isSet10(object.signature) ? bytesFromBase646(object.signature) : new Uint8Array(0),
+      to: isSet10(object.to) ? globalThis.String(object.to) : "",
+      amount: globalThis.Array.isArray(object?.amount) ? object.amount.map((e) => Coin.fromJSON(e)) : [],
+      nonce: isSet10(object.nonce) ? globalThis.String(object.nonce) : "0"
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.relayer !== "") {
+      obj.relayer = message.relayer;
+    }
+    if (message.account !== "") {
+      obj.account = message.account;
+    }
+    if (message.scheme !== "") {
+      obj.scheme = message.scheme;
+    }
+    if (message.pubkey.length !== 0) {
+      obj.pubkey = base64FromBytes6(message.pubkey);
+    }
+    if (message.signature.length !== 0) {
+      obj.signature = base64FromBytes6(message.signature);
+    }
+    if (message.to !== "") {
+      obj.to = message.to;
+    }
+    if (message.amount?.length) {
+      obj.amount = message.amount.map((e) => Coin.toJSON(e));
+    }
+    if (message.nonce !== "0") {
+      obj.nonce = message.nonce;
+    }
+    return obj;
+  },
+  create(base) {
+    return MsgExecuteCosmos.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMsgExecuteCosmos();
+    message.relayer = object.relayer ?? "";
+    message.account = object.account ?? "";
+    message.scheme = object.scheme ?? "";
+    message.pubkey = object.pubkey ?? new Uint8Array(0);
+    message.signature = object.signature ?? new Uint8Array(0);
+    message.to = object.to ?? "";
+    message.amount = object.amount?.map((e) => Coin.fromPartial(e)) || [];
+    message.nonce = object.nonce ?? "0";
+    return message;
+  }
+};
+function createBaseMsgExecuteCosmosResponse() {
+  return { success: false };
+}
+var MsgExecuteCosmosResponse = {
+  encode(message, writer = new wire.BinaryWriter()) {
+    if (message.success !== false) {
+      writer.uint32(8).bool(message.success);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMsgExecuteCosmosResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.success = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { success: isSet10(object.success) ? globalThis.Boolean(object.success) : false };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.success !== false) {
+      obj.success = message.success;
+    }
+    return obj;
+  },
+  create(base) {
+    return MsgExecuteCosmosResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMsgExecuteCosmosResponse();
+    message.success = object.success ?? false;
+    return message;
+  }
+};
+var MsgDefinition9 = {
+  name: "Msg",
+  fullName: "qorechain.abstractaccount.v1.Msg",
+  methods: {
+    createAbstractAccount: {
+      name: "CreateAbstractAccount",
+      requestType: MsgCreateAbstractAccount,
+      requestStream: false,
+      responseType: MsgCreateAbstractAccountResponse,
+      responseStream: false,
+      options: {}
+    },
+    updateSpendingRules: {
+      name: "UpdateSpendingRules",
+      requestType: MsgUpdateSpendingRules,
+      requestStream: false,
+      responseType: MsgUpdateSpendingRulesResponse,
+      responseStream: false,
+      options: {}
+    },
+    registerAuthenticator: {
+      name: "RegisterAuthenticator",
+      requestType: MsgRegisterAuthenticator,
+      requestStream: false,
+      responseType: MsgRegisterAuthenticatorResponse,
+      responseStream: false,
+      options: {}
+    },
+    revokeAuthenticator: {
+      name: "RevokeAuthenticator",
+      requestType: MsgRevokeAuthenticator,
+      requestStream: false,
+      responseType: MsgRevokeAuthenticatorResponse,
+      responseStream: false,
+      options: {}
+    },
+    executeEVM: {
+      name: "ExecuteEVM",
+      requestType: MsgExecuteEVM,
+      requestStream: false,
+      responseType: MsgExecuteEVMResponse,
+      responseStream: false,
+      options: {}
+    },
+    executeCosmos: {
+      name: "ExecuteCosmos",
+      requestType: MsgExecuteCosmos,
+      requestStream: false,
+      responseType: MsgExecuteCosmosResponse,
+      responseStream: false,
+      options: {}
+    }
+  }
+};
+function bytesFromBase646(b64) {
+  if (globalThis.Buffer) {
+    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+function base64FromBytes6(arr) {
+  if (globalThis.Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin = [];
+    arr.forEach((byte) => {
+      bin.push(globalThis.String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+function isSet10(value) {
+  return value !== null && value !== void 0;
+}
+
+// src/codegen/qorechain/crossvm/v1/tx.ts
+var tx_exports10 = {};
+__export(tx_exports10, {
+  MsgCrossVMCall: () => MsgCrossVMCall,
+  MsgCrossVMCallResponse: () => MsgCrossVMCallResponse,
+  MsgDefinition: () => MsgDefinition10,
+  MsgProcessQueue: () => MsgProcessQueue,
+  MsgProcessQueueResponse: () => MsgProcessQueueResponse,
+  protobufPackage: () => protobufPackage10
+});
+var protobufPackage10 = "qorechain.crossvm.v1";
+function createBaseMsgCrossVMCall() {
+  return { sender: "", sourceVm: "", targetVm: "", targetContract: "", payload: new Uint8Array(0), funds: [] };
+}
+var MsgCrossVMCall = {
+  encode(message, writer = new wire.BinaryWriter()) {
+    if (message.sender !== "") {
+      writer.uint32(10).string(message.sender);
+    }
+    if (message.sourceVm !== "") {
+      writer.uint32(18).string(message.sourceVm);
+    }
+    if (message.targetVm !== "") {
+      writer.uint32(26).string(message.targetVm);
     }
     if (message.targetContract !== "") {
       writer.uint32(34).string(message.targetContract);
@@ -10003,6 +10737,7 @@ var qorechainRegistryTypes = [
   ["/qorechain.pqc.v1.MsgRegisterPQCKey", MsgRegisterPQCKey],
   ["/qorechain.pqc.v1.MsgRegisterPQCKeyV2", MsgRegisterPQCKeyV2],
   ["/qorechain.pqc.v1.MsgMigratePQCKey", MsgMigratePQCKey],
+  ["/qorechain.pqc.v1.MsgRotatePQCKey", MsgRotatePQCKey],
   ["/qorechain.pqc.v1.MsgDeprecateAlgorithm", MsgDeprecateAlgorithm],
   ["/qorechain.pqc.v1.MsgDisableAlgorithm", MsgDisableAlgorithm],
   // svm
@@ -10043,6 +10778,11 @@ var qorechainRegistryTypes = [
     "/qorechain.abstractaccount.v1.MsgRevokeAuthenticator",
     MsgRevokeAuthenticator
   ],
+  ["/qorechain.abstractaccount.v1.MsgExecuteEVM", MsgExecuteEVM],
+  [
+    "/qorechain.abstractaccount.v1.MsgExecuteCosmos",
+    MsgExecuteCosmos
+  ],
   // crossvm
   ["/qorechain.crossvm.v1.MsgCrossVMCall", MsgCrossVMCall],
   ["/qorechain.crossvm.v1.MsgProcessQueue", MsgProcessQueue],
@@ -10091,6 +10831,34 @@ var SDK_CODES = {
   25: { kind: "invalid_gas_limit", message: "invalid gas limit" },
   30: { kind: "tx_timeout_height", message: "transaction timeout height exceeded" }
 };
+var ABSTRACTACCOUNT_CODES = {
+  5: {
+    kind: "spending_limit_exceeded",
+    message: "spending limit exceeded \u2014 the amount is over the authenticator's per-tx or daily SpendingRule"
+  },
+  6: {
+    kind: "session_key_expired",
+    message: "session key expired \u2014 the authenticator's expiry_unix has passed; re-register the key"
+  },
+  10: {
+    kind: "permission_denied",
+    message: "permission denied \u2014 the authenticator lacks the permission this message requires (check the permission_schema)"
+  },
+  11: {
+    kind: "authenticator_replay",
+    message: "authenticator replay \u2014 the nonce does not match the account's expected value; refetch the current nonce/sequence and re-sign"
+  }
+};
+var PQC_CODES = {
+  21: {
+    kind: "hybrid_verify_failed",
+    message: "hybrid signature verification failed \u2014 the ML-DSA-87 signature did not verify (ensure deterministic signing; hedged signatures are rejected)"
+  }
+};
+var MODULE_CODES = {
+  abstractaccount: ABSTRACTACCOUNT_CODES,
+  pqc: PQC_CODES
+};
 var DEFAULT_CODESPACE = "sdk";
 function decodeTxError(input) {
   const codespace = input.codespace || DEFAULT_CODESPACE;
@@ -10106,6 +10874,17 @@ function decodeTxError(input) {
         rawLog
       };
     }
+  } else {
+    const known = MODULE_CODES[codespace]?.[input.code];
+    if (known) {
+      return {
+        code: input.code,
+        codespace,
+        kind: known.kind,
+        message: rawLog ? `${known.message} (${rawLog})` : known.message,
+        rawLog
+      };
+    }
   }
   const detail = rawLog && rawLog.length > 0 ? rawLog : "(no log provided)";
   return {
@@ -11270,93 +12049,279 @@ function isNotFound(err) {
     if (err.body && /not\s*found|tx not found|code\s*=\s*5/i.test(err.body)) {
       return true;
     }
-  }
-  return false;
-}
-function toIncludedTx(hash, res) {
-  const r = res.tx_response;
-  const code = r?.code ?? 0;
-  return {
-    txHash: r?.txhash ?? hash,
-    height: r?.height ? Number(r.height) : 0,
-    code,
-    gasUsed: r?.gas_used ? BigInt(r.gas_used) : void 0,
-    gasWanted: r?.gas_wanted ? BigInt(r.gas_wanted) : void 0,
-    rawLog: r?.raw_log,
-    raw: res
-  };
-}
-async function waitForTx(fetcher, txHash, opts = {}) {
-  const timeoutMs = opts.timeoutMs ?? 6e4;
-  const pollIntervalMs = opts.pollIntervalMs ?? 2e3;
-  const get = typeof fetcher === "function" ? fetcher : (h) => getTx(fetcher, h);
-  const deadline = Date.now() + timeoutMs;
-  for (; ; ) {
-    let res;
-    try {
-      res = await get(txHash);
-    } catch (err) {
-      if (!isNotFound(err)) throw err;
+  }
+  return false;
+}
+function toIncludedTx(hash, res) {
+  const r = res.tx_response;
+  const code = r?.code ?? 0;
+  return {
+    txHash: r?.txhash ?? hash,
+    height: r?.height ? Number(r.height) : 0,
+    code,
+    gasUsed: r?.gas_used ? BigInt(r.gas_used) : void 0,
+    gasWanted: r?.gas_wanted ? BigInt(r.gas_wanted) : void 0,
+    rawLog: r?.raw_log,
+    raw: res
+  };
+}
+async function waitForTx(fetcher, txHash, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? 6e4;
+  const pollIntervalMs = opts.pollIntervalMs ?? 2e3;
+  const get = typeof fetcher === "function" ? fetcher : (h) => getTx(fetcher, h);
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    let res;
+    try {
+      res = await get(txHash);
+    } catch (err) {
+      if (!isNotFound(err)) throw err;
+    }
+    if (res?.tx_response) {
+      const included = toIncludedTx(txHash, res);
+      if (included.code !== 0) {
+        throw txErrorFrom({
+          code: included.code,
+          codespace: res.tx_response.codespace,
+          rawLog: included.rawLog,
+          txHash: included.txHash
+        });
+      }
+      return included;
+    }
+    if (Date.now() + pollIntervalMs > deadline) {
+      throw new Error(
+        `timed out after ${timeoutMs}ms waiting for tx ${txHash} to be included`
+      );
+    }
+    await sleep(pollIntervalMs);
+  }
+}
+async function broadcastAndWait(broadcast, fetcher, opts = {}) {
+  const { transactionHash } = await broadcast();
+  return waitForTx(fetcher, transactionHash, opts);
+}
+async function withRetry2(fn, opts = {}) {
+  const retries = opts.retries ?? 3;
+  const baseBackoff = opts.backoff ?? 250;
+  const maxBackoff = opts.maxBackoff ?? 5e3;
+  const shouldRetry = opts.shouldRetry ?? (() => true);
+  let lastError;
+  for (let attempt2 = 0; attempt2 <= retries; attempt2++) {
+    try {
+      return await fn(attempt2);
+    } catch (err) {
+      lastError = err;
+      if (attempt2 === retries || !shouldRetry(err, attempt2)) throw err;
+      const delay2 = Math.min(baseBackoff * 2 ** attempt2, maxBackoff);
+      if (delay2 > 0) await sleep(delay2);
+    }
+  }
+  throw lastError;
+}
+
+// src/tx/authenticator.ts
+var enc = new TextEncoder();
+var EVM_AUTH_DOMAIN = "qorechain-evm-auth-v1";
+var COSMOS_AUTH_DOMAIN = "qorechain-cosmos-auth-v1";
+var ROTATE_DOMAIN = "qorechain-pqc-rotate-v1";
+function be64(n) {
+  const b = new Uint8Array(8);
+  let v = BigInt(n);
+  if (v < 0n) throw new Error(`be64: value must be non-negative, got ${n}`);
+  for (let i = 7; i >= 0; i--) {
+    b[i] = Number(v & 0xffn);
+    v >>= 8n;
+  }
+  return b;
+}
+function concat(parts) {
+  let len = 0;
+  for (const p of parts) len += p.length;
+  const out = new Uint8Array(len);
+  let o = 0;
+  for (const p of parts) {
+    out.set(p, o);
+    o += p.length;
+  }
+  return out;
+}
+function lengthPrefixed(bytes) {
+  return concat([be64(bytes.length), bytes]);
+}
+function toBytes2(x) {
+  return typeof x === "string" ? enc.encode(x) : x;
+}
+function toHexLower(bytes) {
+  let s = "";
+  for (const b of bytes) s += b.toString(16).padStart(2, "0");
+  return s;
+}
+function evmAuthSignBytes(input) {
+  const {
+    chainId,
+    account,
+    pubkey,
+    to = "",
+    value = "0",
+    data = new Uint8Array(0),
+    nonce
+  } = input;
+  const body = concat([
+    enc.encode(EVM_AUTH_DOMAIN),
+    lengthPrefixed(toBytes2(chainId)),
+    lengthPrefixed(toBytes2(account)),
+    lengthPrefixed(pubkey),
+    lengthPrefixed(toBytes2(to)),
+    lengthPrefixed(toBytes2(value)),
+    lengthPrefixed(data),
+    be64(nonce)
+  ]);
+  return sha256(body);
+}
+function cosmosAuthSignBytes(input) {
+  const { chainId, account, pubkey, to, amount, nonce } = input;
+  const body = concat([
+    enc.encode(COSMOS_AUTH_DOMAIN),
+    lengthPrefixed(toBytes2(chainId)),
+    lengthPrefixed(toBytes2(account)),
+    lengthPrefixed(pubkey),
+    lengthPrefixed(toBytes2(to)),
+    lengthPrefixed(toBytes2(amount)),
+    be64(nonce)
+  ]);
+  return sha256(body);
+}
+function rotationSignBytes(chainId, algorithmId, account, oldPub, newPub) {
+  return `${ROTATE_DOMAIN}|${chainId}|${algorithmId}|${account}|${toHexLower(oldPub)}|${toHexLower(newPub)}`;
+}
+
+// src/codegen/qorechain/pqc/v1/hybrid.ts
+var hybrid_exports = {};
+__export(hybrid_exports, {
+  PQCHybridSignature: () => PQCHybridSignature,
+  protobufPackage: () => protobufPackage12
+});
+var protobufPackage12 = "qorechain.pqc.v1";
+function createBasePQCHybridSignature() {
+  return { algorithmId: 0, pqcSignature: new Uint8Array(0), pqcPublicKey: new Uint8Array(0) };
+}
+var PQCHybridSignature = {
+  encode(message, writer = new wire.BinaryWriter()) {
+    if (message.algorithmId !== 0) {
+      writer.uint32(8).uint32(message.algorithmId);
+    }
+    if (message.pqcSignature.length !== 0) {
+      writer.uint32(18).bytes(message.pqcSignature);
+    }
+    if (message.pqcPublicKey.length !== 0) {
+      writer.uint32(26).bytes(message.pqcPublicKey);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBasePQCHybridSignature();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.algorithmId = reader.uint32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.pqcSignature = reader.bytes();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.pqcPublicKey = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      algorithmId: isSet13(object.algorithmId) ? globalThis.Number(object.algorithmId) : isSet13(object.algorithm_id) ? globalThis.Number(object.algorithm_id) : 0,
+      pqcSignature: isSet13(object.pqcSignature) ? bytesFromBase648(object.pqcSignature) : isSet13(object.pqc_signature) ? bytesFromBase648(object.pqc_signature) : new Uint8Array(0),
+      pqcPublicKey: isSet13(object.pqcPublicKey) ? bytesFromBase648(object.pqcPublicKey) : isSet13(object.pqc_public_key) ? bytesFromBase648(object.pqc_public_key) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.algorithmId !== 0) {
+      obj.algorithmId = Math.round(message.algorithmId);
     }
-    if (res?.tx_response) {
-      const included = toIncludedTx(txHash, res);
-      if (included.code !== 0) {
-        throw txErrorFrom({
-          code: included.code,
-          codespace: res.tx_response.codespace,
-          rawLog: included.rawLog,
-          txHash: included.txHash
-        });
-      }
-      return included;
+    if (message.pqcSignature.length !== 0) {
+      obj.pqcSignature = base64FromBytes8(message.pqcSignature);
     }
-    if (Date.now() + pollIntervalMs > deadline) {
-      throw new Error(
-        `timed out after ${timeoutMs}ms waiting for tx ${txHash} to be included`
-      );
+    if (message.pqcPublicKey.length !== 0) {
+      obj.pqcPublicKey = base64FromBytes8(message.pqcPublicKey);
     }
-    await sleep(pollIntervalMs);
+    return obj;
+  },
+  create(base) {
+    return PQCHybridSignature.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBasePQCHybridSignature();
+    message.algorithmId = object.algorithmId ?? 0;
+    message.pqcSignature = object.pqcSignature ?? new Uint8Array(0);
+    message.pqcPublicKey = object.pqcPublicKey ?? new Uint8Array(0);
+    return message;
   }
-}
-async function broadcastAndWait(broadcast, fetcher, opts = {}) {
-  const { transactionHash } = await broadcast();
-  return waitForTx(fetcher, transactionHash, opts);
-}
-async function withRetry2(fn, opts = {}) {
-  const retries = opts.retries ?? 3;
-  const baseBackoff = opts.backoff ?? 250;
-  const maxBackoff = opts.maxBackoff ?? 5e3;
-  const shouldRetry = opts.shouldRetry ?? (() => true);
-  let lastError;
-  for (let attempt2 = 0; attempt2 <= retries; attempt2++) {
-    try {
-      return await fn(attempt2);
-    } catch (err) {
-      lastError = err;
-      if (attempt2 === retries || !shouldRetry(err, attempt2)) throw err;
-      const delay2 = Math.min(baseBackoff * 2 ** attempt2, maxBackoff);
-      if (delay2 > 0) await sleep(delay2);
+};
+function bytesFromBase648(b64) {
+  if (globalThis.Buffer) {
+    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
     }
+    return arr;
   }
-  throw lastError;
 }
-function toGoJson(ext) {
-  const obj = {
-    algorithm_id: ext.algorithm_id,
-    pqc_signature: base64(ext.pqc_signature)
-  };
-  if (ext.pqc_public_key !== void 0 && ext.pqc_public_key.length > 0) {
-    obj.pqc_public_key = base64(ext.pqc_public_key);
+function base64FromBytes8(arr) {
+  if (globalThis.Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin = [];
+    arr.forEach((byte) => {
+      bin.push(globalThis.String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
   }
-  return JSON.stringify(obj);
 }
-function base64(bytes) {
-  let binary = "";
-  for (const b of bytes) binary += String.fromCharCode(b);
-  return btoa(binary);
+function isSet13(value) {
+  return value !== null && value !== void 0;
 }
+
+// src/tx/hybrid.ts
 function encodeHybridExtension(ext) {
-  const value = new TextEncoder().encode(toGoJson(ext));
+  const value = PQCHybridSignature.encode(
+    PQCHybridSignature.fromPartial({
+      algorithmId: ext.algorithm_id,
+      pqcSignature: ext.pqc_signature,
+      pqcPublicKey: ext.pqc_public_key ?? new Uint8Array(0)
+    })
+  ).finish();
   return any.Any.fromPartial({ typeUrl: HYBRID_SIG_TYPE_URL, value });
 }
 function attachHybridExtension(body, ext, opts = {}) {
@@ -11530,9 +12495,9 @@ function concatBytes2(...parts) {
   return out;
 }
 function encodeMessages(params) {
-  const enc = params.encodeMessage;
+  const enc3 = params.encodeMessage;
   return params.messages.map((m) => {
-    if (enc) return enc(m);
+    if (enc3) return enc3(m);
     if (m.value instanceof Uint8Array) {
       return any.Any.fromPartial({ typeUrl: m.typeUrl, value: m.value });
     }
@@ -11959,6 +12924,17 @@ var pqc = {
   disableAlgorithm: composer2(
     "/qorechain.pqc.v1.MsgDisableAlgorithm",
     MsgDisableAlgorithm
+  ),
+  /**
+   * Replace an account's PQC key with a NEW key of the SAME algorithm (rotate a
+   * compromised key, or migrate a legacy-derived key to the canonical
+   * derivation). Dual-signed over the domain-separated rotation bytes (the old
+   * key proves ownership, the new key proves control). Sender-signed; broadcast
+   * BY the account, cosigned (hybrid) with the OLD key.
+   */
+  rotatePqcKey: composer2(
+    "/qorechain.pqc.v1.MsgRotatePQCKey",
+    MsgRotatePQCKey
   )
 };
 var svm = {
@@ -12037,6 +13013,26 @@ var abstractaccount = {
   revokeAuthenticator: composer2(
     "/qorechain.abstractaccount.v1.MsgRevokeAuthenticator",
     MsgRevokeAuthenticator
+  ),
+  /**
+   * EVM-lane spend: execute an EVM call/transfer FROM the canonical account's
+   * 0x address, authorized by a linked authenticator's signature over the EVM
+   * auth sign-bytes. Relayer-signed (it submits + pays fees). See
+   * {@link ../tx/authenticator.evmAuthSignBytes}.
+   */
+  executeEvm: composer2(
+    "/qorechain.abstractaccount.v1.MsgExecuteEVM",
+    MsgExecuteEVM
+  ),
+  /**
+   * Native-lane spend: move native QOR FROM the canonical account via x/bank,
+   * authorized by a linked authenticator's signature over the Cosmos auth
+   * sign-bytes. Relayer-signed (it submits + pays fees). See
+   * {@link ../tx/authenticator.cosmosAuthSignBytes}.
+   */
+  executeCosmos: composer2(
+    "/qorechain.abstractaccount.v1.MsgExecuteCosmos",
+    MsgExecuteCosmos
   )
 };
 var crossvm = {
@@ -12080,164 +13076,47 @@ var msg = {
   ibc,
   // qorechain
   amm,
-  bridge,
-  rdk,
-  multilayer,
-  pqc,
-  svm,
-  lightnode,
-  license,
-  abstractaccount,
-  crossvm,
-  rlconsensus
-};
-
-// src/codegen/index.ts
-var codegen_exports = {};
-__export(codegen_exports, {
-  abstractaccount: () => tx_exports9,
-  abstractaccountQuery: () => query_exports,
-  amm: () => tx_exports,
-  ammQuery: () => query_exports2,
-  bridge: () => tx_exports2,
-  bridgeQuery: () => query_exports3,
-  crossvm: () => tx_exports10,
-  crossvmQuery: () => query_exports4,
-  license: () => tx_exports8,
-  licenseQuery: () => query_exports5,
-  lightnode: () => tx_exports7,
-  lightnodeQuery: () => query_exports6,
-  multilayer: () => tx_exports4,
-  multilayerQuery: () => query_exports7,
-  pqc: () => tx_exports5,
-  pqcHybrid: () => hybrid_exports,
-  pqcQuery: () => query_exports8,
-  qcaQuery: () => query_exports9,
-  rdk: () => tx_exports3,
-  rdkQuery: () => query_exports10,
-  reputationQuery: () => query_exports11,
-  rlconsensus: () => tx_exports11,
-  rlconsensusQuery: () => query_exports12,
-  svm: () => tx_exports6,
-  svmQuery: () => query_exports13
-});
-
-// src/codegen/qorechain/pqc/v1/hybrid.ts
-var hybrid_exports = {};
-__export(hybrid_exports, {
-  PQCHybridSignature: () => PQCHybridSignature,
-  protobufPackage: () => protobufPackage12
-});
-var protobufPackage12 = "qorechain.pqc.v1";
-function createBasePQCHybridSignature() {
-  return { algorithmId: 0, pqcSignature: new Uint8Array(0), pqcPublicKey: new Uint8Array(0) };
-}
-var PQCHybridSignature = {
-  encode(message, writer = new wire.BinaryWriter()) {
-    if (message.algorithmId !== 0) {
-      writer.uint32(8).uint32(message.algorithmId);
-    }
-    if (message.pqcSignature.length !== 0) {
-      writer.uint32(18).bytes(message.pqcSignature);
-    }
-    if (message.pqcPublicKey.length !== 0) {
-      writer.uint32(26).bytes(message.pqcPublicKey);
-    }
-    return writer;
-  },
-  decode(input, length) {
-    const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
-    const end = length === void 0 ? reader.len : reader.pos + length;
-    const message = createBasePQCHybridSignature();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 8) {
-            break;
-          }
-          message.algorithmId = reader.uint32();
-          continue;
-        }
-        case 2: {
-          if (tag !== 18) {
-            break;
-          }
-          message.pqcSignature = reader.bytes();
-          continue;
-        }
-        case 3: {
-          if (tag !== 26) {
-            break;
-          }
-          message.pqcPublicKey = reader.bytes();
-          continue;
-        }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
-  },
-  fromJSON(object) {
-    return {
-      algorithmId: isSet13(object.algorithmId) ? globalThis.Number(object.algorithmId) : isSet13(object.algorithm_id) ? globalThis.Number(object.algorithm_id) : 0,
-      pqcSignature: isSet13(object.pqcSignature) ? bytesFromBase648(object.pqcSignature) : isSet13(object.pqc_signature) ? bytesFromBase648(object.pqc_signature) : new Uint8Array(0),
-      pqcPublicKey: isSet13(object.pqcPublicKey) ? bytesFromBase648(object.pqcPublicKey) : isSet13(object.pqc_public_key) ? bytesFromBase648(object.pqc_public_key) : new Uint8Array(0)
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.algorithmId !== 0) {
-      obj.algorithmId = Math.round(message.algorithmId);
-    }
-    if (message.pqcSignature.length !== 0) {
-      obj.pqcSignature = base64FromBytes8(message.pqcSignature);
-    }
-    if (message.pqcPublicKey.length !== 0) {
-      obj.pqcPublicKey = base64FromBytes8(message.pqcPublicKey);
-    }
-    return obj;
-  },
-  create(base) {
-    return PQCHybridSignature.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBasePQCHybridSignature();
-    message.algorithmId = object.algorithmId ?? 0;
-    message.pqcSignature = object.pqcSignature ?? new Uint8Array(0);
-    message.pqcPublicKey = object.pqcPublicKey ?? new Uint8Array(0);
-    return message;
-  }
+  bridge,
+  rdk,
+  multilayer,
+  pqc,
+  svm,
+  lightnode,
+  license,
+  abstractaccount,
+  crossvm,
+  rlconsensus
 };
-function bytesFromBase648(b64) {
-  if (globalThis.Buffer) {
-    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
-  } else {
-    const bin = globalThis.atob(b64);
-    const arr = new Uint8Array(bin.length);
-    for (let i = 0; i < bin.length; ++i) {
-      arr[i] = bin.charCodeAt(i);
-    }
-    return arr;
-  }
-}
-function base64FromBytes8(arr) {
-  if (globalThis.Buffer) {
-    return globalThis.Buffer.from(arr).toString("base64");
-  } else {
-    const bin = [];
-    arr.forEach((byte) => {
-      bin.push(globalThis.String.fromCharCode(byte));
-    });
-    return globalThis.btoa(bin.join(""));
-  }
-}
-function isSet13(value) {
-  return value !== null && value !== void 0;
-}
+
+// src/codegen/index.ts
+var codegen_exports = {};
+__export(codegen_exports, {
+  abstractaccount: () => tx_exports9,
+  abstractaccountQuery: () => query_exports,
+  amm: () => tx_exports,
+  ammQuery: () => query_exports2,
+  bridge: () => tx_exports2,
+  bridgeQuery: () => query_exports3,
+  crossvm: () => tx_exports10,
+  crossvmQuery: () => query_exports4,
+  license: () => tx_exports8,
+  licenseQuery: () => query_exports5,
+  lightnode: () => tx_exports7,
+  lightnodeQuery: () => query_exports6,
+  multilayer: () => tx_exports4,
+  multilayerQuery: () => query_exports7,
+  pqc: () => tx_exports5,
+  pqcHybrid: () => hybrid_exports,
+  pqcQuery: () => query_exports8,
+  qcaQuery: () => query_exports9,
+  rdk: () => tx_exports3,
+  rdkQuery: () => query_exports10,
+  reputationQuery: () => query_exports11,
+  rlconsensus: () => tx_exports11,
+  rlconsensusQuery: () => query_exports12,
+  svm: () => tx_exports6,
+  svmQuery: () => query_exports13
+});
 
 // src/codegen/qorechain/abstractaccount/v1/query.ts
 var query_exports = {};
@@ -12251,6 +13130,9 @@ __export(query_exports, {
   QueryConfigRequest: () => QueryConfigRequest,
   QueryConfigResponse: () => QueryConfigResponse,
   QueryDefinition: () => QueryDefinition,
+  QueryPermissionSchemaRequest: () => QueryPermissionSchemaRequest,
+  QueryPermissionSchemaResponse: () => QueryPermissionSchemaResponse,
+  QueryPermissionSchemaResponse_MsgPermissionsEntry: () => QueryPermissionSchemaResponse_MsgPermissionsEntry,
   protobufPackage: () => protobufPackage13
 });
 var protobufPackage13 = "qorechain.abstractaccount.v1";
@@ -12779,6 +13661,236 @@ var QueryAccountsResponse = {
     return message;
   }
 };
+function createBaseQueryPermissionSchemaRequest() {
+  return {};
+}
+var QueryPermissionSchemaRequest = {
+  encode(_, writer = new wire.BinaryWriter()) {
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseQueryPermissionSchemaRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(_) {
+    return {};
+  },
+  toJSON(_) {
+    const obj = {};
+    return obj;
+  },
+  create(base) {
+    return QueryPermissionSchemaRequest.fromPartial(base ?? {});
+  },
+  fromPartial(_) {
+    const message = createBaseQueryPermissionSchemaRequest();
+    return message;
+  }
+};
+function createBaseQueryPermissionSchemaResponse() {
+  return { schemaVersion: "", permissions: [], msgPermissions: {}, keyManagementMsgs: [] };
+}
+var QueryPermissionSchemaResponse = {
+  encode(message, writer = new wire.BinaryWriter()) {
+    if (message.schemaVersion !== "") {
+      writer.uint32(10).string(message.schemaVersion);
+    }
+    for (const v of message.permissions) {
+      writer.uint32(18).string(v);
+    }
+    globalThis.Object.entries(message.msgPermissions).forEach(([key, value]) => {
+      QueryPermissionSchemaResponse_MsgPermissionsEntry.encode({ key, value }, writer.uint32(26).fork()).join();
+    });
+    for (const v of message.keyManagementMsgs) {
+      writer.uint32(34).string(v);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseQueryPermissionSchemaResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.schemaVersion = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.permissions.push(reader.string());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          const entry3 = QueryPermissionSchemaResponse_MsgPermissionsEntry.decode(reader, reader.uint32());
+          if (entry3.value !== void 0) {
+            message.msgPermissions[entry3.key] = entry3.value;
+          }
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.keyManagementMsgs.push(reader.string());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      schemaVersion: isSet14(object.schemaVersion) ? globalThis.String(object.schemaVersion) : isSet14(object.schema_version) ? globalThis.String(object.schema_version) : "",
+      permissions: globalThis.Array.isArray(object?.permissions) ? object.permissions.map((e) => globalThis.String(e)) : [],
+      msgPermissions: isObject(object.msgPermissions) ? globalThis.Object.entries(object.msgPermissions).reduce(
+        (acc, [key, value]) => {
+          acc[key] = globalThis.String(value);
+          return acc;
+        },
+        {}
+      ) : isObject(object.msg_permissions) ? globalThis.Object.entries(object.msg_permissions).reduce(
+        (acc, [key, value]) => {
+          acc[key] = globalThis.String(value);
+          return acc;
+        },
+        {}
+      ) : {},
+      keyManagementMsgs: globalThis.Array.isArray(object?.keyManagementMsgs) ? object.keyManagementMsgs.map((e) => globalThis.String(e)) : globalThis.Array.isArray(object?.key_management_msgs) ? object.key_management_msgs.map((e) => globalThis.String(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.schemaVersion !== "") {
+      obj.schemaVersion = message.schemaVersion;
+    }
+    if (message.permissions?.length) {
+      obj.permissions = message.permissions;
+    }
+    if (message.msgPermissions) {
+      const entries = globalThis.Object.entries(message.msgPermissions);
+      if (entries.length > 0) {
+        obj.msgPermissions = {};
+        entries.forEach(([k, v]) => {
+          obj.msgPermissions[k] = v;
+        });
+      }
+    }
+    if (message.keyManagementMsgs?.length) {
+      obj.keyManagementMsgs = message.keyManagementMsgs;
+    }
+    return obj;
+  },
+  create(base) {
+    return QueryPermissionSchemaResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseQueryPermissionSchemaResponse();
+    message.schemaVersion = object.schemaVersion ?? "";
+    message.permissions = object.permissions?.map((e) => e) || [];
+    message.msgPermissions = globalThis.Object.entries(object.msgPermissions ?? {}).reduce(
+      (acc, [key, value]) => {
+        if (value !== void 0) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {}
+    );
+    message.keyManagementMsgs = object.keyManagementMsgs?.map((e) => e) || [];
+    return message;
+  }
+};
+function createBaseQueryPermissionSchemaResponse_MsgPermissionsEntry() {
+  return { key: "", value: "" };
+}
+var QueryPermissionSchemaResponse_MsgPermissionsEntry = {
+  encode(message, writer = new wire.BinaryWriter()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof wire.BinaryReader ? input : new wire.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseQueryPermissionSchemaResponse_MsgPermissionsEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      key: isSet14(object.key) ? globalThis.String(object.key) : "",
+      value: isSet14(object.value) ? globalThis.String(object.value) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+  create(base) {
+    return QueryPermissionSchemaResponse_MsgPermissionsEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseQueryPermissionSchemaResponse_MsgPermissionsEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  }
+};
 var QueryDefinition = {
   name: "Query",
   fullName: "qorechain.abstractaccount.v1.Query",
@@ -12790,7 +13902,53 @@ var QueryDefinition = {
       requestStream: false,
       responseType: QueryConfigResponse,
       responseStream: false,
-      options: {}
+      options: {
+        _unknownFields: {
+          578365826: [
+            new Uint8Array([
+              38,
+              18,
+              36,
+              47,
+              113,
+              111,
+              114,
+              101,
+              99,
+              104,
+              97,
+              105,
+              110,
+              47,
+              97,
+              98,
+              115,
+              116,
+              114,
+              97,
+              99,
+              116,
+              97,
+              99,
+              99,
+              111,
+              117,
+              110,
+              116,
+              47,
+              118,
+              49,
+              47,
+              99,
+              111,
+              110,
+              102,
+              105,
+              103
+            ])
+          ]
+        }
+      }
     },
     /** Account returns a single abstract account by address. */
     account: {
@@ -12799,7 +13957,65 @@ var QueryDefinition = {
       requestStream: false,
       responseType: QueryAccountResponse,
       responseStream: false,
-      options: {}
+      options: {
+        _unknownFields: {
+          578365826: [
+            new Uint8Array([
+              50,
+              18,
+              48,
+              47,
+              113,
+              111,
+              114,
+              101,
+              99,
+              104,
+              97,
+              105,
+              110,
+              47,
+              97,
+              98,
+              115,
+              116,
+              114,
+              97,
+              99,
+              116,
+              97,
+              99,
+              99,
+              111,
+              117,
+              110,
+              116,
+              47,
+              118,
+              49,
+              47,
+              97,
+              99,
+              99,
+              111,
+              117,
+              110,
+              116,
+              115,
+              47,
+              123,
+              97,
+              100,
+              100,
+              114,
+              101,
+              115,
+              115,
+              125
+            ])
+          ]
+        }
+      }
     },
     /** Accounts lists all abstract accounts. */
     accounts: {
@@ -12808,10 +14024,131 @@ var QueryDefinition = {
       requestStream: false,
       responseType: QueryAccountsResponse,
       responseStream: false,
-      options: {}
+      options: {
+        _unknownFields: {
+          578365826: [
+            new Uint8Array([
+              40,
+              18,
+              38,
+              47,
+              113,
+              111,
+              114,
+              101,
+              99,
+              104,
+              97,
+              105,
+              110,
+              47,
+              97,
+              98,
+              115,
+              116,
+              114,
+              97,
+              99,
+              116,
+              97,
+              99,
+              99,
+              111,
+              117,
+              110,
+              116,
+              47,
+              118,
+              49,
+              47,
+              97,
+              99,
+              99,
+              111,
+              117,
+              110,
+              116,
+              115
+            ])
+          ]
+        }
+      }
+    },
+    /**
+     * PermissionSchema returns the canonical authenticator permission taxonomy so
+     * clients (QoreX/dashboard/relayer) validate scopes without hardcoding strings
+     * and detect drift via schema_version (v3.1.85).
+     */
+    permissionSchema: {
+      name: "PermissionSchema",
+      requestType: QueryPermissionSchemaRequest,
+      requestStream: false,
+      responseType: QueryPermissionSchemaResponse,
+      responseStream: false,
+      options: {
+        _unknownFields: {
+          578365826: [
+            new Uint8Array([
+              49,
+              18,
+              47,
+              47,
+              113,
+              111,
+              114,
+              101,
+              99,
+              104,
+              97,
+              105,
+              110,
+              47,
+              97,
+              98,
+              115,
+              116,
+              114,
+              97,
+              99,
+              116,
+              97,
+              99,
+              99,
+              111,
+              117,
+              110,
+              116,
+              47,
+              118,
+              49,
+              47,
+              112,
+              101,
+              114,
+              109,
+              105,
+              115,
+              115,
+              105,
+              111,
+              110,
+              95,
+              115,
+              99,
+              104,
+              101,
+              109,
+              97
+            ])
+          ]
+        }
+      }
     }
   }
 };
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
 function isSet14(value) {
   return value !== null && value !== void 0;
 }
@@ -24026,6 +25363,277 @@ function base64FromBytes11(arr) {
 function isSet26(value) {
   return value !== null && value !== void 0;
 }
+var enc2 = new TextEncoder();
+function toBytes3(x) {
+  return typeof x === "string" ? enc2.encode(x) : x;
+}
+function hexToBytes3(hex) {
+  const h = hex.replace(/^0x/, "");
+  const out = new Uint8Array(h.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+function bytesToHex0x(b) {
+  let s = "0x";
+  for (const x of b) s += x.toString(16).padStart(2, "0");
+  return s;
+}
+function toHexLower2(b) {
+  let s = "";
+  for (const x of b) s += x.toString(16).padStart(2, "0");
+  return s;
+}
+function parseCoins(amount) {
+  const m = /^([0-9]+)([a-zA-Z][a-zA-Z0-9/:._-]*)$/.exec(String(amount).trim());
+  if (!m) {
+    throw new Error(`invalid amount "${amount}" (expected e.g. "100uqor")`);
+  }
+  return [{ denom: m[2], amount: m[1] }];
+}
+function executeEvmMsg(input) {
+  const {
+    relayer,
+    account,
+    scheme,
+    pubkey,
+    signature,
+    to = "",
+    value = "0",
+    data = new Uint8Array(0),
+    gasLimit,
+    nonce
+  } = input;
+  return {
+    typeUrl: "/qorechain.abstractaccount.v1.MsgExecuteEVM",
+    value: {
+      relayer,
+      account,
+      scheme,
+      pubkey: toBytes3(pubkey),
+      signature: toBytes3(signature),
+      to,
+      value,
+      data: toBytes3(data),
+      gasLimit: BigInt(gasLimit),
+      nonce: BigInt(nonce)
+    }
+  };
+}
+function executeCosmosMsg(input) {
+  const { relayer, account, scheme, pubkey, signature, to, amount, nonce } = input;
+  return {
+    typeUrl: "/qorechain.abstractaccount.v1.MsgExecuteCosmos",
+    value: {
+      relayer,
+      account,
+      scheme,
+      pubkey: toBytes3(pubkey),
+      signature: toBytes3(signature),
+      to,
+      amount: parseCoins(amount),
+      nonce: BigInt(nonce)
+    }
+  };
+}
+function revokeAuthenticatorMsg(input) {
+  const { owner, account = owner, scheme, pubkey } = input;
+  return {
+    typeUrl: "/qorechain.abstractaccount.v1.MsgRevokeAuthenticator",
+    value: {
+      owner,
+      accountAddress: account,
+      scheme,
+      pubkey: toBytes3(pubkey)
+    }
+  };
+}
+function registerEthAuthenticatorMsg(input) {
+  const {
+    owner,
+    account = owner,
+    ethAddress,
+    permissions = ["evm"],
+    expiryUnix,
+    label = "metamask"
+  } = input;
+  return {
+    typeUrl: "/qorechain.abstractaccount.v1.MsgRegisterAuthenticator",
+    value: {
+      owner,
+      accountAddress: account,
+      scheme: "secp256k1",
+      pubkey: hexToBytes3(ethAddress),
+      permissions,
+      expiryUnix: BigInt(expiryUnix),
+      label
+    }
+  };
+}
+function rotatePqcKeyMsg(input) {
+  const { sender, oldPublicKey, newPublicKey, oldSignature, newSignature } = input;
+  return {
+    typeUrl: "/qorechain.pqc.v1.MsgRotatePQCKey",
+    value: {
+      sender,
+      oldPublicKey: toBytes3(oldPublicKey),
+      newPublicKey: toBytes3(newPublicKey),
+      oldSignature: toBytes3(oldSignature),
+      newSignature: toBytes3(newSignature)
+    }
+  };
+}
+function walletPubkey(wallet) {
+  const pk = wallet.publicKey;
+  return pk instanceof Uint8Array ? pk : pk.toBytes();
+}
+function normalizeSignature(res) {
+  return res instanceof Uint8Array ? res : res.signature;
+}
+async function buildPhantomExecuteEvm(opts) {
+  const {
+    wallet,
+    relayer,
+    chainId,
+    account,
+    to = "",
+    value = "0",
+    data = new Uint8Array(0),
+    gasLimit = 1e5,
+    nonce
+  } = opts;
+  const pubkey = walletPubkey(wallet);
+  const digest = evmAuthSignBytes({ chainId, account, pubkey, to, value, data, nonce });
+  const signature = normalizeSignature(await wallet.signMessage(digest));
+  return executeEvmMsg({
+    relayer,
+    account,
+    scheme: "ed25519",
+    pubkey,
+    signature,
+    to,
+    value,
+    data,
+    gasLimit,
+    nonce
+  });
+}
+async function buildPhantomExecuteCosmos(opts) {
+  const { wallet, relayer, chainId, account, to, amount, nonce } = opts;
+  const pubkey = walletPubkey(wallet);
+  const digest = cosmosAuthSignBytes({ chainId, account, pubkey, to, amount, nonce });
+  const signature = normalizeSignature(await wallet.signMessage(digest));
+  return executeCosmosMsg({
+    relayer,
+    account,
+    scheme: "ed25519",
+    pubkey,
+    signature,
+    to,
+    amount,
+    nonce
+  });
+}
+async function ethPersonalSign(provider, address, digest) {
+  const sigHex = await provider.request({
+    method: "personal_sign",
+    params: [bytesToHex0x(digest), address]
+  });
+  return hexToBytes3(sigHex);
+}
+async function buildMetaMaskExecuteEvm(opts) {
+  const {
+    provider,
+    address,
+    relayer,
+    chainId,
+    account,
+    to = "",
+    value = "0",
+    data = new Uint8Array(0),
+    gasLimit = 1e5,
+    nonce
+  } = opts;
+  const pubkey = hexToBytes3(address);
+  const digest = evmAuthSignBytes({ chainId, account, pubkey, to, value, data, nonce });
+  const signature = await ethPersonalSign(provider, address, digest);
+  return executeEvmMsg({
+    relayer,
+    account,
+    scheme: "secp256k1",
+    pubkey,
+    signature,
+    to,
+    value,
+    data,
+    gasLimit,
+    nonce
+  });
+}
+async function buildMetaMaskExecuteCosmos(opts) {
+  const { provider, address, relayer, chainId, account, to, amount, nonce } = opts;
+  const pubkey = hexToBytes3(address);
+  const digest = cosmosAuthSignBytes({ chainId, account, pubkey, to, amount, nonce });
+  const signature = await ethPersonalSign(provider, address, digest);
+  return executeCosmosMsg({
+    relayer,
+    account,
+    scheme: "secp256k1",
+    pubkey,
+    signature,
+    to,
+    amount,
+    nonce
+  });
+}
+var CANONICAL_DERIVATION = "adapter";
+var LEGACY_DERIVATION = "bridge";
+function derivePqcLegacy(mnemonic) {
+  return generatePqcKeypair(pqc$1.shake256(enc2.encode(mnemonic), 32));
+}
+function derivePqcCanonical(account, mnemonic) {
+  return generatePqcKeypair(
+    pqc$1.shake256(enc2.encode(`qorechain:pqc:v1|${account}|${mnemonic}`), 32)
+  );
+}
+function derivePqcByScheme(scheme, account, mnemonic) {
+  if (scheme === LEGACY_DERIVATION || scheme === "mnemonic-only") {
+    return derivePqcLegacy(mnemonic);
+  }
+  if (scheme === CANONICAL_DERIVATION || scheme === "") {
+    return derivePqcCanonical(account, mnemonic);
+  }
+  throw new Error(`unknown derivation "${scheme}" (use adapter|bridge)`);
+}
+function rotatePqcKeyMsgFromMnemonic(opts) {
+  const {
+    account,
+    mnemonic,
+    chainId,
+    algorithmId = 1,
+    oldDerivation = LEGACY_DERIVATION,
+    newDerivation = CANONICAL_DERIVATION
+  } = opts;
+  const oldKp = derivePqcByScheme(oldDerivation, account, mnemonic);
+  const newKp = derivePqcByScheme(newDerivation, account, mnemonic);
+  if (toHexLower2(oldKp.publicKey) === toHexLower2(newKp.publicKey)) {
+    throw new Error(
+      "old and new derivations produce the same key \u2014 rotation would be a no-op"
+    );
+  }
+  const sb = enc2.encode(
+    rotationSignBytes(chainId, algorithmId, account, oldKp.publicKey, newKp.publicKey)
+  );
+  const msg2 = rotatePqcKeyMsg({
+    sender: account,
+    oldPublicKey: oldKp.publicKey,
+    newPublicKey: newKp.publicKey,
+    oldSignature: pqc$1.mldsa.sign(oldKp.secretKey, sb),
+    newSignature: pqc$1.mldsa.sign(newKp.secretKey, sb)
+  });
+  return { msg: msg2, oldKeypair: oldKp, newKeypair: newKp };
+}
 
 // src/wallet/cosmos.ts
 function suggestChainInfo(network) {
@@ -24114,6 +25722,13 @@ function createQueryClients(rpc) {
         "Accounts",
         QueryAccountsRequest,
         QueryAccountsResponse
+      ),
+      permissionSchema: unary(
+        rpc,
+        "qorechain.abstractaccount.v1.Query",
+        "PermissionSchema",
+        QueryPermissionSchemaRequest,
+        QueryPermissionSchemaResponse
       )
     },
     amm: {
@@ -24830,7 +26445,7 @@ async function migrateToHybrid(tx, opts) {
 }
 
 // src/index.ts
-var VERSION = "0.6.0";
+var VERSION = "0.7.0";
 
 Object.defineProperty(exports, "AI_ANOMALY_CHECK_ADDRESS", {
   enumerable: true,
@@ -24863,6 +26478,7 @@ Object.defineProperty(exports, "simulateWithRiskScore", {
 exports.AlgorithmDilithium5 = AlgorithmDilithium5;
 exports.AlgorithmMLKEM1024 = AlgorithmMLKEM1024;
 exports.AlgorithmUnspecified = AlgorithmUnspecified;
+exports.CANONICAL_DERIVATION = CANONICAL_DERIVATION;
 exports.DEFAULT_GAS_MULTIPLIER = DEFAULT_GAS_MULTIPLIER;
 exports.DEFAULT_GAS_PRICE = DEFAULT_GAS_PRICE;
 exports.ETHSECP256K1_PUBKEY_TYPE = ETHSECP256K1_PUBKEY_TYPE;
@@ -24872,6 +26488,7 @@ exports.HYBRID_SIG_TYPE_URL = HYBRID_SIG_TYPE_URL;
 exports.HybridSigner = HybridSigner;
 exports.JsonRpcClient = JsonRpcClient;
 exports.JsonRpcError = JsonRpcError;
+exports.LEGACY_DERIVATION = LEGACY_DERIVATION;
 exports.ML_DSA_87_PUBLIC_KEY_LENGTH = ML_DSA_87_PUBLIC_KEY_LENGTH;
 exports.ML_DSA_87_SECRET_KEY_LENGTH = ML_DSA_87_SECRET_KEY_LENGTH;
 exports.ML_DSA_87_SEED_LENGTH = ML_DSA_87_SEED_LENGTH;
@@ -24897,6 +26514,7 @@ exports.amm = amm;
 exports.attachHybridExtension = attachHybridExtension;
 exports.authz = authz;
 exports.bank = bank;
+exports.be64 = be64;
 exports.bech32ToHex = bech32ToHex;
 exports.bridge = bridge;
 exports.broadcastAndWait = broadcastAndWait;
@@ -24904,6 +26522,10 @@ exports.buildAminoTypes = buildAminoTypes;
 exports.buildEventsQuery = buildEventsQuery;
 exports.buildHybridSignatureExtension = buildHybridSignatureExtension;
 exports.buildHybridTx = buildHybridTx;
+exports.buildMetaMaskExecuteCosmos = buildMetaMaskExecuteCosmos;
+exports.buildMetaMaskExecuteEvm = buildMetaMaskExecuteEvm;
+exports.buildPhantomExecuteCosmos = buildPhantomExecuteCosmos;
+exports.buildPhantomExecuteEvm = buildPhantomExecuteEvm;
 exports.buildRegisterPqcKeyMsg = buildRegisterPqcKeyMsg;
 exports.buildTxQuery = buildTxQuery;
 exports.buildUrl = buildUrl;
@@ -24913,6 +26535,7 @@ exports.clearAdmin = clearAdmin;
 exports.connectCosmWasmSigner = connectCosmWasmSigner;
 exports.connectPhantomUnified = connectPhantomUnified;
 exports.connectQueryClients = connectQueryClients;
+exports.cosmosAuthSignBytes = cosmosAuthSignBytes;
 exports.createClient = createClient;
 exports.createCosmWasmClient = createCosmWasmClient;
 exports.createCrossVMClient = createCrossVMClient;
@@ -24924,6 +26547,7 @@ exports.crossvm = crossvm;
 exports.decodeTxError = decodeTxError;
 exports.deriveEvmAccount = deriveEvmAccount;
 exports.deriveNativeAccount = deriveNativeAccount;
+exports.derivePqcLegacy = derivePqcLegacy;
 exports.deriveSvmAccount = deriveSvmAccount;
 exports.deriveUnifiedAccount = deriveUnifiedAccount;
 exports.directSignerFromPrivateKey = directSignerFromPrivateKey;
@@ -24931,8 +26555,11 @@ exports.distribution = distribution;
 exports.encodeHybridExtension = encodeHybridExtension;
 exports.ensurePqcRegistered = ensurePqcRegistered;
 exports.estimateFee = estimateFee;
+exports.evmAuthSignBytes = evmAuthSignBytes;
 exports.evmToQor = evmToQor;
 exports.execute = execute;
+exports.executeCosmosMsg = executeCosmosMsg;
+exports.executeEvmMsg = executeEvmMsg;
 exports.explorerAddressUrl = explorerAddressUrl;
 exports.explorerBlockUrl = explorerBlockUrl;
 exports.explorerTxUrl = explorerTxUrl;
@@ -24970,6 +26597,7 @@ exports.isValidSvmAddress = isValidSvmAddress;
 exports.joinUrl = joinUrl;
 exports.keccak256 = keccak256;
 exports.keccak256Hex = keccak256Hex;
+exports.lengthPrefixed = lengthPrefixed;
 exports.license = license;
 exports.lightnode = lightnode;
 exports.listNetworks = listNetworks;
@@ -24991,10 +26619,15 @@ exports.qorechainRegistryTypes = qorechainRegistryTypes;
 exports.qorechainTypes = codegen_exports;
 exports.queryContractSmart = queryContractSmart;
 exports.rdk = rdk;
+exports.registerEthAuthenticatorMsg = registerEthAuthenticatorMsg;
 exports.requestFaucet = requestFaucet;
+exports.revokeAuthenticatorMsg = revokeAuthenticatorMsg;
 exports.ripemd160 = ripemd160;
 exports.ripemd160Hex = ripemd160Hex;
 exports.rlconsensus = rlconsensus;
+exports.rotatePqcKeyMsg = rotatePqcKeyMsg;
+exports.rotatePqcKeyMsgFromMnemonic = rotatePqcKeyMsgFromMnemonic;
+exports.rotationSignBytes = rotationSignBytes;
 exports.searchTxs = searchTxs;
 exports.sha256 = sha256;
 exports.sha256Hex = sha256Hex;