@agentlayer.tech/wallet 0.1.16 → 0.1.18

package/agent-wallet/agent_wallet/wallet_layer/solana.py

@@ -2600,10 +2600,6 @@ class SolanaWalletBackend(AgentWalletBackend):
             collateral_symbol,
             field_name="collateral_symbol",
         )
-        if normalized_collateral_symbol != normalized_market_symbol:
-            raise WalletBackendError(
-                "Phase 2 Flash preview currently supports only same-collateral opens where collateral_symbol matches market_symbol."
-            )
         normalized_collateral_amount_raw = _require_positive_integer_string(
             collateral_amount_raw,
             field_name="collateral_amount_raw",
@@ -2616,15 +2612,19 @@ class SolanaWalletBackend(AgentWalletBackend):
                 item
                 for item in market_snapshot["markets"]
                 if isinstance(item, dict)
-                and str(item.get("symbol") or "").strip().upper() == normalized_market_symbol
+                and str(item.get("market_symbol") or item.get("symbol") or "").strip().upper()
+                == normalized_market_symbol
+                and str(item.get("side") or "").strip().lower() == normalized_side
+                and str(item.get("collateral_symbol") or "").strip().upper()
+                == normalized_collateral_symbol
             ),
             None,
         )
         if matching_market is None:
             raise WalletBackendError(
-                "Requested Flash market is not available in the selected pool."
+                "Requested Flash market is not available in the selected pool for the requested collateral and side."
             )
-        bridge_preview = await flash_sdk_bridge.preview_open_position_same_collateral(
+        bridge_preview = await flash_sdk_bridge.preview_open_position(
             owner=owner,
             pool_name=normalized_pool_name,
             market_symbol=normalized_market_symbol,
@@ -2927,7 +2927,7 @@ class SolanaWalletBackend(AgentWalletBackend):
             leverage=leverage,
             side=side,
         )
-        bridge_prepared = await flash_sdk_bridge.prepare_open_position_same_collateral(
+        bridge_prepared = await flash_sdk_bridge.prepare_open_position(
             owner=str(preview["owner"]),
             pool_name=str(preview["pool_name"]),
             market_symbol=str(preview["market_symbol"]),
@@ -2948,7 +2948,7 @@ class SolanaWalletBackend(AgentWalletBackend):
         self,
         preview: dict[str, Any],
     ) -> dict[str, Any]:
-        bridge_prepared = await flash_sdk_bridge.prepare_open_position_same_collateral(
+        bridge_prepared = await flash_sdk_bridge.prepare_open_position(
             owner=str(preview["owner"]),
             pool_name=str(preview["pool_name"]),
             market_symbol=str(preview["market_symbol"]),

package/agent-wallet/agent_wallet/wallet_layer/wdk_evm.py

@@ -440,6 +440,36 @@ class WdkEvmLocalWalletBackend(AgentWalletBackend):
         self.address = address
         return address
 
+    def sign_x402_evm_exact_typed_data(
+        self,
+        *,
+        domain: dict[str, Any],
+        types: dict[str, Any],
+        primary_type: str,
+        message: dict[str, Any],
+    ) -> bytes:
+        data = self.client.post_sync(
+            "/v1/evm/x402/exact/sign",
+            {
+                "walletId": self.wallet_id,
+                "accountIndex": self.account_index,
+                "network": self.network,
+                "domain": domain,
+                "types": types,
+                "primaryType": primary_type,
+                "message": message,
+            },
+        )
+        signature = str(data.get("signature") or "").strip()
+        if not signature:
+            raise WalletBackendError("wdk-evm-wallet did not return an x402 EVM signature.")
+        if signature.startswith("0x"):
+            signature = signature[2:]
+        try:
+            return bytes.fromhex(signature)
+        except ValueError as exc:
+            raise WalletBackendError("wdk-evm-wallet returned an invalid x402 EVM signature.") from exc
+
     async def get_balance(self, address: str | None = None) -> dict[str, Any]:
         resolved_address = await self.get_address()
         if address is not None and address.strip() and address.strip() != resolved_address:

package/agent-wallet/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openclaw-agent-wallet"
-version = "0.1.16"
+version = "0.1.18"
 description = "Plugin-friendly wallet backend for OpenClaw agents"
 requires-python = ">=3.10"
 dependencies = [
@@ -15,6 +15,7 @@ dependencies = [
     "python-dotenv>=1.0.0",
     "solana>=0.36.0",
     "solders>=0.27.0",
+    "x402[httpx,svm,evm]>=2.10.0",
 ]
 
 [project.optional-dependencies]

package/agent-wallet/scripts/flash-sdk-bridge/README.md

@@ -13,7 +13,7 @@ Current goals:
 - `FLASH_SDK_BRIDGE_MODE=mock`
   Returns deterministic payloads for local smoke checks without installing SDK dependencies.
 - `FLASH_SDK_BRIDGE_MODE=real`
-  Loads `flash-sdk` and validates runtime config. This mode now supports market discovery, user-position discovery, open/close previews, and unsigned transaction preparation for the current same-collateral Flash perps MVP.
+  Loads `flash-sdk` and validates runtime config. This mode now supports market discovery, user-position discovery, open/close previews, and unsigned transaction preparation for Flash perps using the collateral supported by the selected Flash market.
 
 ## Command
 
@@ -28,6 +28,6 @@ For local smoke:
 ```bash
 FLASH_SDK_BRIDGE_MODE=mock \
 node agent-wallet/scripts/flash-sdk-bridge/bridge.mjs <<'EOF'
-{"action":"preview_open_position_same_collateral","owner":"Fake11111111111111111111111111111111111111111","pool_name":"Crypto.1","market_symbol":"SOL","collateral_symbol":"SOL","collateral_amount_raw":"100000000","leverage":"5","side":"long","network":"mainnet"}
+{"action":"preview_open_position","owner":"Fake11111111111111111111111111111111111111111","pool_name":"Crypto.1","market_symbol":"SOL","collateral_symbol":"USDC","collateral_amount_raw":"5000000","leverage":"2","side":"short","network":"mainnet"}
 EOF
 ```

package/agent-wallet/scripts/flash-sdk-bridge/bridge.mjs

@@ -110,7 +110,7 @@ function mockResponse(normalized) {
             pool_name: normalized.poolName ?? "Crypto.1",
             symbol: "SOL",
             market_symbol: "SOL",
-            collateral_symbol: "SOL",
+            collateral_symbol: "USDC",
             side: "short",
             market_address: "MockFlashMarketShort1111111111111111111111111",
           },
@@ -145,7 +145,10 @@ function mockResponse(normalized) {
     };
   }
 
-  if (normalized.action === "preview_open_position_same_collateral") {
+  if (
+    normalized.action === "preview_open_position" ||
+    normalized.action === "preview_open_position_same_collateral"
+  ) {
     return {
       ok: true,
       preview: {
@@ -177,7 +180,10 @@ function mockResponse(normalized) {
     };
   }
 
-  if (normalized.action === "prepare_open_position_same_collateral") {
+  if (
+    normalized.action === "prepare_open_position" ||
+    normalized.action === "prepare_open_position_same_collateral"
+  ) {
     return {
       ok: true,
       prepared: {
@@ -608,12 +614,6 @@ async function getOpenPositionPreview(runtime, normalized) {
       "collateral_symbol, collateral_amount_raw, and leverage are required for open preview",
     );
   }
-  if (normalized.collateralSymbol !== normalized.marketSymbol) {
-    throw new Error(
-      "Current bridge MVP supports only same-collateral opens where collateral_symbol matches market_symbol",
-    );
-  }
-
   const { BN } = runtime;
   const privilege = runtime.flashSdk.Privilege.None;
   const ownerPublicKey = runtime.provider.wallet.publicKey;
@@ -810,12 +810,6 @@ async function prepareOpenPosition(runtime, normalized) {
       "collateral_symbol, collateral_amount_raw, and leverage are required for open prepare",
     );
   }
-  if (normalized.collateralSymbol !== normalized.marketSymbol) {
-    throw new Error(
-      "Current bridge MVP supports only same-collateral opens where collateral_symbol matches market_symbol",
-    );
-  }
-
   const { BN } = runtime;
   const privilege = runtime.flashSdk.Privilege.None;
   const ownerPublicKey = runtime.provider.wallet.publicKey;
@@ -1113,13 +1107,19 @@ async function realResponse(normalized) {
     return getPositionsReal(normalized);
   }
   const runtime = await buildRuntimeContext(normalized);
-  if (normalized.action === "preview_open_position_same_collateral") {
+  if (
+    normalized.action === "preview_open_position" ||
+    normalized.action === "preview_open_position_same_collateral"
+  ) {
     return getOpenPositionPreview(runtime, normalized);
   }
   if (normalized.action === "preview_close_position_same_collateral") {
     return getClosePositionPreview(runtime, normalized);
   }
-  if (normalized.action === "prepare_open_position_same_collateral") {
+  if (
+    normalized.action === "prepare_open_position" ||
+    normalized.action === "prepare_open_position_same_collateral"
+  ) {
     return prepareOpenPosition(runtime, normalized);
   }
   if (normalized.action === "prepare_close_position_same_collateral") {

package/agent-wallet/scripts/install_openclaw_local_config.py

@@ -58,6 +58,13 @@ PAY_BRIDGE_TOOLS = [
     "pay_api_request",
 ]
 
+X402_TOOLS = [
+    "x402_search_services",
+    "x402_get_service_details",
+    "x402_preview_request",
+    "x402_pay_request",
+]
+
 
 def _default_config_path() -> Path:
     return Path(os.path.expanduser("~/.openclaw/openclaw.json"))
@@ -329,7 +336,7 @@ def main() -> None:
 
     tools = data.setdefault("tools", {})
     also_allow = tools.setdefault("alsoAllow", [])
-    for tool_name in OPTIONAL_TOOLS + PAY_BRIDGE_TOOLS:
+    for tool_name in OPTIONAL_TOOLS + PAY_BRIDGE_TOOLS + X402_TOOLS:
         if tool_name not in also_allow:
             also_allow.append(tool_name)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayer.tech/wallet",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "NPM installer for the OpenClaw Agent Wallet local runtime.",
   "type": "module",
   "repository": {

package/wdk-evm-wallet/src/server.js

@@ -554,6 +554,12 @@ async function handleRequest(request, response) {
       return sendJson(response, 200, { ok: true, data });
     }
 
+    if (method === "POST" && url.pathname === "/v1/evm/x402/exact/sign") {
+      const body = await withResolvedNetwork(await withResolvedSeed(await readJsonBody(request)));
+      const data = await service.signX402ExactTypedData(body);
+      return sendJson(response, 200, { ok: true, data });
+    }
+
     return notFound(response);
   } catch (error) {
     const shaped = toErrorResponse(error, new URL(request.url || "/", "http://localhost").pathname, 400);

package/wdk-evm-wallet/src/wdk_evm_wallet.js

@@ -149,6 +149,14 @@ function assertPositiveBigIntString(value, fieldName) {
   return parsed;
 }
 
+function assertNonNegativeBigIntString(value, fieldName) {
+  const normalized = String(value ?? "").trim();
+  if (!/^[0-9]+$/.test(normalized)) {
+    throw new Error(`${fieldName} must be a non-negative base-10 integer string.`);
+  }
+  return normalized;
+}
+
 function normalizeAddress(value, fieldName) {
   const address = assertNonEmptyString(value, fieldName);
   if (!/^0x[a-fA-F0-9]{40}$/.test(address)) {
@@ -305,6 +313,71 @@ function mergeBridgeLists(...values) {
   return items.length > 0 ? items.join(",") : null;
 }
 
+function assertPlainObject(value, fieldName) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${fieldName} must be an object.`);
+  }
+  return value;
+}
+
+function normalizeX402ExactTypedData({ domain, types, primaryType, message }, runtimeConfig) {
+  const normalizedPrimaryType = assertNonEmptyString(primaryType, "primaryType");
+  if (normalizedPrimaryType !== "TransferWithAuthorization") {
+    throw new Error("primaryType must be TransferWithAuthorization for x402 exact EVM payments.");
+  }
+
+  const domainObject = assertPlainObject(domain, "domain");
+  const domainChainId = assertNonNegativeInteger(domainObject.chainId, "domain.chainId");
+  if (domainChainId !== runtimeConfig.chainId) {
+    throw new Error("domain.chainId must match the active network chain id.");
+  }
+  const normalizedDomain = {
+    name: assertNonEmptyString(domainObject.name, "domain.name"),
+    version: assertNonEmptyString(domainObject.version, "domain.version"),
+    chainId: domainChainId,
+    verifyingContract: normalizeAddress(domainObject.verifyingContract, "domain.verifyingContract"),
+  };
+
+  const typesObject = assertPlainObject(types, "types");
+  const primaryFields = typesObject[normalizedPrimaryType];
+  if (!Array.isArray(primaryFields) || primaryFields.length === 0) {
+    throw new Error(`types.${normalizedPrimaryType} must be a non-empty array.`);
+  }
+  const normalizedTypes = {};
+  for (const [typeName, fields] of Object.entries(typesObject)) {
+    if (!Array.isArray(fields) || fields.length === 0) {
+      throw new Error(`types.${typeName} must be a non-empty array.`);
+    }
+    normalizedTypes[typeName] = fields.map((field, index) => {
+      const normalizedField = assertPlainObject(field, `types.${typeName}[${index}]`);
+      return {
+        name: assertNonEmptyString(normalizedField.name, `types.${typeName}[${index}].name`),
+        type: assertNonEmptyString(normalizedField.type, `types.${typeName}[${index}].type`),
+      };
+    });
+  }
+
+  const messageObject = assertPlainObject(message, "message");
+  const normalizedMessage = {
+    from: normalizeAddress(messageObject.from, "message.from"),
+    to: normalizeAddress(messageObject.to, "message.to"),
+    value: assertPositiveBigIntString(messageObject.value, "message.value").toString(),
+    validAfter: assertNonNegativeBigIntString(messageObject.validAfter, "message.validAfter"),
+    validBefore: assertPositiveBigIntString(messageObject.validBefore, "message.validBefore").toString(),
+    nonce: assertNonEmptyString(messageObject.nonce, "message.nonce"),
+  };
+  if (!/^0x[a-fA-F0-9]{64}$/.test(normalizedMessage.nonce)) {
+    throw new Error("message.nonce must be a 32-byte hex string.");
+  }
+
+  return {
+    domain: normalizedDomain,
+    types: normalizedTypes,
+    primaryType: normalizedPrimaryType,
+    message: normalizedMessage,
+  };
+}
+
 function buildSwapRequest({ tokenIn, tokenOut, tokenInAmount }) {
   const swapRequest = {
     tokenIn: normalizeAddress(tokenIn, "tokenIn"),
@@ -2335,6 +2408,41 @@ export class WdkEvmWalletService {
     });
   }
 
+  async signX402ExactTypedData({
+    seedPhrase,
+    accountIndex = 0,
+    network,
+    domain,
+    types,
+    primaryType,
+    message,
+  }) {
+    return this.#withAccount({ seedPhrase, accountIndex, network }, async (account, runtimeConfig) => {
+      const typedData = normalizeX402ExactTypedData(
+        { domain, types, primaryType, message },
+        runtimeConfig
+      );
+      const signerAddress = normalizeAddress(await account.getAddress(), "accountAddress");
+      if (typedData.message.from.toLowerCase() !== signerAddress.toLowerCase()) {
+        throw new Error("message.from must match the active wallet account address.");
+      }
+      const signature = await account.signTypedData({
+        domain: typedData.domain,
+        types: typedData.types,
+        message: typedData.message,
+      });
+      return {
+        network: runtimeConfig.network,
+        chainId: runtimeConfig.chainId,
+        accountIndex,
+        address: signerAddress,
+        primaryType: typedData.primaryType,
+        signature,
+        source: "wdk-wallet-evm",
+      };
+    });
+  }
+
   #resolveRuntimeConfig(networkOverride) {
     const network = assertValidNetwork(networkOverride) || this.config.network;
     const profile = this.config.networkProfiles?.[network];