@qorechain/sdk 0.6.1 → 0.8.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",
@@ -6546,7 +6745,10 @@ __export(tx_exports6, {
   MsgExecuteProgramResponse: () => MsgExecuteProgramResponse,
   MsgRegisterSVMPQCKey: () => MsgRegisterSVMPQCKey,
   MsgRegisterSVMPQCKeyResponse: () => MsgRegisterSVMPQCKeyResponse,
+  MsgUpdateParams: () => MsgUpdateParams,
+  MsgUpdateParamsResponse: () => MsgUpdateParamsResponse,
   SVMAuth: () => SVMAuth,
+  SVMParams: () => SVMParams,
   SvmAccountMeta: () => SvmAccountMeta,
   protobufPackage: () => protobufPackage6
 });
@@ -7283,138 +7485,118 @@ var MsgRegisterSVMPQCKeyResponse = {
     return message;
   }
 };
-var MsgDefinition6 = {
-  name: "Msg",
-  fullName: "qorechain.svm.v1.Msg",
-  methods: {
-    deployProgram: {
-      name: "DeployProgram",
-      requestType: MsgDeployProgram,
-      requestStream: false,
-      responseType: MsgDeployProgramResponse,
-      responseStream: false,
-      options: {}
-    },
-    createAccount: {
-      name: "CreateAccount",
-      requestType: MsgCreateAccount,
-      requestStream: false,
-      responseType: MsgCreateAccountResponse,
-      responseStream: false,
-      options: {}
-    },
-    executeProgram: {
-      name: "ExecuteProgram",
-      requestType: MsgExecuteProgram,
-      requestStream: false,
-      responseType: MsgExecuteProgramResponse,
-      responseStream: false,
-      options: {}
-    },
-    registerSVMPQCKey: {
-      name: "RegisterSVMPQCKey",
-      requestType: MsgRegisterSVMPQCKey,
-      requestStream: false,
-      responseType: MsgRegisterSVMPQCKeyResponse,
-      responseStream: false,
-      options: {}
-    }
-  }
-};
-function bytesFromBase645(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 base64FromBytes5(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 isSet7(value) {
-  return value !== null && value !== void 0;
-}
-
-// src/codegen/qorechain/lightnode/v1/tx.ts
-var tx_exports7 = {};
-__export(tx_exports7, {
-  MsgClaimLightNodeRewards: () => MsgClaimLightNodeRewards,
-  MsgClaimLightNodeRewardsResponse: () => MsgClaimLightNodeRewardsResponse,
-  MsgDefinition: () => MsgDefinition7,
-  MsgDeregisterLightNode: () => MsgDeregisterLightNode,
-  MsgDeregisterLightNodeResponse: () => MsgDeregisterLightNodeResponse,
-  MsgHeartbeat: () => MsgHeartbeat,
-  MsgHeartbeatResponse: () => MsgHeartbeatResponse,
-  MsgRegisterLightNode: () => MsgRegisterLightNode,
-  MsgRegisterLightNodeResponse: () => MsgRegisterLightNodeResponse,
-  protobufPackage: () => protobufPackage7
-});
-var protobufPackage7 = "qorechain.lightnode.v1";
-function createBaseMsgRegisterLightNode() {
-  return { operator: "", nodeType: "", version: "", capabilities: [] };
+function createBaseSVMParams() {
+  return {
+    maxProgramSize: "0",
+    maxAccountDataSize: "0",
+    computeBudgetMax: "0",
+    lamportsPerByte: "0",
+    rentExemptionMulti: "",
+    enabled: false,
+    svmSlotOffset: "0",
+    defaultSigScheme: 0,
+    maxCpi: 0
+  };
 }
-var MsgRegisterLightNode = {
+var SVMParams = {
   encode(message, writer = new wire.BinaryWriter()) {
-    if (message.operator !== "") {
-      writer.uint32(10).string(message.operator);
+    if (message.maxProgramSize !== "0") {
+      writer.uint32(8).uint64(message.maxProgramSize);
     }
-    if (message.nodeType !== "") {
-      writer.uint32(18).string(message.nodeType);
+    if (message.maxAccountDataSize !== "0") {
+      writer.uint32(16).uint64(message.maxAccountDataSize);
     }
-    if (message.version !== "") {
-      writer.uint32(26).string(message.version);
+    if (message.computeBudgetMax !== "0") {
+      writer.uint32(24).uint64(message.computeBudgetMax);
     }
-    for (const v of message.capabilities) {
-      writer.uint32(34).string(v);
+    if (message.lamportsPerByte !== "0") {
+      writer.uint32(32).uint64(message.lamportsPerByte);
     }
-    return writer;
+    if (message.rentExemptionMulti !== "") {
+      writer.uint32(42).string(message.rentExemptionMulti);
+    }
+    if (message.enabled !== false) {
+      writer.uint32(48).bool(message.enabled);
+    }
+    if (message.svmSlotOffset !== "0") {
+      writer.uint32(56).int64(message.svmSlotOffset);
+    }
+    if (message.defaultSigScheme !== 0) {
+      writer.uint32(64).uint32(message.defaultSigScheme);
+    }
+    if (message.maxCpi !== 0) {
+      writer.uint32(72).uint32(message.maxCpi);
+    }
+    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 = createBaseMsgRegisterLightNode();
+    const message = createBaseSVMParams();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
         case 1: {
-          if (tag !== 10) {
+          if (tag !== 8) {
             break;
           }
-          message.operator = reader.string();
+          message.maxProgramSize = reader.uint64().toString();
           continue;
         }
         case 2: {
-          if (tag !== 18) {
+          if (tag !== 16) {
             break;
           }
-          message.nodeType = reader.string();
+          message.maxAccountDataSize = reader.uint64().toString();
           continue;
         }
         case 3: {
-          if (tag !== 26) {
+          if (tag !== 24) {
             break;
           }
-          message.version = reader.string();
+          message.computeBudgetMax = reader.uint64().toString();
           continue;
         }
         case 4: {
-          if (tag !== 34) {
+          if (tag !== 32) {
             break;
           }
-          message.capabilities.push(reader.string());
+          message.lamportsPerByte = reader.uint64().toString();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.rentExemptionMulti = reader.string();
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+          message.enabled = reader.bool();
+          continue;
+        }
+        case 7: {
+          if (tag !== 56) {
+            break;
+          }
+          message.svmSlotOffset = reader.int64().toString();
+          continue;
+        }
+        case 8: {
+          if (tag !== 64) {
+            break;
+          }
+          message.defaultSigScheme = reader.uint32();
+          continue;
+        }
+        case 9: {
+          if (tag !== 72) {
+            break;
+          }
+          message.maxCpi = reader.uint32();
           continue;
         }
       }
@@ -7427,89 +7609,82 @@ var MsgRegisterLightNode = {
   },
   fromJSON(object) {
     return {
-      operator: isSet8(object.operator) ? globalThis.String(object.operator) : "",
-      nodeType: isSet8(object.nodeType) ? globalThis.String(object.nodeType) : isSet8(object.node_type) ? globalThis.String(object.node_type) : "",
-      version: isSet8(object.version) ? globalThis.String(object.version) : "",
-      capabilities: globalThis.Array.isArray(object?.capabilities) ? object.capabilities.map((e) => globalThis.String(e)) : []
+      maxProgramSize: isSet7(object.maxProgramSize) ? globalThis.String(object.maxProgramSize) : isSet7(object.max_program_size) ? globalThis.String(object.max_program_size) : "0",
+      maxAccountDataSize: isSet7(object.maxAccountDataSize) ? globalThis.String(object.maxAccountDataSize) : isSet7(object.max_account_data_size) ? globalThis.String(object.max_account_data_size) : "0",
+      computeBudgetMax: isSet7(object.computeBudgetMax) ? globalThis.String(object.computeBudgetMax) : isSet7(object.compute_budget_max) ? globalThis.String(object.compute_budget_max) : "0",
+      lamportsPerByte: isSet7(object.lamportsPerByte) ? globalThis.String(object.lamportsPerByte) : isSet7(object.lamports_per_byte) ? globalThis.String(object.lamports_per_byte) : "0",
+      rentExemptionMulti: isSet7(object.rentExemptionMulti) ? globalThis.String(object.rentExemptionMulti) : isSet7(object.rent_exemption_multi) ? globalThis.String(object.rent_exemption_multi) : "",
+      enabled: isSet7(object.enabled) ? globalThis.Boolean(object.enabled) : false,
+      svmSlotOffset: isSet7(object.svmSlotOffset) ? globalThis.String(object.svmSlotOffset) : isSet7(object.svm_slot_offset) ? globalThis.String(object.svm_slot_offset) : "0",
+      defaultSigScheme: isSet7(object.defaultSigScheme) ? globalThis.Number(object.defaultSigScheme) : isSet7(object.default_sig_scheme) ? globalThis.Number(object.default_sig_scheme) : 0,
+      maxCpi: isSet7(object.maxCpi) ? globalThis.Number(object.maxCpi) : isSet7(object.max_cpi) ? globalThis.Number(object.max_cpi) : 0
     };
   },
   toJSON(message) {
     const obj = {};
-    if (message.operator !== "") {
-      obj.operator = message.operator;
+    if (message.maxProgramSize !== "0") {
+      obj.maxProgramSize = message.maxProgramSize;
     }
-    if (message.nodeType !== "") {
-      obj.nodeType = message.nodeType;
+    if (message.maxAccountDataSize !== "0") {
+      obj.maxAccountDataSize = message.maxAccountDataSize;
     }
-    if (message.version !== "") {
-      obj.version = message.version;
+    if (message.computeBudgetMax !== "0") {
+      obj.computeBudgetMax = message.computeBudgetMax;
     }
-    if (message.capabilities?.length) {
-      obj.capabilities = message.capabilities;
+    if (message.lamportsPerByte !== "0") {
+      obj.lamportsPerByte = message.lamportsPerByte;
     }
-    return obj;
-  },
-  create(base) {
-    return MsgRegisterLightNode.fromPartial(base ?? {});
-  },
-  fromPartial(object) {
-    const message = createBaseMsgRegisterLightNode();
-    message.operator = object.operator ?? "";
-    message.nodeType = object.nodeType ?? "";
-    message.version = object.version ?? "";
-    message.capabilities = object.capabilities?.map((e) => e) || [];
-    return message;
-  }
-};
-function createBaseMsgRegisterLightNodeResponse() {
-  return {};
-}
-var MsgRegisterLightNodeResponse = {
-  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 = createBaseMsgRegisterLightNodeResponse();
-    while (reader.pos < end) {
-      const tag = reader.uint32();
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
+    if (message.rentExemptionMulti !== "") {
+      obj.rentExemptionMulti = message.rentExemptionMulti;
+    }
+    if (message.enabled !== false) {
+      obj.enabled = message.enabled;
+    }
+    if (message.svmSlotOffset !== "0") {
+      obj.svmSlotOffset = message.svmSlotOffset;
+    }
+    if (message.defaultSigScheme !== 0) {
+      obj.defaultSigScheme = Math.round(message.defaultSigScheme);
+    }
+    if (message.maxCpi !== 0) {
+      obj.maxCpi = Math.round(message.maxCpi);
     }
-    return message;
-  },
-  fromJSON(_) {
-    return {};
-  },
-  toJSON(_) {
-    const obj = {};
     return obj;
   },
   create(base) {
-    return MsgRegisterLightNodeResponse.fromPartial(base ?? {});
+    return SVMParams.fromPartial(base ?? {});
   },
-  fromPartial(_) {
-    const message = createBaseMsgRegisterLightNodeResponse();
+  fromPartial(object) {
+    const message = createBaseSVMParams();
+    message.maxProgramSize = object.maxProgramSize ?? "0";
+    message.maxAccountDataSize = object.maxAccountDataSize ?? "0";
+    message.computeBudgetMax = object.computeBudgetMax ?? "0";
+    message.lamportsPerByte = object.lamportsPerByte ?? "0";
+    message.rentExemptionMulti = object.rentExemptionMulti ?? "";
+    message.enabled = object.enabled ?? false;
+    message.svmSlotOffset = object.svmSlotOffset ?? "0";
+    message.defaultSigScheme = object.defaultSigScheme ?? 0;
+    message.maxCpi = object.maxCpi ?? 0;
     return message;
   }
 };
-function createBaseMsgHeartbeat() {
-  return { operator: "" };
+function createBaseMsgUpdateParams() {
+  return { authority: "", params: void 0 };
 }
-var MsgHeartbeat = {
+var MsgUpdateParams = {
   encode(message, writer = new wire.BinaryWriter()) {
-    if (message.operator !== "") {
-      writer.uint32(10).string(message.operator);
+    if (message.authority !== "") {
+      writer.uint32(10).string(message.authority);
+    }
+    if (message.params !== void 0) {
+      SVMParams.encode(message.params, writer.uint32(18).fork()).join();
     }
     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 = createBaseMsgHeartbeat();
+    const message = createBaseMsgUpdateParams();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -7517,7 +7692,14 @@ var MsgHeartbeat = {
           if (tag !== 10) {
             break;
           }
-          message.operator = reader.string();
+          message.authority = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.params = SVMParams.decode(reader, reader.uint32());
           continue;
         }
       }
@@ -7529,35 +7711,42 @@ var MsgHeartbeat = {
     return message;
   },
   fromJSON(object) {
-    return { operator: isSet8(object.operator) ? globalThis.String(object.operator) : "" };
+    return {
+      authority: isSet7(object.authority) ? globalThis.String(object.authority) : "",
+      params: isSet7(object.params) ? SVMParams.fromJSON(object.params) : void 0
+    };
   },
   toJSON(message) {
     const obj = {};
-    if (message.operator !== "") {
-      obj.operator = message.operator;
+    if (message.authority !== "") {
+      obj.authority = message.authority;
+    }
+    if (message.params !== void 0) {
+      obj.params = SVMParams.toJSON(message.params);
     }
     return obj;
   },
   create(base) {
-    return MsgHeartbeat.fromPartial(base ?? {});
+    return MsgUpdateParams.fromPartial(base ?? {});
   },
   fromPartial(object) {
-    const message = createBaseMsgHeartbeat();
-    message.operator = object.operator ?? "";
+    const message = createBaseMsgUpdateParams();
+    message.authority = object.authority ?? "";
+    message.params = object.params !== void 0 && object.params !== null ? SVMParams.fromPartial(object.params) : void 0;
     return message;
   }
 };
-function createBaseMsgHeartbeatResponse() {
+function createBaseMsgUpdateParamsResponse() {
   return {};
 }
-var MsgHeartbeatResponse = {
+var MsgUpdateParamsResponse = {
   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 = createBaseMsgHeartbeatResponse();
+    const message = createBaseMsgUpdateParamsResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       if ((tag & 7) === 4 || tag === 0) {
@@ -7575,27 +7764,124 @@ var MsgHeartbeatResponse = {
     return obj;
   },
   create(base) {
-    return MsgHeartbeatResponse.fromPartial(base ?? {});
+    return MsgUpdateParamsResponse.fromPartial(base ?? {});
   },
   fromPartial(_) {
-    const message = createBaseMsgHeartbeatResponse();
+    const message = createBaseMsgUpdateParamsResponse();
     return message;
   }
 };
-function createBaseMsgDeregisterLightNode() {
-  return { operator: "" };
+var MsgDefinition6 = {
+  name: "Msg",
+  fullName: "qorechain.svm.v1.Msg",
+  methods: {
+    deployProgram: {
+      name: "DeployProgram",
+      requestType: MsgDeployProgram,
+      requestStream: false,
+      responseType: MsgDeployProgramResponse,
+      responseStream: false,
+      options: {}
+    },
+    createAccount: {
+      name: "CreateAccount",
+      requestType: MsgCreateAccount,
+      requestStream: false,
+      responseType: MsgCreateAccountResponse,
+      responseStream: false,
+      options: {}
+    },
+    executeProgram: {
+      name: "ExecuteProgram",
+      requestType: MsgExecuteProgram,
+      requestStream: false,
+      responseType: MsgExecuteProgramResponse,
+      responseStream: false,
+      options: {}
+    },
+    registerSVMPQCKey: {
+      name: "RegisterSVMPQCKey",
+      requestType: MsgRegisterSVMPQCKey,
+      requestStream: false,
+      responseType: MsgRegisterSVMPQCKeyResponse,
+      responseStream: false,
+      options: {}
+    },
+    updateParams: {
+      name: "UpdateParams",
+      requestType: MsgUpdateParams,
+      requestStream: false,
+      responseType: MsgUpdateParamsResponse,
+      responseStream: false,
+      options: {}
+    }
+  }
+};
+function bytesFromBase645(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;
+  }
 }
-var MsgDeregisterLightNode = {
+function base64FromBytes5(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 isSet7(value) {
+  return value !== null && value !== void 0;
+}
+
+// src/codegen/qorechain/lightnode/v1/tx.ts
+var tx_exports7 = {};
+__export(tx_exports7, {
+  MsgClaimLightNodeRewards: () => MsgClaimLightNodeRewards,
+  MsgClaimLightNodeRewardsResponse: () => MsgClaimLightNodeRewardsResponse,
+  MsgDefinition: () => MsgDefinition7,
+  MsgDeregisterLightNode: () => MsgDeregisterLightNode,
+  MsgDeregisterLightNodeResponse: () => MsgDeregisterLightNodeResponse,
+  MsgHeartbeat: () => MsgHeartbeat,
+  MsgHeartbeatResponse: () => MsgHeartbeatResponse,
+  MsgRegisterLightNode: () => MsgRegisterLightNode,
+  MsgRegisterLightNodeResponse: () => MsgRegisterLightNodeResponse,
+  protobufPackage: () => protobufPackage7
+});
+var protobufPackage7 = "qorechain.lightnode.v1";
+function createBaseMsgRegisterLightNode() {
+  return { operator: "", nodeType: "", version: "", capabilities: [] };
+}
+var MsgRegisterLightNode = {
   encode(message, writer = new wire.BinaryWriter()) {
     if (message.operator !== "") {
       writer.uint32(10).string(message.operator);
     }
+    if (message.nodeType !== "") {
+      writer.uint32(18).string(message.nodeType);
+    }
+    if (message.version !== "") {
+      writer.uint32(26).string(message.version);
+    }
+    for (const v of message.capabilities) {
+      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 = createBaseMsgDeregisterLightNode();
+    const message = createBaseMsgRegisterLightNode();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -7606,13 +7892,223 @@ var MsgDeregisterLightNode = {
           message.operator = reader.string();
           continue;
         }
-      }
-      if ((tag & 7) === 4 || tag === 0) {
-        break;
-      }
-      reader.skip(tag & 7);
-    }
-    return message;
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.nodeType = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.version = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.capabilities.push(reader.string());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      operator: isSet8(object.operator) ? globalThis.String(object.operator) : "",
+      nodeType: isSet8(object.nodeType) ? globalThis.String(object.nodeType) : isSet8(object.node_type) ? globalThis.String(object.node_type) : "",
+      version: isSet8(object.version) ? globalThis.String(object.version) : "",
+      capabilities: globalThis.Array.isArray(object?.capabilities) ? object.capabilities.map((e) => globalThis.String(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.operator !== "") {
+      obj.operator = message.operator;
+    }
+    if (message.nodeType !== "") {
+      obj.nodeType = message.nodeType;
+    }
+    if (message.version !== "") {
+      obj.version = message.version;
+    }
+    if (message.capabilities?.length) {
+      obj.capabilities = message.capabilities;
+    }
+    return obj;
+  },
+  create(base) {
+    return MsgRegisterLightNode.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMsgRegisterLightNode();
+    message.operator = object.operator ?? "";
+    message.nodeType = object.nodeType ?? "";
+    message.version = object.version ?? "";
+    message.capabilities = object.capabilities?.map((e) => e) || [];
+    return message;
+  }
+};
+function createBaseMsgRegisterLightNodeResponse() {
+  return {};
+}
+var MsgRegisterLightNodeResponse = {
+  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 = createBaseMsgRegisterLightNodeResponse();
+    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 MsgRegisterLightNodeResponse.fromPartial(base ?? {});
+  },
+  fromPartial(_) {
+    const message = createBaseMsgRegisterLightNodeResponse();
+    return message;
+  }
+};
+function createBaseMsgHeartbeat() {
+  return { operator: "" };
+}
+var MsgHeartbeat = {
+  encode(message, writer = new wire.BinaryWriter()) {
+    if (message.operator !== "") {
+      writer.uint32(10).string(message.operator);
+    }
+    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 = createBaseMsgHeartbeat();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.operator = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { operator: isSet8(object.operator) ? globalThis.String(object.operator) : "" };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.operator !== "") {
+      obj.operator = message.operator;
+    }
+    return obj;
+  },
+  create(base) {
+    return MsgHeartbeat.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMsgHeartbeat();
+    message.operator = object.operator ?? "";
+    return message;
+  }
+};
+function createBaseMsgHeartbeatResponse() {
+  return {};
+}
+var MsgHeartbeatResponse = {
+  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 = createBaseMsgHeartbeatResponse();
+    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 MsgHeartbeatResponse.fromPartial(base ?? {});
+  },
+  fromPartial(_) {
+    const message = createBaseMsgHeartbeatResponse();
+    return message;
+  }
+};
+function createBaseMsgDeregisterLightNode() {
+  return { operator: "" };
+}
+var MsgDeregisterLightNode = {
+  encode(message, writer = new wire.BinaryWriter()) {
+    if (message.operator !== "") {
+      writer.uint32(10).string(message.operator);
+    }
+    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 = createBaseMsgDeregisterLightNode();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.operator = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
   },
   fromJSON(object) {
     return { operator: isSet8(object.operator) ? globalThis.String(object.operator) : "" };
@@ -8361,6 +8857,10 @@ __export(tx_exports9, {
   MsgCreateAbstractAccount: () => MsgCreateAbstractAccount,
   MsgCreateAbstractAccountResponse: () => MsgCreateAbstractAccountResponse,
   MsgDefinition: () => MsgDefinition9,
+  MsgExecuteCosmos: () => MsgExecuteCosmos,
+  MsgExecuteCosmosResponse: () => MsgExecuteCosmosResponse,
+  MsgExecuteEVM: () => MsgExecuteEVM,
+  MsgExecuteEVMResponse: () => MsgExecuteEVMResponse,
   MsgRegisterAuthenticator: () => MsgRegisterAuthenticator,
   MsgRegisterAuthenticatorResponse: () => MsgRegisterAuthenticatorResponse,
   MsgRevokeAuthenticator: () => MsgRevokeAuthenticator,
@@ -8508,14 +9008,309 @@ var MsgCreateAbstractAccount = {
           if (tag !== 10) {
             break;
           }
-          message.owner = reader.string();
+          message.owner = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.accountType = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      owner: isSet10(object.owner) ? globalThis.String(object.owner) : "",
+      accountType: isSet10(object.accountType) ? globalThis.String(object.accountType) : isSet10(object.account_type) ? globalThis.String(object.account_type) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.owner !== "") {
+      obj.owner = message.owner;
+    }
+    if (message.accountType !== "") {
+      obj.accountType = message.accountType;
+    }
+    return obj;
+  },
+  create(base) {
+    return MsgCreateAbstractAccount.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMsgCreateAbstractAccount();
+    message.owner = object.owner ?? "";
+    message.accountType = object.accountType ?? "";
+    return message;
+  }
+};
+function createBaseMsgCreateAbstractAccountResponse() {
+  return { address: "" };
+}
+var MsgCreateAbstractAccountResponse = {
+  encode(message, writer = new wire.BinaryWriter()) {
+    if (message.address !== "") {
+      writer.uint32(10).string(message.address);
+    }
+    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 = createBaseMsgCreateAbstractAccountResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.address = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return { address: isSet10(object.address) ? globalThis.String(object.address) : "" };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.address !== "") {
+      obj.address = message.address;
+    }
+    return obj;
+  },
+  create(base) {
+    return MsgCreateAbstractAccountResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMsgCreateAbstractAccountResponse();
+    message.address = object.address ?? "";
+    return message;
+  }
+};
+function createBaseMsgUpdateSpendingRules() {
+  return { owner: "", accountAddress: "", rules: [] };
+}
+var MsgUpdateSpendingRules = {
+  encode(message, writer = new wire.BinaryWriter()) {
+    if (message.owner !== "") {
+      writer.uint32(10).string(message.owner);
+    }
+    if (message.accountAddress !== "") {
+      writer.uint32(18).string(message.accountAddress);
+    }
+    for (const v of message.rules) {
+      SpendingRule.encode(v, writer.uint32(26).fork()).join();
+    }
+    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 = createBaseMsgUpdateSpendingRules();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.owner = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.accountAddress = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.rules.push(SpendingRule.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      owner: isSet10(object.owner) ? globalThis.String(object.owner) : "",
+      accountAddress: isSet10(object.accountAddress) ? globalThis.String(object.accountAddress) : isSet10(object.account_address) ? globalThis.String(object.account_address) : "",
+      rules: globalThis.Array.isArray(object?.rules) ? object.rules.map((e) => SpendingRule.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.owner !== "") {
+      obj.owner = message.owner;
+    }
+    if (message.accountAddress !== "") {
+      obj.accountAddress = message.accountAddress;
+    }
+    if (message.rules?.length) {
+      obj.rules = message.rules.map((e) => SpendingRule.toJSON(e));
+    }
+    return obj;
+  },
+  create(base) {
+    return MsgUpdateSpendingRules.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseMsgUpdateSpendingRules();
+    message.owner = object.owner ?? "";
+    message.accountAddress = object.accountAddress ?? "";
+    message.rules = object.rules?.map((e) => SpendingRule.fromPartial(e)) || [];
+    return message;
+  }
+};
+function createBaseMsgUpdateSpendingRulesResponse() {
+  return {};
+}
+var MsgUpdateSpendingRulesResponse = {
+  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 = createBaseMsgUpdateSpendingRulesResponse();
+    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 MsgUpdateSpendingRulesResponse.fromPartial(base ?? {});
+  },
+  fromPartial(_) {
+    const message = createBaseMsgUpdateSpendingRulesResponse();
+    return message;
+  }
+};
+function createBaseMsgRegisterAuthenticator() {
+  return {
+    owner: "",
+    accountAddress: "",
+    scheme: "",
+    pubkey: new Uint8Array(0),
+    permissions: [],
+    expiryUnix: "0",
+    label: ""
+  };
+}
+var MsgRegisterAuthenticator = {
+  encode(message, writer = new wire.BinaryWriter()) {
+    if (message.owner !== "") {
+      writer.uint32(10).string(message.owner);
+    }
+    if (message.accountAddress !== "") {
+      writer.uint32(18).string(message.accountAddress);
+    }
+    if (message.scheme !== "") {
+      writer.uint32(26).string(message.scheme);
+    }
+    if (message.pubkey.length !== 0) {
+      writer.uint32(34).bytes(message.pubkey);
+    }
+    for (const v of message.permissions) {
+      writer.uint32(42).string(v);
+    }
+    if (message.expiryUnix !== "0") {
+      writer.uint32(48).int64(message.expiryUnix);
+    }
+    if (message.label !== "") {
+      writer.uint32(58).string(message.label);
+    }
+    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 = createBaseMsgRegisterAuthenticator();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.owner = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.accountAddress = 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 2: {
-          if (tag !== 18) {
+        case 5: {
+          if (tag !== 42) {
             break;
           }
-          message.accountType = reader.string();
+          message.permissions.push(reader.string());
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+          message.expiryUnix = reader.int64().toString();
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.label = reader.string();
           continue;
         }
       }
@@ -8529,7 +9324,12 @@ var MsgCreateAbstractAccount = {
   fromJSON(object) {
     return {
       owner: isSet10(object.owner) ? globalThis.String(object.owner) : "",
-      accountType: isSet10(object.accountType) ? globalThis.String(object.accountType) : isSet10(object.account_type) ? globalThis.String(object.account_type) : ""
+      accountAddress: isSet10(object.accountAddress) ? globalThis.String(object.accountAddress) : isSet10(object.account_address) ? globalThis.String(object.account_address) : "",
+      scheme: isSet10(object.scheme) ? globalThis.String(object.scheme) : "",
+      pubkey: isSet10(object.pubkey) ? bytesFromBase646(object.pubkey) : new Uint8Array(0),
+      permissions: globalThis.Array.isArray(object?.permissions) ? object.permissions.map((e) => globalThis.String(e)) : [],
+      expiryUnix: isSet10(object.expiryUnix) ? globalThis.String(object.expiryUnix) : isSet10(object.expiry_unix) ? globalThis.String(object.expiry_unix) : "0",
+      label: isSet10(object.label) ? globalThis.String(object.label) : ""
     };
   },
   toJSON(message) {
@@ -8537,46 +9337,54 @@ var MsgCreateAbstractAccount = {
     if (message.owner !== "") {
       obj.owner = message.owner;
     }
-    if (message.accountType !== "") {
-      obj.accountType = message.accountType;
+    if (message.accountAddress !== "") {
+      obj.accountAddress = message.accountAddress;
+    }
+    if (message.scheme !== "") {
+      obj.scheme = message.scheme;
+    }
+    if (message.pubkey.length !== 0) {
+      obj.pubkey = base64FromBytes6(message.pubkey);
+    }
+    if (message.permissions?.length) {
+      obj.permissions = message.permissions;
+    }
+    if (message.expiryUnix !== "0") {
+      obj.expiryUnix = message.expiryUnix;
+    }
+    if (message.label !== "") {
+      obj.label = message.label;
     }
     return obj;
   },
   create(base) {
-    return MsgCreateAbstractAccount.fromPartial(base ?? {});
+    return MsgRegisterAuthenticator.fromPartial(base ?? {});
   },
   fromPartial(object) {
-    const message = createBaseMsgCreateAbstractAccount();
+    const message = createBaseMsgRegisterAuthenticator();
     message.owner = object.owner ?? "";
-    message.accountType = object.accountType ?? "";
+    message.accountAddress = object.accountAddress ?? "";
+    message.scheme = object.scheme ?? "";
+    message.pubkey = object.pubkey ?? new Uint8Array(0);
+    message.permissions = object.permissions?.map((e) => e) || [];
+    message.expiryUnix = object.expiryUnix ?? "0";
+    message.label = object.label ?? "";
     return message;
   }
 };
-function createBaseMsgCreateAbstractAccountResponse() {
-  return { address: "" };
+function createBaseMsgRegisterAuthenticatorResponse() {
+  return {};
 }
-var MsgCreateAbstractAccountResponse = {
-  encode(message, writer = new wire.BinaryWriter()) {
-    if (message.address !== "") {
-      writer.uint32(10).string(message.address);
-    }
+var MsgRegisterAuthenticatorResponse = {
+  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 = createBaseMsgCreateAbstractAccountResponse();
+    const message = createBaseMsgRegisterAuthenticatorResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
-      switch (tag >>> 3) {
-        case 1: {
-          if (tag !== 10) {
-            break;
-          }
-          message.address = reader.string();
-          continue;
-        }
-      }
       if ((tag & 7) === 4 || tag === 0) {
         break;
       }
@@ -8584,29 +9392,25 @@ var MsgCreateAbstractAccountResponse = {
     }
     return message;
   },
-  fromJSON(object) {
-    return { address: isSet10(object.address) ? globalThis.String(object.address) : "" };
+  fromJSON(_) {
+    return {};
   },
-  toJSON(message) {
+  toJSON(_) {
     const obj = {};
-    if (message.address !== "") {
-      obj.address = message.address;
-    }
     return obj;
   },
   create(base) {
-    return MsgCreateAbstractAccountResponse.fromPartial(base ?? {});
+    return MsgRegisterAuthenticatorResponse.fromPartial(base ?? {});
   },
-  fromPartial(object) {
-    const message = createBaseMsgCreateAbstractAccountResponse();
-    message.address = object.address ?? "";
+  fromPartial(_) {
+    const message = createBaseMsgRegisterAuthenticatorResponse();
     return message;
   }
 };
-function createBaseMsgUpdateSpendingRules() {
-  return { owner: "", accountAddress: "", rules: [] };
+function createBaseMsgRevokeAuthenticator() {
+  return { owner: "", accountAddress: "", scheme: "", pubkey: new Uint8Array(0) };
 }
-var MsgUpdateSpendingRules = {
+var MsgRevokeAuthenticator = {
   encode(message, writer = new wire.BinaryWriter()) {
     if (message.owner !== "") {
       writer.uint32(10).string(message.owner);
@@ -8614,15 +9418,18 @@ var MsgUpdateSpendingRules = {
     if (message.accountAddress !== "") {
       writer.uint32(18).string(message.accountAddress);
     }
-    for (const v of message.rules) {
-      SpendingRule.encode(v, writer.uint32(26).fork()).join();
+    if (message.scheme !== "") {
+      writer.uint32(26).string(message.scheme);
+    }
+    if (message.pubkey.length !== 0) {
+      writer.uint32(34).bytes(message.pubkey);
     }
     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 = createBaseMsgUpdateSpendingRules();
+    const message = createBaseMsgRevokeAuthenticator();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -8644,7 +9451,14 @@ var MsgUpdateSpendingRules = {
           if (tag !== 26) {
             break;
           }
-          message.rules.push(SpendingRule.decode(reader, reader.uint32()));
+          message.scheme = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.pubkey = reader.bytes();
           continue;
         }
       }
@@ -8659,7 +9473,8 @@ var MsgUpdateSpendingRules = {
     return {
       owner: isSet10(object.owner) ? globalThis.String(object.owner) : "",
       accountAddress: isSet10(object.accountAddress) ? globalThis.String(object.accountAddress) : isSet10(object.account_address) ? globalThis.String(object.account_address) : "",
-      rules: globalThis.Array.isArray(object?.rules) ? object.rules.map((e) => SpendingRule.fromJSON(e)) : []
+      scheme: isSet10(object.scheme) ? globalThis.String(object.scheme) : "",
+      pubkey: isSet10(object.pubkey) ? bytesFromBase646(object.pubkey) : new Uint8Array(0)
     };
   },
   toJSON(message) {
@@ -8670,33 +9485,37 @@ var MsgUpdateSpendingRules = {
     if (message.accountAddress !== "") {
       obj.accountAddress = message.accountAddress;
     }
-    if (message.rules?.length) {
-      obj.rules = message.rules.map((e) => SpendingRule.toJSON(e));
+    if (message.scheme !== "") {
+      obj.scheme = message.scheme;
+    }
+    if (message.pubkey.length !== 0) {
+      obj.pubkey = base64FromBytes6(message.pubkey);
     }
     return obj;
   },
   create(base) {
-    return MsgUpdateSpendingRules.fromPartial(base ?? {});
+    return MsgRevokeAuthenticator.fromPartial(base ?? {});
   },
   fromPartial(object) {
-    const message = createBaseMsgUpdateSpendingRules();
+    const message = createBaseMsgRevokeAuthenticator();
     message.owner = object.owner ?? "";
     message.accountAddress = object.accountAddress ?? "";
-    message.rules = object.rules?.map((e) => SpendingRule.fromPartial(e)) || [];
+    message.scheme = object.scheme ?? "";
+    message.pubkey = object.pubkey ?? new Uint8Array(0);
     return message;
   }
 };
-function createBaseMsgUpdateSpendingRulesResponse() {
+function createBaseMsgRevokeAuthenticatorResponse() {
   return {};
 }
-var MsgUpdateSpendingRulesResponse = {
+var MsgRevokeAuthenticatorResponse = {
   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 = createBaseMsgUpdateSpendingRulesResponse();
+    const message = createBaseMsgRevokeAuthenticatorResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
       if ((tag & 7) === 4 || tag === 0) {
@@ -8714,31 +9533,34 @@ var MsgUpdateSpendingRulesResponse = {
     return obj;
   },
   create(base) {
-    return MsgUpdateSpendingRulesResponse.fromPartial(base ?? {});
+    return MsgRevokeAuthenticatorResponse.fromPartial(base ?? {});
   },
   fromPartial(_) {
-    const message = createBaseMsgUpdateSpendingRulesResponse();
+    const message = createBaseMsgRevokeAuthenticatorResponse();
     return message;
   }
 };
-function createBaseMsgRegisterAuthenticator() {
+function createBaseMsgExecuteEVM() {
   return {
-    owner: "",
-    accountAddress: "",
+    relayer: "",
+    account: "",
     scheme: "",
     pubkey: new Uint8Array(0),
-    permissions: [],
-    expiryUnix: "0",
-    label: ""
+    signature: new Uint8Array(0),
+    to: "",
+    value: "",
+    data: new Uint8Array(0),
+    gasLimit: "0",
+    nonce: "0"
   };
 }
-var MsgRegisterAuthenticator = {
+var MsgExecuteEVM = {
   encode(message, writer = new wire.BinaryWriter()) {
-    if (message.owner !== "") {
-      writer.uint32(10).string(message.owner);
+    if (message.relayer !== "") {
+      writer.uint32(10).string(message.relayer);
     }
-    if (message.accountAddress !== "") {
-      writer.uint32(18).string(message.accountAddress);
+    if (message.account !== "") {
+      writer.uint32(18).string(message.account);
     }
     if (message.scheme !== "") {
       writer.uint32(26).string(message.scheme);
@@ -8746,21 +9568,30 @@ var MsgRegisterAuthenticator = {
     if (message.pubkey.length !== 0) {
       writer.uint32(34).bytes(message.pubkey);
     }
-    for (const v of message.permissions) {
-      writer.uint32(42).string(v);
+    if (message.signature.length !== 0) {
+      writer.uint32(42).bytes(message.signature);
     }
-    if (message.expiryUnix !== "0") {
-      writer.uint32(48).int64(message.expiryUnix);
+    if (message.to !== "") {
+      writer.uint32(50).string(message.to);
     }
-    if (message.label !== "") {
-      writer.uint32(58).string(message.label);
+    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 = createBaseMsgRegisterAuthenticator();
+    const message = createBaseMsgExecuteEVM();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -8768,14 +9599,14 @@ var MsgRegisterAuthenticator = {
           if (tag !== 10) {
             break;
           }
-          message.owner = reader.string();
+          message.relayer = reader.string();
           continue;
         }
         case 2: {
           if (tag !== 18) {
             break;
           }
-          message.accountAddress = reader.string();
+          message.account = reader.string();
           continue;
         }
         case 3: {
@@ -8796,21 +9627,42 @@ var MsgRegisterAuthenticator = {
           if (tag !== 42) {
             break;
           }
-          message.permissions.push(reader.string());
+          message.signature = reader.bytes();
           continue;
         }
         case 6: {
-          if (tag !== 48) {
+          if (tag !== 50) {
             break;
           }
-          message.expiryUnix = reader.int64().toString();
+          message.to = reader.string();
           continue;
         }
         case 7: {
           if (tag !== 58) {
             break;
           }
-          message.label = reader.string();
+          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;
         }
       }
@@ -8823,22 +9675,25 @@ var MsgRegisterAuthenticator = {
   },
   fromJSON(object) {
     return {
-      owner: isSet10(object.owner) ? globalThis.String(object.owner) : "",
-      accountAddress: isSet10(object.accountAddress) ? globalThis.String(object.accountAddress) : isSet10(object.account_address) ? globalThis.String(object.account_address) : "",
+      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),
-      permissions: globalThis.Array.isArray(object?.permissions) ? object.permissions.map((e) => globalThis.String(e)) : [],
-      expiryUnix: isSet10(object.expiryUnix) ? globalThis.String(object.expiryUnix) : isSet10(object.expiry_unix) ? globalThis.String(object.expiry_unix) : "0",
-      label: isSet10(object.label) ? globalThis.String(object.label) : ""
+      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.owner !== "") {
-      obj.owner = message.owner;
+    if (message.relayer !== "") {
+      obj.relayer = message.relayer;
     }
-    if (message.accountAddress !== "") {
-      obj.accountAddress = message.accountAddress;
+    if (message.account !== "") {
+      obj.account = message.account;
     }
     if (message.scheme !== "") {
       obj.scheme = message.scheme;
@@ -8846,45 +9701,99 @@ var MsgRegisterAuthenticator = {
     if (message.pubkey.length !== 0) {
       obj.pubkey = base64FromBytes6(message.pubkey);
     }
-    if (message.permissions?.length) {
-      obj.permissions = message.permissions;
+    if (message.signature.length !== 0) {
+      obj.signature = base64FromBytes6(message.signature);
     }
-    if (message.expiryUnix !== "0") {
-      obj.expiryUnix = message.expiryUnix;
+    if (message.to !== "") {
+      obj.to = message.to;
     }
-    if (message.label !== "") {
-      obj.label = message.label;
+    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 MsgRegisterAuthenticator.fromPartial(base ?? {});
+    return MsgExecuteEVM.fromPartial(base ?? {});
   },
   fromPartial(object) {
-    const message = createBaseMsgRegisterAuthenticator();
-    message.owner = object.owner ?? "";
-    message.accountAddress = object.accountAddress ?? "";
+    const message = createBaseMsgExecuteEVM();
+    message.relayer = object.relayer ?? "";
+    message.account = object.account ?? "";
     message.scheme = object.scheme ?? "";
     message.pubkey = object.pubkey ?? new Uint8Array(0);
-    message.permissions = object.permissions?.map((e) => e) || [];
-    message.expiryUnix = object.expiryUnix ?? "0";
-    message.label = object.label ?? "";
+    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 createBaseMsgRegisterAuthenticatorResponse() {
-  return {};
+function createBaseMsgExecuteEVMResponse() {
+  return { success: false, ret: new Uint8Array(0), gasUsed: "0", vmError: "" };
 }
-var MsgRegisterAuthenticatorResponse = {
-  encode(_, writer = new wire.BinaryWriter()) {
+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 = createBaseMsgRegisterAuthenticatorResponse();
+    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;
       }
@@ -8892,31 +9801,61 @@ var MsgRegisterAuthenticatorResponse = {
     }
     return message;
   },
-  fromJSON(_) {
-    return {};
+  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(_) {
+  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 MsgRegisterAuthenticatorResponse.fromPartial(base ?? {});
+    return MsgExecuteEVMResponse.fromPartial(base ?? {});
   },
-  fromPartial(_) {
-    const message = createBaseMsgRegisterAuthenticatorResponse();
+  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 createBaseMsgRevokeAuthenticator() {
-  return { owner: "", accountAddress: "", scheme: "", pubkey: new Uint8Array(0) };
+function createBaseMsgExecuteCosmos() {
+  return {
+    relayer: "",
+    account: "",
+    scheme: "",
+    pubkey: new Uint8Array(0),
+    signature: new Uint8Array(0),
+    to: "",
+    amount: [],
+    nonce: "0"
+  };
 }
-var MsgRevokeAuthenticator = {
+var MsgExecuteCosmos = {
   encode(message, writer = new wire.BinaryWriter()) {
-    if (message.owner !== "") {
-      writer.uint32(10).string(message.owner);
+    if (message.relayer !== "") {
+      writer.uint32(10).string(message.relayer);
     }
-    if (message.accountAddress !== "") {
-      writer.uint32(18).string(message.accountAddress);
+    if (message.account !== "") {
+      writer.uint32(18).string(message.account);
     }
     if (message.scheme !== "") {
       writer.uint32(26).string(message.scheme);
@@ -8924,12 +9863,24 @@ var MsgRevokeAuthenticator = {
     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 = createBaseMsgRevokeAuthenticator();
+    const message = createBaseMsgExecuteCosmos();
     while (reader.pos < end) {
       const tag = reader.uint32();
       switch (tag >>> 3) {
@@ -8937,14 +9888,14 @@ var MsgRevokeAuthenticator = {
           if (tag !== 10) {
             break;
           }
-          message.owner = reader.string();
+          message.relayer = reader.string();
           continue;
         }
         case 2: {
           if (tag !== 18) {
             break;
           }
-          message.accountAddress = reader.string();
+          message.account = reader.string();
           continue;
         }
         case 3: {
@@ -8961,6 +9912,34 @@ var MsgRevokeAuthenticator = {
           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;
@@ -8971,19 +9950,23 @@ var MsgRevokeAuthenticator = {
   },
   fromJSON(object) {
     return {
-      owner: isSet10(object.owner) ? globalThis.String(object.owner) : "",
-      accountAddress: isSet10(object.accountAddress) ? globalThis.String(object.accountAddress) : isSet10(object.account_address) ? globalThis.String(object.account_address) : "",
+      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)
+      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.owner !== "") {
-      obj.owner = message.owner;
+    if (message.relayer !== "") {
+      obj.relayer = message.relayer;
     }
-    if (message.accountAddress !== "") {
-      obj.accountAddress = message.accountAddress;
+    if (message.account !== "") {
+      obj.account = message.account;
     }
     if (message.scheme !== "") {
       obj.scheme = message.scheme;
@@ -8991,33 +9974,61 @@ var MsgRevokeAuthenticator = {
     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 MsgRevokeAuthenticator.fromPartial(base ?? {});
+    return MsgExecuteCosmos.fromPartial(base ?? {});
   },
   fromPartial(object) {
-    const message = createBaseMsgRevokeAuthenticator();
-    message.owner = object.owner ?? "";
-    message.accountAddress = object.accountAddress ?? "";
+    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 createBaseMsgRevokeAuthenticatorResponse() {
-  return {};
+function createBaseMsgExecuteCosmosResponse() {
+  return { success: false };
 }
-var MsgRevokeAuthenticatorResponse = {
-  encode(_, writer = new wire.BinaryWriter()) {
+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 = createBaseMsgRevokeAuthenticatorResponse();
+    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;
       }
@@ -9025,18 +10036,22 @@ var MsgRevokeAuthenticatorResponse = {
     }
     return message;
   },
-  fromJSON(_) {
-    return {};
+  fromJSON(object) {
+    return { success: isSet10(object.success) ? globalThis.Boolean(object.success) : false };
   },
-  toJSON(_) {
+  toJSON(message) {
     const obj = {};
+    if (message.success !== false) {
+      obj.success = message.success;
+    }
     return obj;
   },
   create(base) {
-    return MsgRevokeAuthenticatorResponse.fromPartial(base ?? {});
+    return MsgExecuteCosmosResponse.fromPartial(base ?? {});
   },
-  fromPartial(_) {
-    const message = createBaseMsgRevokeAuthenticatorResponse();
+  fromPartial(object) {
+    const message = createBaseMsgExecuteCosmosResponse();
+    message.success = object.success ?? false;
     return message;
   }
 };
@@ -9075,6 +10090,22 @@ var MsgDefinition9 = {
       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: {}
     }
   }
 };
@@ -9117,7 +10148,15 @@ __export(tx_exports10, {
 });
 var protobufPackage10 = "qorechain.crossvm.v1";
 function createBaseMsgCrossVMCall() {
-  return { sender: "", sourceVm: "", targetVm: "", targetContract: "", payload: new Uint8Array(0), funds: [] };
+  return {
+    sender: "",
+    sourceVm: "",
+    targetVm: "",
+    targetContract: "",
+    payload: new Uint8Array(0),
+    funds: [],
+    async: false
+  };
 }
 var MsgCrossVMCall = {
   encode(message, writer = new wire.BinaryWriter()) {
@@ -9139,6 +10178,9 @@ var MsgCrossVMCall = {
     for (const v of message.funds) {
       Coin.encode(v, writer.uint32(50).fork()).join();
     }
+    if (message.async !== false) {
+      writer.uint32(56).bool(message.async);
+    }
     return writer;
   },
   decode(input, length) {
@@ -9190,6 +10232,13 @@ var MsgCrossVMCall = {
           message.funds.push(Coin.decode(reader, reader.uint32()));
           continue;
         }
+        case 7: {
+          if (tag !== 56) {
+            break;
+          }
+          message.async = reader.bool();
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -9205,7 +10254,8 @@ var MsgCrossVMCall = {
       targetVm: isSet11(object.targetVm) ? globalThis.String(object.targetVm) : isSet11(object.target_vm) ? globalThis.String(object.target_vm) : "",
       targetContract: isSet11(object.targetContract) ? globalThis.String(object.targetContract) : isSet11(object.target_contract) ? globalThis.String(object.target_contract) : "",
       payload: isSet11(object.payload) ? bytesFromBase647(object.payload) : new Uint8Array(0),
-      funds: globalThis.Array.isArray(object?.funds) ? object.funds.map((e) => Coin.fromJSON(e)) : []
+      funds: globalThis.Array.isArray(object?.funds) ? object.funds.map((e) => Coin.fromJSON(e)) : [],
+      async: isSet11(object.async) ? globalThis.Boolean(object.async) : false
     };
   },
   toJSON(message) {
@@ -9228,6 +10278,9 @@ var MsgCrossVMCall = {
     if (message.funds?.length) {
       obj.funds = message.funds.map((e) => Coin.toJSON(e));
     }
+    if (message.async !== false) {
+      obj.async = message.async;
+    }
     return obj;
   },
   create(base) {
@@ -9241,17 +10294,27 @@ var MsgCrossVMCall = {
     message.targetContract = object.targetContract ?? "";
     message.payload = object.payload ?? new Uint8Array(0);
     message.funds = object.funds?.map((e) => Coin.fromPartial(e)) || [];
+    message.async = object.async ?? false;
     return message;
   }
 };
 function createBaseMsgCrossVMCallResponse() {
-  return { messageId: "" };
+  return { messageId: "", executed: false, data: new Uint8Array(0), gasUsed: "0" };
 }
 var MsgCrossVMCallResponse = {
   encode(message, writer = new wire.BinaryWriter()) {
     if (message.messageId !== "") {
       writer.uint32(10).string(message.messageId);
     }
+    if (message.executed !== false) {
+      writer.uint32(16).bool(message.executed);
+    }
+    if (message.data.length !== 0) {
+      writer.uint32(26).bytes(message.data);
+    }
+    if (message.gasUsed !== "0") {
+      writer.uint32(32).uint64(message.gasUsed);
+    }
     return writer;
   },
   decode(input, length) {
@@ -9268,6 +10331,27 @@ var MsgCrossVMCallResponse = {
           message.messageId = reader.string();
           continue;
         }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.executed = reader.bool();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.data = reader.bytes();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.gasUsed = reader.uint64().toString();
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -9278,7 +10362,10 @@ var MsgCrossVMCallResponse = {
   },
   fromJSON(object) {
     return {
-      messageId: isSet11(object.messageId) ? globalThis.String(object.messageId) : isSet11(object.message_id) ? globalThis.String(object.message_id) : ""
+      messageId: isSet11(object.messageId) ? globalThis.String(object.messageId) : isSet11(object.message_id) ? globalThis.String(object.message_id) : "",
+      executed: isSet11(object.executed) ? globalThis.Boolean(object.executed) : false,
+      data: isSet11(object.data) ? bytesFromBase647(object.data) : new Uint8Array(0),
+      gasUsed: isSet11(object.gasUsed) ? globalThis.String(object.gasUsed) : isSet11(object.gas_used) ? globalThis.String(object.gas_used) : "0"
     };
   },
   toJSON(message) {
@@ -9286,6 +10373,15 @@ var MsgCrossVMCallResponse = {
     if (message.messageId !== "") {
       obj.messageId = message.messageId;
     }
+    if (message.executed !== false) {
+      obj.executed = message.executed;
+    }
+    if (message.data.length !== 0) {
+      obj.data = base64FromBytes7(message.data);
+    }
+    if (message.gasUsed !== "0") {
+      obj.gasUsed = message.gasUsed;
+    }
     return obj;
   },
   create(base) {
@@ -9294,6 +10390,9 @@ var MsgCrossVMCallResponse = {
   fromPartial(object) {
     const message = createBaseMsgCrossVMCallResponse();
     message.messageId = object.messageId ?? "";
+    message.executed = object.executed ?? false;
+    message.data = object.data ?? new Uint8Array(0);
+    message.gasUsed = object.gasUsed ?? "0";
     return message;
   }
 };
@@ -9387,7 +10486,11 @@ var MsgDefinition10 = {
   name: "Msg",
   fullName: "qorechain.crossvm.v1.Msg",
   methods: {
-    /** CrossVMCall submits a cross-VM message to the queue. */
+    /**
+     * CrossVMCall invokes a contract on another VM. It executes within the
+     * transaction and returns the callee's answer, unless async is set, in which
+     * case it is queued for ProcessQueue to dispatch later.
+     */
     crossVMCall: {
       name: "CrossVMCall",
       requestType: MsgCrossVMCall,
@@ -10003,6 +11106,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
@@ -10010,6 +11114,7 @@ var qorechainRegistryTypes = [
   ["/qorechain.svm.v1.MsgCreateAccount", MsgCreateAccount],
   ["/qorechain.svm.v1.MsgExecuteProgram", MsgExecuteProgram],
   ["/qorechain.svm.v1.MsgRegisterSVMPQCKey", MsgRegisterSVMPQCKey],
+  ["/qorechain.svm.v1.MsgUpdateParams", MsgUpdateParams],
   // lightnode
   ["/qorechain.lightnode.v1.MsgRegisterLightNode", MsgRegisterLightNode],
   ["/qorechain.lightnode.v1.MsgHeartbeat", MsgHeartbeat],
@@ -10043,6 +11148,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 +11201,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 +11244,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 {
@@ -10313,7 +11462,12 @@ var TxClient = class _TxClient {
         height: res.height,
         gasUsed: res.gasUsed,
         gasWanted: res.gasWanted,
-        rawLog: res.rawLog
+        rawLog: res.rawLog,
+        // Carried through so callers can read typed attributes / decode the
+        // per-message responses (e.g. MsgCrossVMCallResponse) without a
+        // second round-trip.
+        events: res.events,
+        msgResponses: res.msgResponses
       };
     }
     const hash = await this.client.signAndBroadcastSync(
@@ -10941,9 +12095,16 @@ function generatePqcKeypair(seed) {
   return { publicKey: kp.publicKey, secretKey: kp.secretKey };
 }
 function pqcSign(secretKey, message, opts) {
+  if (secretKey.length !== ML_DSA_87_SECRET_KEY_LENGTH) {
+    throw new Error(
+      `ML-DSA-87 secret key must be ${ML_DSA_87_SECRET_KEY_LENGTH} bytes, got ${secretKey.length}`
+    );
+  }
   return pqc$1.mldsa87.sign(secretKey, message, opts);
 }
 function pqcVerify(publicKey, message, signature) {
+  if (publicKey.length !== ML_DSA_87_PUBLIC_KEY_LENGTH) return false;
+  if (signature.length !== ML_DSA_87_SIGNATURE_LENGTH) return false;
   return pqc$1.mldsa87.verify(publicKey, message, signature);
 }
 function buildHybridSignatureExtension(args) {
@@ -11154,37 +12315,17 @@ function unifiedAccountFromSeed(seed32) {
     pqc: pqc2
   };
 }
-var PHANTOM_DERIVATION_DOMAIN = "QoreChain unified account derivation v1";
-function unifiedAccountFromPhantomSignature(signatureBytes2) {
-  const seed = pqc$1.shake256(signatureBytes2, 32);
-  return unifiedAccountFromSeed(seed);
-}
-function pubkeyBytes(pk) {
-  if (!pk) throw new Error("Phantom provider exposed no public key");
-  if (pk instanceof Uint8Array) return pk;
-  return pk.toBytes();
-}
-function signatureBytes(res) {
-  return res instanceof Uint8Array ? res : res.signature;
+
+// src/accounts/phantom.ts
+function unifiedAccountFromPhantomSignature(signatureBytes) {
+  throw new Error(
+    "unifiedAccountFromPhantomSignature was removed in v0.8.0: deriving a spend key from a wallet signature is unsafe \u2014 the signature is a bearer secret that any page can request from the wallet, so whoever obtains it controls the account. Use the authenticator lanes instead: register the external key with MsgRegisterAuthenticator and spend via MsgExecuteCosmos / MsgExecuteEVM (see the Authenticators guide). Any account previously derived this way must be treated as exposed \u2014 move its funds."
+  );
 }
 async function connectPhantomUnified(opts = {}) {
-  const provider = opts.provider ?? globalThis.solana ?? void 0;
-  if (!provider) {
-    throw new Error(
-      "no Phantom provider found (window.solana); pass opts.provider"
-    );
-  }
-  const conn = await provider.connect();
-  const pk = pubkeyBytes(
-    provider.publicKey ?? conn.publicKey
-  );
-  const message = `${PHANTOM_DERIVATION_DOMAIN}
-${base.base58.encode(pk)}`;
-  const signed = await provider.signMessage(
-    new TextEncoder().encode(message),
-    "utf8"
+  throw new Error(
+    "connectPhantomUnified was removed in v0.8.0: deriving a spend key from a wallet signature is unsafe \u2014 the signature is a bearer secret that any page can request from the wallet, so whoever obtains it controls the account. Use the authenticator lanes instead: register the external key with MsgRegisterAuthenticator and spend via MsgExecuteCosmos / MsgExecuteEVM (see the Authenticators guide). Any account previously derived this way must be treated as exposed \u2014 move its funds."
   );
-  return unifiedAccountFromPhantomSignature(signatureBytes(signed));
 }
 async function directSignerFromPrivateKey(privateKey, prefix) {
   if (privateKey.length !== 32) {
@@ -11341,6 +12482,82 @@ async function withRetry2(fn, opts = {}) {
   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, {
@@ -11486,21 +12703,28 @@ function attachHybridExtension(body, ext, opts = {}) {
   }
   return next;
 }
+
+// src/tx/signbytes.ts
+var SIGN_BYTES_V2_UPGRADE = "v3.1.98";
+var LEGACY_SIGN_BYTES_CHAINS = [
+  "qorechain-vladi",
+  "qorechain-diana"
+];
+var HYBRID_SIGN_BYTES_V2_DOMAIN = "qorechain-pqc-hybrid-v2";
+var MIGRATION_SIGN_BYTES_V2_DOMAIN = "qorechain-key-migration-v2";
+var BRIDGE_ATTESTATION_V2_DOMAIN = "qorechain-bridge-attestation-v2";
+var utf8 = new TextEncoder();
 function be32(n) {
   const b = new Uint8Array(4);
-  b[0] = n >>> 24 & 255;
-  b[1] = n >>> 16 & 255;
-  b[2] = n >>> 8 & 255;
-  b[3] = n & 255;
+  new DataView(b.buffer).setUint32(0, n >>> 0, false);
   return b;
 }
-function fromBase64(b64) {
-  const binary = atob(b64);
-  const out = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
-  return out;
+function be642(n) {
+  const b = new Uint8Array(8);
+  new DataView(b.buffer).setBigUint64(0, BigInt(n), false);
+  return b;
 }
-function concatBytes(...parts) {
+function concat2(parts) {
   let total = 0;
   for (const p of parts) total += p.length;
   const out = new Uint8Array(total);
@@ -11511,6 +12735,154 @@ function concatBytes(...parts) {
   }
   return out;
 }
+function assertVersion(version) {
+  if (version !== "v1" && version !== "v2") {
+    throw new Error(`sign-bytes version must be "v1" or "v2", got ${JSON.stringify(version)}`);
+  }
+}
+function hybridSignBytesV1(b0, authInfo) {
+  return concat2([be32(b0.length), b0, be32(authInfo.length), authInfo]);
+}
+function hybridSignBytesV2(chainId, b0, authInfo) {
+  const cid = utf8.encode(chainId);
+  return concat2([
+    utf8.encode(HYBRID_SIGN_BYTES_V2_DOMAIN),
+    be642(cid.length),
+    cid,
+    be32(b0.length),
+    b0,
+    be32(authInfo.length),
+    authInfo
+  ]);
+}
+function hybridSignBytes(version, chainId, b0, authInfo) {
+  assertVersion(version);
+  return version === "v2" ? hybridSignBytesV2(chainId, b0, authInfo) : hybridSignBytesV1(b0, authInfo);
+}
+function migrationSignBytesV1(input) {
+  return utf8.encode(
+    `qorechain-key-migration:chain=${input.chainId}:from=${input.fromAlgorithmId}:to=${input.toAlgorithmId}:account=${input.account}:height=${BigInt(input.height)}`
+  );
+}
+function migrationSignBytesV2(input) {
+  const cid = utf8.encode(input.chainId);
+  const acct = utf8.encode(input.account);
+  return concat2([
+    utf8.encode(MIGRATION_SIGN_BYTES_V2_DOMAIN),
+    be642(cid.length),
+    cid,
+    be642(acct.length),
+    acct,
+    be32(input.fromAlgorithmId),
+    be32(input.toAlgorithmId),
+    be642(input.height),
+    be32(input.oldPublicKey.length),
+    input.oldPublicKey,
+    be32(input.newPublicKey.length),
+    input.newPublicKey
+  ]);
+}
+function migrationSignBytes(version, input) {
+  assertVersion(version);
+  return version === "v2" ? migrationSignBytesV2(input) : migrationSignBytesV1(input);
+}
+function bridgeAttestationSignBytesV1(input) {
+  return utf8.encode(
+    [input.chain, input.eventType, input.operationId, input.txHash, input.amount, input.asset].join("|")
+  );
+}
+function bridgeAttestationSignBytesV2(input) {
+  const parts = [utf8.encode(BRIDGE_ATTESTATION_V2_DOMAIN)];
+  for (const f of [
+    input.chainId,
+    input.chain,
+    input.eventType,
+    input.operationId,
+    input.txHash,
+    input.amount,
+    input.asset
+  ]) {
+    const b = utf8.encode(f);
+    parts.push(be642(b.length), b);
+  }
+  return concat2(parts);
+}
+function bridgeAttestationSignBytes(version, input) {
+  assertVersion(version);
+  return version === "v2" ? bridgeAttestationSignBytesV2(input) : bridgeAttestationSignBytesV1(input);
+}
+function isLegacySignBytesChain(chainId) {
+  return LEGACY_SIGN_BYTES_CHAINS.includes(chainId);
+}
+function signBytesVersionFor(chainId, v2AppliedHeight) {
+  return BigInt(v2AppliedHeight) > 0n || !isLegacySignBytesChain(chainId) ? "v2" : "v1";
+}
+function parseAppliedHeight(body) {
+  const h = body?.height;
+  if (h === void 0 || h === null || h === "") return 0n;
+  if (typeof h !== "string" && typeof h !== "number" && typeof h !== "bigint") {
+    throw new Error(`unexpected applied_plan height ${JSON.stringify(h)}`);
+  }
+  return BigInt(h);
+}
+async function fetchSignBytesV2AppliedHeight(rest, fetchImpl = globalThis.fetch) {
+  const url = `${rest.replace(/\/+$/, "")}/cosmos/upgrade/v1beta1/applied_plan/${SIGN_BYTES_V2_UPGRADE}`;
+  const res = await fetchImpl(url);
+  if (!res.ok) {
+    throw new Error(`applied_plan query failed: HTTP ${res.status} from ${url}`);
+  }
+  return parseAppliedHeight(await res.json());
+}
+var cache = /* @__PURE__ */ new Map();
+function clearSignBytesCache() {
+  cache.clear();
+}
+async function resolveSignBytesVersion(opts) {
+  const requested = opts.signBytesVersion ?? "auto";
+  if (requested === "v1" || requested === "v2") return requested;
+  if (requested !== "auto") {
+    throw new Error(`signBytesVersion must be "auto", "v1" or "v2", got ${JSON.stringify(requested)}`);
+  }
+  if (!isLegacySignBytesChain(opts.chainId)) return "v2";
+  if (!opts.rest) {
+    throw new Error(
+      `cannot choose the hybrid sign-bytes form for ${opts.chainId} without its REST endpoint: pass rest, or signBytesVersion "v1" (before the ${SIGN_BYTES_V2_UPGRADE} upgrade) or "v2" (after)`
+    );
+  }
+  const key = `${opts.rest}\0${opts.chainId}`;
+  const ttl = opts.ttlMs ?? 6e4;
+  const hit = cache.get(key);
+  if (!opts.forceRefresh && hit && Date.now() - hit.at < ttl) return hit.version;
+  let height;
+  try {
+    height = await fetchSignBytesV2AppliedHeight(opts.rest, opts.fetch);
+  } catch (e) {
+    throw new Error(
+      `cannot ask ${opts.rest} whether ${SIGN_BYTES_V2_UPGRADE} is applied (${e.message}); pass signBytesVersion "v1" or "v2"`
+    );
+  }
+  const version = signBytesVersionFor(opts.chainId, height);
+  cache.set(key, { version, at: Date.now() });
+  return version;
+}
+var HYBRID_SIGN_BYTES_REJECTION_LOG = "hybrid PQC signature verification failed";
+function isHybridSignBytesRejection(x) {
+  if (x === null || x === void 0) return false;
+  const o = x;
+  if (o.codespace === "pqc" && Number(o.code) === 21) return true;
+  for (const t of [o.log, o.rawLog, o.message]) {
+    if (typeof t === "string" && t.includes(HYBRID_SIGN_BYTES_REJECTION_LOG)) return true;
+  }
+  return false;
+}
+
+// src/tx/hybrid-tx.ts
+function fromBase64(b64) {
+  const binary = atob(b64);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+  return out;
+}
 async function buildHybridTx(opts) {
   const {
     registry,
@@ -11546,12 +12918,14 @@ async function buildHybridTx(opts) {
     fee.payer,
     signing.SignMode.SIGN_MODE_DIRECT
   );
-  const pqcSignedMessage = concatBytes(
-    be32(b0.length),
-    b0,
-    be32(authInfoBytes.length),
-    authInfoBytes
-  );
+  const signBytesVersion = await resolveSignBytesVersion({
+    chainId,
+    rest: opts.rest,
+    signBytesVersion: opts.signBytesVersion,
+    fetch: opts.fetch,
+    forceRefresh: opts.forceRefreshSignBytesVersion
+  });
+  const pqcSignedMessage = hybridSignBytes(signBytesVersion, chainId, b0, authInfoBytes);
   const pqcSignature = pqcSign(pqcKeypair.secretKey, pqcSignedMessage);
   const ext = buildHybridSignatureExtension({
     algorithmId: AlgorithmDilithium5,
@@ -11585,18 +12959,34 @@ async function buildHybridTx(opts) {
     txRawBytes,
     authInfoBytes,
     pqcSignedMessage,
-    pqcSignature
+    pqcSignature,
+    signBytesVersion
   };
 }
 async function signAndBroadcastHybrid(opts) {
+  const auto = (opts.signBytesVersion ?? "auto") === "auto";
+  try {
+    return await broadcastHybridOnce(opts, false);
+  } catch (e) {
+    if (!auto || !isHybridSignBytesRejection(e)) throw e;
+    return broadcastHybridOnce(opts, true);
+  }
+}
+async function broadcastHybridOnce(opts, forceRefresh) {
   const { transport } = opts;
   const mode = opts.mode ?? "commit";
-  const built = await buildHybridTx(opts);
+  const built = await buildHybridTx({
+    ...opts,
+    forceRefreshSignBytesVersion: forceRefresh || opts.forceRefreshSignBytesVersion
+  });
   if (mode === "commit") {
     const res = await transport.broadcastTx(built.txRawBytes);
     if (res.code !== 0) {
-      throw new Error(
-        `hybrid transaction failed with code ${res.code}: ${res.rawLog ?? "(no log)"} (hash ${res.transactionHash})`
+      throw Object.assign(
+        new Error(
+          `hybrid transaction failed with code ${res.code}: ${res.rawLog ?? "(no log)"} (hash ${res.transactionHash})`
+        ),
+        { code: res.code, rawLog: res.rawLog, transactionHash: res.transactionHash }
       );
     }
     return {
@@ -11620,29 +13010,16 @@ function fromHex(hex) {
   }
   return bytes;
 }
-function be322(n) {
-  const b = new Uint8Array(4);
-  b[0] = n >>> 24 & 255;
-  b[1] = n >>> 16 & 255;
-  b[2] = n >>> 8 & 255;
-  b[3] = n & 255;
-  return b;
-}
-function concatBytes2(...parts) {
-  let total = 0;
-  for (const p of parts) total += p.length;
-  const out = new Uint8Array(total);
-  let off = 0;
-  for (const p of parts) {
-    out.set(p, off);
-    off += p.length;
-  }
-  return out;
+function defaultSignBytesVersion(chainId) {
+  if (!isLegacySignBytesChain(chainId)) return "v2";
+  throw new Error(
+    `signHybridEth on ${chainId} needs signBytesVersion: resolve it with resolveSignBytesVersion({ chainId, rest }) \u2014 the network switches from v1 to v2 at its own upgrade height`
+  );
 }
 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 });
     }
@@ -11723,12 +13100,8 @@ function signHybridEth(params) {
   const b0 = tx$1.TxBody.encode(
     tx$1.TxBody.fromPartial({ messages: encodedMessages, memo, timeoutHeight })
   ).finish();
-  const pqcSignedMessage = concatBytes2(
-    be322(b0.length),
-    b0,
-    be322(authInfoBytes.length),
-    authInfoBytes
-  );
+  const version = params.signBytesVersion ?? defaultSignBytesVersion(params.chainId);
+  const pqcSignedMessage = hybridSignBytes(version, params.chainId, b0, authInfoBytes);
   const pqcSignature = pqcSign(params.account.pqc.secretKey, pqcSignedMessage);
   const ext = buildHybridSignatureExtension({
     algorithmId: AlgorithmDilithium5,
@@ -11777,6 +13150,22 @@ var EthNativeSigner = class {
     };
     this.registry = opts.registry ?? qorechainRegistry();
     this.signMode = opts.signMode ?? "hybrid";
+    this.signBytesVersion = opts.signBytesVersion ?? "auto";
+    this.rest = opts.rest;
+    this.fetchImpl = opts.fetch;
+  }
+  /**
+   * The hybrid sign-bytes form for `chainId` under this signer's settings.
+   * Pass `forceRefresh` to bypass the cached answer.
+   */
+  resolveSignBytesVersion(chainId, forceRefresh = false) {
+    return resolveSignBytesVersion({
+      chainId,
+      rest: this.rest,
+      signBytesVersion: this.signBytesVersion,
+      fetch: this.fetchImpl,
+      forceRefresh
+    });
   }
   /** Build and sign a `TxRaw` for the given messages. Does not broadcast. */
   sign(params) {
@@ -11789,20 +13178,34 @@ var EthNativeSigner = class {
       sequence: params.sequence,
       memo: params.memo,
       timeoutHeight: params.timeoutHeight,
-      encodeMessage: this.encode
+      encodeMessage: this.encode,
+      signBytesVersion: params.signBytesVersion ?? (this.signBytesVersion === "auto" ? void 0 : this.signBytesVersion)
     };
     return this.signMode === "classical" ? signClassicalEth(signParams) : signHybridEth(signParams);
   }
   /** Sign and broadcast the given messages via `transport`. */
   async signAndBroadcast(transport, params) {
-    const { txRawBytes } = this.sign(params);
-    const res = await transport.broadcastTx(txRawBytes);
-    if (res.code !== 0) {
-      throw new Error(
-        `eth-native tx failed with code ${res.code}: ${res.rawLog ?? "(no log)"} (hash ${res.transactionHash})`
-      );
+    const once = async (forceRefresh) => {
+      const signBytesVersion = this.signMode === "hybrid" ? params.signBytesVersion ?? await this.resolveSignBytesVersion(params.chainId, forceRefresh) : void 0;
+      const { txRawBytes } = this.sign({ ...params, signBytesVersion });
+      const res = await transport.broadcastTx(txRawBytes);
+      if (res.code !== 0) {
+        throw Object.assign(
+          new Error(
+            `eth-native tx failed with code ${res.code}: ${res.rawLog ?? "(no log)"} (hash ${res.transactionHash})`
+          ),
+          { code: res.code, rawLog: res.rawLog, transactionHash: res.transactionHash }
+        );
+      }
+      return res;
+    };
+    const auto = this.signMode === "hybrid" && params.signBytesVersion === void 0 && this.signBytesVersion === "auto";
+    try {
+      return await once(false);
+    } catch (e) {
+      if (!auto || !isHybridSignBytesRejection(e)) throw e;
+      return once(true);
     }
-    return res;
   }
   /** Send `amount` to `toAddress` via a bank `MsgSend`, signed eth-native. */
   bankSend(transport, toAddress, amount, params) {
@@ -12069,6 +13472,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 = {
@@ -12087,6 +13501,20 @@ var svm = {
   registerSvmPqcKey: composer2(
     "/qorechain.svm.v1.MsgRegisterSVMPQCKey",
     MsgRegisterSVMPQCKey
+  ),
+  /**
+   * Replace the x/svm runtime parameters wholesale (chain v3.1.97).
+   *
+   * GOVERNANCE ONLY: `authority` must be the governance module account, so this
+   * message is submitted inside a gov proposal, not signed by a user. It is what
+   * makes enabling/disabling the SVM lane a proposal rather than a binary
+   * release. `params` is replaced in full — send every field, not just the ones
+   * you mean to change. `rentExemptionMulti` is a `LegacyDec` string (e.g.
+   * `"2.000000000000000000"`).
+   */
+  updateParams: composer2(
+    "/qorechain.svm.v1.MsgUpdateParams",
+    MsgUpdateParams
   )
 };
 var lightnode = {
@@ -12147,6 +13575,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 = {
@@ -12244,6 +13692,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";
@@ -12772,6 +14223,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",
@@ -12783,7 +14464,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: {
@@ -12792,7 +14519,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: {
@@ -12801,10 +14586,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;
 }
@@ -24019,6 +25925,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) {
@@ -24107,6 +26284,13 @@ function createQueryClients(rpc) {
         "Accounts",
         QueryAccountsRequest,
         QueryAccountsResponse
+      ),
+      permissionSchema: unary(
+        rpc,
+        "qorechain.abstractaccount.v1.Query",
+        "PermissionSchema",
+        QueryPermissionSchemaRequest,
+        QueryPermissionSchemaResponse
       )
     },
     amm: {
@@ -24669,6 +26853,30 @@ function extractMessageIds(result) {
   }
   return ids;
 }
+var CROSSVM_CALL_RESPONSE_TYPE_URL = "/qorechain.crossvm.v1.MsgCrossVMCallResponse";
+function unknownOutcome() {
+  return { executed: false, data: new Uint8Array(0), gasUsed: 0n };
+}
+function decodeCallOutcomes(result) {
+  const responses = result.msgResponses;
+  if (!Array.isArray(responses)) return [];
+  const out = [];
+  for (const r of responses) {
+    if (r?.typeUrl !== CROSSVM_CALL_RESPONSE_TYPE_URL) continue;
+    try {
+      const decoded = MsgCrossVMCallResponse.decode(r.value);
+      out.push({
+        executed: decoded.executed,
+        data: decoded.data,
+        // uint64 is generated as a decimal string; surface it as a bigint.
+        gasUsed: BigInt(decoded.gasUsed ?? 0)
+      });
+    } catch {
+      out.push(unknownOutcome());
+    }
+  }
+  return out;
+}
 function createCrossVMClient(tx, opts = {}) {
   const sender = tx.senderAddress;
   const query = opts.query;
@@ -24679,7 +26887,8 @@ function createCrossVMClient(tx, opts = {}) {
     targetVm: o.targetVm,
     targetContract: o.targetContract,
     payload,
-    funds: o.funds ?? []
+    funds: o.funds ?? [],
+    async: o.async ?? false
   });
   const buildCallSync = (o, payload) => buildFrom(o, payload);
   const buildCall = (o) => {
@@ -24704,7 +26913,8 @@ function createCrossVMClient(tx, opts = {}) {
       { autoFee: o.autoFee }
     );
     const [messageId = ""] = extractMessageIds(result);
-    return { messageId, result };
+    const [outcome = unknownOutcome()] = decodeCallOutcomes(result);
+    return { messageId, ...outcome, result };
   };
   const callAtomic = async (calls, w = {}) => {
     if (calls.length === 0) {
@@ -24719,7 +26929,11 @@ function createCrossVMClient(tx, opts = {}) {
       w.memo ?? "",
       { autoFee: w.autoFee }
     );
-    return { messageIds: extractMessageIds(result), result };
+    return {
+      messageIds: extractMessageIds(result),
+      outcomes: decodeCallOutcomes(result),
+      result
+    };
   };
   const getMessage = (id) => {
     requireGetMessageSource(query, qor);
@@ -24823,7 +27037,7 @@ async function migrateToHybrid(tx, opts) {
 }
 
 // src/index.ts
-var VERSION = "0.6.1";
+var VERSION = "0.8.0";
 
 Object.defineProperty(exports, "AI_ANOMALY_CHECK_ADDRESS", {
   enumerable: true,
@@ -24856,28 +27070,35 @@ Object.defineProperty(exports, "simulateWithRiskScore", {
 exports.AlgorithmDilithium5 = AlgorithmDilithium5;
 exports.AlgorithmMLKEM1024 = AlgorithmMLKEM1024;
 exports.AlgorithmUnspecified = AlgorithmUnspecified;
+exports.BRIDGE_ATTESTATION_V2_DOMAIN = BRIDGE_ATTESTATION_V2_DOMAIN;
+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;
 exports.EthNativeSigner = EthNativeSigner;
 exports.GasPrice = GasPrice;
+exports.HYBRID_SIGN_BYTES_REJECTION_LOG = HYBRID_SIGN_BYTES_REJECTION_LOG;
+exports.HYBRID_SIGN_BYTES_V2_DOMAIN = HYBRID_SIGN_BYTES_V2_DOMAIN;
 exports.HYBRID_SIG_TYPE_URL = HYBRID_SIG_TYPE_URL;
 exports.HybridSigner = HybridSigner;
 exports.JsonRpcClient = JsonRpcClient;
 exports.JsonRpcError = JsonRpcError;
+exports.LEGACY_DERIVATION = LEGACY_DERIVATION;
+exports.LEGACY_SIGN_BYTES_CHAINS = LEGACY_SIGN_BYTES_CHAINS;
+exports.MIGRATION_SIGN_BYTES_V2_DOMAIN = MIGRATION_SIGN_BYTES_V2_DOMAIN;
 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;
 exports.ML_DSA_87_SIGNATURE_LENGTH = ML_DSA_87_SIGNATURE_LENGTH;
 exports.MSG_SEND_TYPE_URL = MSG_SEND_TYPE_URL;
 exports.NETWORKS = NETWORKS;
-exports.PHANTOM_DERIVATION_DOMAIN = PHANTOM_DERIVATION_DOMAIN;
 exports.PQC_KEY_STATUS_PRECOMPILE_ADDRESS = PQC_KEY_STATUS_PRECOMPILE_ADDRESS;
 exports.PqcSigner = PqcSigner;
 exports.QorClient = QorClient;
 exports.QoreHttpError = QoreHttpError;
 exports.QoreTxError = QoreTxError;
 exports.RestClient = RestClient;
+exports.SIGN_BYTES_V2_UPGRADE = SIGN_BYTES_V2_UPGRADE;
 exports.STATIC_FALLBACK = STATIC_FALLBACK;
 exports.TxClient = TxClient;
 exports.VERSION = VERSION;
@@ -24890,22 +27111,32 @@ exports.amm = amm;
 exports.attachHybridExtension = attachHybridExtension;
 exports.authz = authz;
 exports.bank = bank;
+exports.be64 = be64;
 exports.bech32ToHex = bech32ToHex;
 exports.bridge = bridge;
+exports.bridgeAttestationSignBytes = bridgeAttestationSignBytes;
+exports.bridgeAttestationSignBytesV1 = bridgeAttestationSignBytesV1;
+exports.bridgeAttestationSignBytesV2 = bridgeAttestationSignBytesV2;
 exports.broadcastAndWait = broadcastAndWait;
 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;
 exports.bytesToBech32 = bytesToBech32;
 exports.calculateFee = calculateFee;
 exports.clearAdmin = clearAdmin;
+exports.clearSignBytesCache = clearSignBytesCache;
 exports.connectCosmWasmSigner = connectCosmWasmSigner;
 exports.connectPhantomUnified = connectPhantomUnified;
 exports.connectQueryClients = connectQueryClients;
+exports.cosmosAuthSignBytes = cosmosAuthSignBytes;
 exports.createClient = createClient;
 exports.createCosmWasmClient = createCosmWasmClient;
 exports.createCrossVMClient = createCrossVMClient;
@@ -24917,6 +27148,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;
@@ -24924,12 +27156,16 @@ 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;
 exports.feegrant = feegrant;
+exports.fetchSignBytesV2AppliedHeight = fetchSignBytesV2AppliedHeight;
 exports.formatUnits = formatUnits;
 exports.fromBase = fromBase;
 exports.generateMnemonic = generateMnemonic;
@@ -24950,10 +27186,15 @@ exports.getPqcStatus = getPqcStatus;
 exports.getTx = getTx;
 exports.gov = gov;
 exports.hexToBech32 = hexToBech32;
+exports.hybridSignBytes = hybridSignBytes;
+exports.hybridSignBytesV1 = hybridSignBytesV1;
+exports.hybridSignBytesV2 = hybridSignBytesV2;
 exports.ibc = ibc;
 exports.instantiate = instantiate;
 exports.instantiate2 = instantiate2;
 exports.isChecksumAddress = isChecksumAddress;
+exports.isHybridSignBytesRejection = isHybridSignBytesRejection;
+exports.isLegacySignBytesChain = isLegacySignBytesChain;
 exports.isPqcRegistered = isPqcRegistered;
 exports.isSignatureAlgorithm = isSignatureAlgorithm;
 exports.isTxFailure = isTxFailure;
@@ -24963,12 +27204,16 @@ exports.isValidSvmAddress = isValidSvmAddress;
 exports.joinUrl = joinUrl;
 exports.keccak256 = keccak256;
 exports.keccak256Hex = keccak256Hex;
+exports.lengthPrefixed = lengthPrefixed;
 exports.license = license;
 exports.lightnode = lightnode;
 exports.listNetworks = listNetworks;
 exports.migrate = migrate;
 exports.migratePqcKey = migratePqcKey;
 exports.migrateToHybrid = migrateToHybrid;
+exports.migrationSignBytes = migrationSignBytes;
+exports.migrationSignBytesV1 = migrationSignBytesV1;
+exports.migrationSignBytesV2 = migrationSignBytesV2;
 exports.msg = msg;
 exports.multilayer = multilayer;
 exports.parseEthPubkeyAny = parseEthPubkeyAny;
@@ -24984,14 +27229,21 @@ exports.qorechainRegistryTypes = qorechainRegistryTypes;
 exports.qorechainTypes = codegen_exports;
 exports.queryContractSmart = queryContractSmart;
 exports.rdk = rdk;
+exports.registerEthAuthenticatorMsg = registerEthAuthenticatorMsg;
 exports.requestFaucet = requestFaucet;
+exports.resolveSignBytesVersion = resolveSignBytesVersion;
+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;
 exports.signAndBroadcastHybrid = signAndBroadcastHybrid;
+exports.signBytesVersionFor = signBytesVersionFor;
 exports.signClassicalEth = signClassicalEth;
 exports.signHybridEth = signHybridEth;
 exports.staking = staking;