@clawlogic/sdk 0.0.2 → 0.1.0

package/src/cli/runtime.ts

@@ -0,0 +1,157 @@
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts';
+import type { ClawlogicConfig } from '../types.js';
+import { createConfig } from '../config.js';
+import { ClawlogicClient } from '../client.js';
+import {
+  DEFAULT_CHAIN_ID,
+  DEFAULT_CONTRACTS,
+  DEFAULT_RPC_URL,
+  DEFAULT_STATE_PATH,
+} from './constants.js';
+
+interface PersistedState {
+  version: 1;
+  privateKey: `0x${string}`;
+  address: `0x${string}`;
+  createdAt: string;
+  rpcUrl?: string;
+  contracts?: Partial<ClawlogicConfig['contracts']>;
+}
+
+export interface RuntimeContext {
+  client: ClawlogicClient;
+  config: ClawlogicConfig;
+  address?: `0x${string}`;
+  statePath: string;
+  createdWallet: boolean;
+  state?: PersistedState;
+}
+
+export interface RuntimeOptions {
+  requireWallet?: boolean;
+  autoCreateWallet?: boolean;
+}
+
+export async function createRuntime(
+  options: RuntimeOptions = {},
+): Promise<RuntimeContext> {
+  const statePath = resolveStatePath(process.env.CLAWLOGIC_STATE_PATH ?? DEFAULT_STATE_PATH);
+  const state = await readState(statePath);
+  let privateKey = readPrivateKeyFromEnv();
+  let createdWallet = false;
+
+  if (!privateKey && state?.privateKey) {
+    privateKey = state.privateKey;
+  }
+
+  if (!privateKey && options.requireWallet && options.autoCreateWallet !== false) {
+    const generated = generatePrivateKey();
+    const address = privateKeyToAccount(generated).address;
+    const nextState: PersistedState = {
+      version: 1,
+      privateKey: generated,
+      address,
+      createdAt: new Date().toISOString(),
+      rpcUrl: state?.rpcUrl,
+      contracts: state?.contracts,
+    };
+    await writeState(statePath, nextState);
+    privateKey = generated;
+    createdWallet = true;
+  }
+
+  if (!privateKey && options.requireWallet) {
+    throw new Error(
+      'No wallet available. Run `npx @clawlogic/sdk@latest clawlogic-agent init` first.',
+    );
+  }
+
+  const config = resolveConfig(state);
+  const client = new ClawlogicClient(config, privateKey);
+  const address = privateKey ? privateKeyToAccount(privateKey).address : state?.address;
+
+  return {
+    client,
+    config,
+    address,
+    statePath,
+    createdWallet,
+    state: state ?? undefined,
+  };
+}
+
+function resolveConfig(state: PersistedState | null): ClawlogicConfig {
+  const rpcUrl =
+    process.env.ARBITRUM_SEPOLIA_RPC_URL ??
+    process.env.CLAWLOGIC_RPC_URL ??
+    state?.rpcUrl ??
+    DEFAULT_RPC_URL;
+
+  const agentRegistry =
+    process.env.AGENT_REGISTRY ??
+    state?.contracts?.agentRegistry ??
+    DEFAULT_CONTRACTS.agentRegistry;
+  const predictionMarketHook =
+    process.env.PREDICTION_MARKET_HOOK ??
+    state?.contracts?.predictionMarketHook ??
+    DEFAULT_CONTRACTS.predictionMarketHook;
+  const poolManager =
+    process.env.V4_POOL_MANAGER ??
+    state?.contracts?.poolManager ??
+    DEFAULT_CONTRACTS.poolManager;
+  const optimisticOracleV3 =
+    process.env.UMA_OOV3 ??
+    state?.contracts?.optimisticOracleV3 ??
+    DEFAULT_CONTRACTS.optimisticOracleV3;
+
+  return createConfig(
+    {
+      agentRegistry: agentRegistry as `0x${string}`,
+      predictionMarketHook: predictionMarketHook as `0x${string}`,
+      poolManager: poolManager as `0x${string}`,
+      optimisticOracleV3: optimisticOracleV3 as `0x${string}`,
+    },
+    DEFAULT_CHAIN_ID,
+    rpcUrl,
+  );
+}
+
+function readPrivateKeyFromEnv(): `0x${string}` | undefined {
+  const candidate = process.env.AGENT_PRIVATE_KEY?.trim();
+  if (!candidate) {
+    return undefined;
+  }
+  if (!/^0x[0-9a-fA-F]{64}$/.test(candidate)) {
+    throw new Error('AGENT_PRIVATE_KEY must be a 32-byte hex string (0x + 64 hex chars).');
+  }
+  return candidate as `0x${string}`;
+}
+
+async function readState(path: string): Promise<PersistedState | null> {
+  try {
+    const raw = await readFile(path, 'utf-8');
+    const parsed = JSON.parse(raw) as PersistedState;
+    if (!parsed.privateKey || !parsed.address) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+async function writeState(path: string, state: PersistedState): Promise<void> {
+  await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+  await writeFile(path, JSON.stringify(state, null, 2), { mode: 0o600 });
+  await chmod(path, 0o600);
+}
+
+function resolveStatePath(path: string): string {
+  if (path.startsWith('~/')) {
+    return resolve(homedir(), path.slice(2));
+  }
+  return resolve(path);
+}

package/src/client.ts

@@ -13,6 +13,7 @@ import {
   type WatchContractEventReturnType,
 } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
+import { namehash } from 'viem/ens';
 import type {
   ClawlogicConfig,
   MarketInfo,
@@ -43,6 +44,22 @@ const arbitrumSepolia: Chain = {
   testnet: true,
 };
 
+const ZERO_BYTES32 =
+  '0x0000000000000000000000000000000000000000000000000000000000000000' as const;
+const ZERO_ADDRESS =
+  '0x0000000000000000000000000000000000000000' as const;
+
+function isBytes32Hex(value: string): value is `0x${string}` {
+  return /^0x[0-9a-fA-F]{64}$/.test(value);
+}
+
+function resolveEnsNode(ensNodeOrName: `0x${string}` | string): `0x${string}` {
+  if (isBytes32Hex(ensNodeOrName)) {
+    return ensNodeOrName;
+  }
+  return namehash(ensNodeOrName) as `0x${string}`;
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Helper: build a viem Chain object from a config
 // ─────────────────────────────────────────────────────────────────────────────
@@ -71,7 +88,7 @@ function buildChain(config: ClawlogicConfig): Chain {
 // ─────────────────────────────────────────────────────────────────────────────
 
 /**
- * Main client for interacting with the $CLAWLOGIC protocol.
+ * Main client for interacting with the CLAWLOGIC protocol.
  *
  * Provides methods for:
  * - Agent registration & lookup (AgentRegistry)
@@ -199,6 +216,32 @@ export class ClawlogicClient {
     return this.waitForTx(hash);
   }
 
+  /**
+   * Register the caller as an agent and link an ENS node.
+   *
+   * @param name - Human-readable agent name.
+   * @param ensNodeOrName - ENS namehash (`0x...`) or ENS name (`alpha.clawlogic.eth`).
+   * @param attestation - TEE attestation bytes (hex-encoded). Defaults to "0x".
+   * @returns Transaction hash of the registration.
+   */
+  async registerAgentWithENS(
+    name: string,
+    ensNodeOrName: `0x${string}` | string,
+    attestation: `0x${string}` = '0x',
+  ): Promise<`0x${string}`> {
+    const wallet = this.requireWallet();
+    const ensNode = resolveEnsNode(ensNodeOrName);
+
+    const hash = await wallet.writeContract({
+      address: this.config.contracts.agentRegistry,
+      abi: agentRegistryAbi,
+      functionName: 'registerAgentWithENS',
+      args: [name, attestation, ensNode],
+    });
+
+    return this.waitForTx(hash);
+  }
+
   /**
    * Check whether an address is a registered agent.
    *
@@ -235,6 +278,7 @@ export class ClawlogicClient {
       attestation: `0x${string}`;
       registeredAt: bigint;
       exists: boolean;
+      ensNode?: `0x${string}`;
     };
 
     return {
@@ -243,9 +287,31 @@ export class ClawlogicClient {
       attestation: agent.attestation,
       registeredAt: agent.registeredAt,
       exists: agent.exists,
+      ensNode: agent.ensNode && agent.ensNode !== ZERO_BYTES32 ? agent.ensNode : undefined,
     };
   }
 
+  /**
+   * Resolve an ENS-linked agent address from ENS namehash or name.
+   *
+   * @param ensNodeOrName - ENS namehash (`0x...`) or ENS name (`alpha.clawlogic.eth`).
+   * @returns The registered agent address linked to the ENS node.
+   */
+  async getAgentByENS(ensNodeOrName: `0x${string}` | string): Promise<`0x${string}`> {
+    const ensNode = resolveEnsNode(ensNodeOrName);
+    const result = await this.publicClient.readContract({
+      address: this.config.contracts.agentRegistry,
+      abi: agentRegistryAbi,
+      functionName: 'getAgentByENS',
+      args: [ensNode],
+    });
+    const agent = result as `0x${string}`;
+    if (agent.toLowerCase() === ZERO_ADDRESS) {
+      throw new Error(`No agent linked to ENS node ${ensNode}`);
+    }
+    return agent;
+  }
+
   /**
    * Get the total number of registered agents.
    *
@@ -290,6 +356,7 @@ export class ClawlogicClient {
    * @param description - Human-readable market question.
    * @param reward - Amount of bond currency offered as incentive to the asserter.
    * @param requiredBond - Minimum bond required from an asserter.
+   * @param initialLiquidityEth - Optional ETH value to seed CPMM reserves at market creation.
    * @returns Transaction hash of the market creation.
    */
   async initializeMarket(
@@ -298,6 +365,7 @@ export class ClawlogicClient {
     description: string,
     reward: bigint,
     requiredBond: bigint,
+    initialLiquidityEth: bigint = 0n,
   ): Promise<`0x${string}`> {
     const wallet = this.requireWallet();
 
@@ -306,6 +374,7 @@ export class ClawlogicClient {
       abi: predictionMarketHookAbi,
       functionName: 'initializeMarket',
       args: [outcome1, outcome2, description, reward, requiredBond],
+      value: initialLiquidityEth,
     });
 
     return this.waitForTx(hash);

package/src/identity.ts

@@ -1,7 +1,7 @@
 /**
  * @file identity.ts
  *
- * Phase 1 Identity & Trust infrastructure for $CLAWLOGIC.
+ * Phase 1 Identity & Trust infrastructure for CLAWLOGIC.
  *
  * Provides SDK methods for:
  * - ENS agent identity resolution
@@ -30,17 +30,24 @@ import { ValidationType } from './types.js';
 import { agentIdentityRegistryAbi } from './abis/agentIdentityRegistryAbi.js';
 import { agentReputationRegistryAbi } from './abis/agentReputationRegistryAbi.js';
 import { agentValidationRegistryAbi } from './abis/agentValidationRegistryAbi.js';
+import { agentRegistryAbi } from './abis/agentRegistryAbi.js';
 
 /**
  * Extended contract addresses for Phase 1 identity infrastructure.
  */
 export interface IdentityContracts {
+  agentRegistry?: `0x${string}`;
   agentIdentityRegistry: `0x${string}`;
   agentReputationRegistry: `0x${string}`;
   agentValidationRegistry: `0x${string}`;
   ensRegistry?: `0x${string}`; // Optional: 0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e on most chains
 }
 
+const ZERO_BYTES32 =
+  '0x0000000000000000000000000000000000000000000000000000000000000000' as const;
+const ZERO_ADDRESS =
+  '0x0000000000000000000000000000000000000000' as const;
+
 /**
  * Identity client for Phase 1 ENS + ERC-8004 + TEE functionality.
  *
@@ -65,12 +72,23 @@ export class IdentityClient {
    * @returns Agent address, or null if not found
    */
   async resolveAgentENS(ensName: string): Promise<`0x${string}` | null> {
-    try {
-      // ENS resolution is handled by AgentRegistry.getAgentByENS(), not the
-      // identity registry.  Use the main ClawlogicClient for ENS resolution.
-      // This method is a no-op placeholder; callers should use
-      // ClawlogicClient.getAgentByENS() directly.
+    const registry = this.contracts.agentRegistry;
+    if (!registry) {
       return null;
+    }
+
+    try {
+      const ensNode = namehash(ensName) as `0x${string}`;
+      const agent = await this.publicClient.readContract({
+        address: registry,
+        abi: agentRegistryAbi,
+        functionName: 'getAgentByENS',
+        args: [ensNode],
+      }) as `0x${string}`;
+      if (agent.toLowerCase() === ZERO_ADDRESS) {
+        return null;
+      }
+      return agent;
     } catch {
       return null;
     }
@@ -83,10 +101,58 @@ export class IdentityClient {
    * @returns ENS name, or null if not linked
    */
   async getAgentENSName(address: `0x${string}`): Promise<string | null> {
+    const ensCapableClient = this.publicClient as PublicClient<Transport, Chain> & {
+      getEnsName?: (args: { address: `0x${string}` }) => Promise<string | null>;
+    };
+
     try {
-      // This will be implemented once AgentRegistry includes ENS reverse mapping
-      // For now, return null (requires contract support)
+      if (typeof ensCapableClient.getEnsName === 'function') {
+        const ensName = await ensCapableClient.getEnsName({ address });
+        if (ensName) {
+          return ensName;
+        }
+      }
+    } catch {
+      // Fall through to registry-based fallback.
+    }
+
+    const ensNode = await this.getAgentENSNode(address);
+    if (!ensNode) {
+      return null;
+    }
+    return `ens-node:${ensNode}`;
+  }
+
+  /**
+   * Get the ENS node linked to a given agent address.
+   *
+   * @param address - Agent address
+   * @returns ENS node (bytes32) if linked, otherwise null
+   */
+  async getAgentENSNode(address: `0x${string}`): Promise<`0x${string}` | null> {
+    const registry = this.contracts.agentRegistry;
+    if (!registry) {
       return null;
+    }
+
+    try {
+      const result = await this.publicClient.readContract({
+        address: registry,
+        abi: agentRegistryAbi,
+        functionName: 'getAgent',
+        args: [address],
+      });
+
+      const agent = result as {
+        exists: boolean;
+        ensNode?: `0x${string}`;
+      };
+
+      if (!agent.exists || !agent.ensNode || agent.ensNode === ZERO_BYTES32) {
+        return null;
+      }
+
+      return agent.ensNode;
     } catch {
       return null;
     }
@@ -362,6 +428,7 @@ export class IdentityClient {
 
     // Get ENS name
     const ensName = await this.getAgentENSName(address);
+    const ensNode = await this.getAgentENSNode(address);
 
     // Get identity token
     const identityToken = await this.getAgentIdentityToken(address);
@@ -384,7 +451,7 @@ export class IdentityClient {
       attestation: '0x', // Will be filled by caller
       registeredAt: 0n, // Will be filled by caller
       exists: true,
-      ensNode: ensName ? namehash(ensName) : undefined,
+      ensNode: ensNode ?? (ensName && !ensName.startsWith('ens-node:') ? namehash(ensName) : undefined),
       agentId: identityToken?.tokenId,
       reputationScore,
       ensName,

package/src/index.ts

@@ -4,6 +4,20 @@
 
 // Main client
 export { ClawlogicClient } from './client.js';
+export {
+  bridge,
+  bridgeQuote,
+  bridgeStatus,
+  bridgeExecute,
+} from './bridge.js';
+export type {
+  LiFiQuoteRequest,
+  LiFiQuoteResponse,
+  LiFiStatusRequest,
+  LiFiStatusResponse,
+  LiFiExecuteRequest,
+  LiFiExecuteResult,
+} from './bridge.js';
 
 // Phase 1: Identity & Trust infrastructure
 export { IdentityClient } from './identity.js';