@usekova/evm 0.1.0 → 2.0.0

package/README.md

@@ -0,0 +1,51 @@
+# @usekova/evm
+
+EVM anchoring utilities for on-chain covenant verification with ABI encoding and Keccak-256 hashing.
+
+## Installation
+
+```bash
+npm install @usekova/evm
+```
+
+## Key APIs
+
+- **EVMClient**: Client for anchoring and verifying covenants on-chain via a user-supplied JSON-RPC provider. No ethers.js dependency.
+- **encodeUint256() / decodeUint256()**: ABI encode/decode uint256 values.
+- **encodeBytes32() / decodeBytes32()**: ABI encode/decode bytes32 values.
+- **encodeAddress() / decodeAddress()**: ABI encode/decode EVM addresses with EIP-55 checksumming.
+- **encodeString()**: ABI encode dynamic strings.
+- **encodeFunctionCall()**: Concatenate a 4-byte selector with ABI-encoded parameters.
+- **computeFunctionSelector()**: Compute the 4-byte Keccak-256 selector for a Solidity function signature.
+- **buildAnchorCalldata() / parseAnchorFromCalldata()**: Encode/decode covenant anchor calldata.
+- **computeAnchorHash()**: Deterministic Keccak-256 hash of a CovenantAnchor.
+- **checksumAddress()**: EIP-55 mixed-case checksum encoding.
+- **isValidAddress()**: Validate EVM addresses.
+- **keccak256()**: Keccak-256 hashing for EVM-compatible use cases.
+- **STELE_REGISTRY_ABI**: JSON ABI for the on-chain Stele registry contract.
+
+## Usage
+
+```typescript
+import { EVMClient, buildAnchorCalldata, computeAnchorHash } from '@usekova/evm';
+
+// Plug in any JSON-RPC provider (ethers, viem, raw fetch, etc.)
+const client = new EVMClient(myProvider, '0xRegistryAddress');
+
+const anchor = {
+  covenantId: '00'.repeat(32),
+  constraintsHash: 'ab'.repeat(32),
+  issuerAddress: '0x' + '11'.repeat(20),
+  beneficiaryAddress: '0x' + '22'.repeat(20),
+  timestamp: BigInt(Date.now()),
+  chainId: 1,
+};
+
+const txHash = await client.anchorCovenant(anchor, fromAddress);
+const receipt = await client.waitForTransaction(txHash);
+const isAnchored = await client.verifyCovenant(anchor.covenantId);
+```
+
+## Docs
+
+See the [Stele SDK root documentation](../../README.md) for the full API reference.

package/dist/index.d.ts

@@ -1,7 +1,308 @@
 /**
- * @stele/evm — Solidity contracts and ethers.js bindings for on-chain anchoring.
+ * @usekova/evm — EVM anchoring utilities for on-chain covenant verification.
+ *
+ * Provides ABI encoding/decoding, contract interface definitions, and
+ * anchor/verify helpers for EVM-compatible blockchains. No ethers.js dependency.
  *
  * @packageDocumentation
  */
-export {};
+/**
+ * Compute the Keccak-256 hash of a hex string input.
+ * This is the real EVM hash function, not a SHA-256 placeholder.
+ * @param input - String to hash
+ * @returns 64-character lowercase hex hash string
+ */
+declare function keccak256String(input: string): string;
+/**
+ * ABI encode a uint256 value as a 64-character hex string, left-padded with zeros.
+ * @param value - Non-negative bigint that fits in 256 bits
+ * @returns 64-character hex string (no 0x prefix)
+ */
+export declare function encodeUint256(value: bigint): string;
+/**
+ * ABI encode a bytes32 value. The value is right-padded to 32 bytes per ABI spec.
+ * @param hex - Hex string (with or without 0x prefix), at most 64 hex chars
+ * @returns 64-character hex string (no 0x prefix)
+ */
+export declare function encodeBytes32(hex: string): string;
+/**
+ * ABI encode an address (20 bytes) left-padded to 32 bytes.
+ * @param address - 20-byte hex address (with or without 0x prefix)
+ * @returns 64-character hex string (no 0x prefix)
+ */
+export declare function encodeAddress(address: string): string;
+/**
+ * ABI encode a dynamic string. Returns length (32 bytes) followed by
+ * the UTF-8 data right-padded to the next 32-byte boundary.
+ *
+ * Note: when used in a function call with mixed static/dynamic types,
+ * an offset pointer must be handled separately.
+ *
+ * @param value - The string to encode
+ * @returns Hex string: 64-char length + padded data (no 0x prefix)
+ */
+export declare function encodeString(value: string): string;
+/**
+ * Decode a 64-character hex string as a uint256 bigint.
+ * @param hex - 64-character hex string (with or without 0x prefix)
+ */
+export declare function decodeUint256(hex: string): bigint;
+/**
+ * Decode a 64-character hex string as bytes32.
+ * @param hex - 64-character hex string (with or without 0x prefix)
+ * @returns 64-character lowercase hex string (no 0x prefix)
+ */
+export declare function decodeBytes32(hex: string): string;
+/**
+ * Decode a 64-character hex string as an EVM address.
+ * The address is extracted from the rightmost 40 characters (left-padded).
+ * @param hex - 64-character hex string (with or without 0x prefix)
+ * @returns Checksummed address with 0x prefix
+ */
+export declare function decodeAddress(hex: string): string;
+/**
+ * Concatenate a 4-byte function selector with ABI-encoded parameters.
+ * @param selector - 4-byte function selector (8 hex chars, with or without 0x prefix)
+ * @param params - Already ABI-encoded parameter strings (each 64 hex chars for static types)
+ * @returns Hex string with 0x prefix: selector + concatenated params
+ */
+export declare function encodeFunctionCall(selector: string, ...params: string[]): string;
+/**
+ * Compute the 4-byte function selector for a Solidity function signature.
+ * Uses Keccak-256 as per the Ethereum ABI specification.
+ * @param signature - Canonical function signature, e.g., "transfer(address,uint256)"
+ * @returns 8-character hex string (4 bytes, no 0x prefix)
+ */
+export declare function computeFunctionSelector(signature: string): string;
+/**
+ * Represents an on-chain covenant anchor with all data needed for verification.
+ */
+export interface CovenantAnchor {
+    /** Unique identifier for the covenant (64-char lowercase hex, maps to bytes32). */
+    covenantId: string;
+    /** Hash of the covenant's constraint document (64-char lowercase hex, maps to bytes32). */
+    constraintsHash: string;
+    /** EVM address of the covenant issuer (0x-prefixed, 20 bytes). */
+    issuerAddress: string;
+    /** EVM address of the covenant beneficiary (0x-prefixed, 20 bytes). */
+    beneficiaryAddress: string;
+    /** Unix timestamp of when the anchor was created. */
+    timestamp: bigint;
+    /** EVM chain ID where the anchor exists (e.g., 1 for mainnet). */
+    chainId: number;
+}
+/**
+ * Encode a CovenantAnchor as EVM calldata for the registry's anchor() function.
+ * The chainId is not included in calldata — it is implicit from the chain.
+ * @param anchor - The covenant anchor to encode
+ * @returns Hex calldata string with 0x prefix
+ */
+export declare function buildAnchorCalldata(anchor: CovenantAnchor): string;
+/**
+ * Parse EVM calldata back into a CovenantAnchor.
+ * The chainId defaults to 1 (mainnet) since it is not encoded in calldata.
+ * @param calldata - Hex calldata string (with or without 0x prefix)
+ * @returns Decoded CovenantAnchor
+ */
+export declare function parseAnchorFromCalldata(calldata: string): CovenantAnchor;
+/**
+ * Compute a deterministic hash of a CovenantAnchor.
+ * All fields (including chainId) are ABI-encoded, concatenated, and hashed.
+ * @param anchor - The covenant anchor to hash
+ * @returns 64-character lowercase hex hash string
+ */
+export declare function computeAnchorHash(anchor: CovenantAnchor): string;
+/**
+ * JSON ABI array for the Stele on-chain registry contract.
+ * Defines the methods: anchor(), verify(), and getAnchor().
+ */
+export declare const STELE_REGISTRY_ABI: readonly [{
+    readonly name: "anchor";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "covenantId";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "constraintsHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "issuer";
+        readonly type: "address";
+    }, {
+        readonly name: "beneficiary";
+        readonly type: "address";
+    }, {
+        readonly name: "timestamp";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly name: "verify";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "covenantId";
+        readonly type: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly name: "getAnchor";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "covenantId";
+        readonly type: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "constraintsHash";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "issuer";
+        readonly type: "address";
+    }, {
+        readonly name: "beneficiary";
+        readonly type: "address";
+    }, {
+        readonly name: "timestamp";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}];
+/**
+ * TypeScript interface matching the Stele on-chain registry contract ABI.
+ */
+export interface SteleRegistryInterface {
+    /** Anchor a covenant on-chain. */
+    anchor(covenantId: string, constraintsHash: string, issuer: string, beneficiary: string, timestamp: bigint): void;
+    /** Check whether a covenant has been anchored. */
+    verify(covenantId: string): boolean;
+    /** Retrieve anchor data for a covenant. */
+    getAnchor(covenantId: string): {
+        constraintsHash: string;
+        issuer: string;
+        beneficiary: string;
+        timestamp: bigint;
+    };
+}
+/**
+ * Check if a hex string is a valid EVM address (20 bytes with 0x prefix).
+ * @param address - The string to validate
+ * @returns true if the address is well-formed
+ */
+export declare function isValidAddress(address: string): boolean;
+/**
+ * Apply EIP-55 mixed-case checksum encoding to an address.
+ * Uses Keccak-256 as specified by EIP-55.
+ *
+ * @param address - A valid EVM address (0x-prefixed, 40 hex chars)
+ * @returns The same address with EIP-55 mixed-case checksum encoding
+ */
+export declare function checksumAddress(address: string): string;
+/**
+ * Convert a covenant ID (64-char hex string) to 0x-prefixed bytes32 format.
+ * @param id - 64-character hex string (with or without 0x prefix)
+ * @returns 0x-prefixed lowercase hex string (66 chars total)
+ */
+export declare function covenantIdToBytes32(id: string): string;
+/**
+ * Minimal JSON-RPC provider interface for EVM interaction.
+ * Consumers supply their own transport (HTTP, WebSocket, IPC).
+ */
+export interface EVMProvider {
+    /** Send a JSON-RPC request and return the result. */
+    request(args: {
+        method: string;
+        params?: unknown[];
+    }): Promise<unknown>;
+}
+/**
+ * Transaction request for sending to the network.
+ */
+export interface TransactionRequest {
+    /** Target contract address (0x-prefixed). */
+    to: string;
+    /** Hex-encoded calldata (0x-prefixed). */
+    data: string;
+    /** Optional value in wei (hex-encoded). */
+    value?: string;
+    /** Optional gas limit (hex-encoded). */
+    gas?: string;
+    /** Sender address (0x-prefixed). */
+    from?: string;
+}
+/**
+ * Transaction receipt returned after confirmation.
+ */
+export interface TransactionReceipt {
+    /** Transaction hash. */
+    transactionHash: string;
+    /** Block number (hex-encoded). */
+    blockNumber: string;
+    /** Status: '0x1' for success, '0x0' for revert. */
+    status: string;
+    /** Gas used (hex-encoded). */
+    gasUsed: string;
+}
+/**
+ * EVM client for anchoring and verifying covenants on-chain.
+ *
+ * Requires a user-supplied {@link EVMProvider} for actual network interaction.
+ * This keeps the package dependency-free while supporting any EVM-compatible chain.
+ *
+ * @example
+ * ```typescript
+ * import { EVMClient } from '@usekova/evm';
+ *
+ * // Plug in any provider (ethers, viem, raw fetch, etc.)
+ * const client = new EVMClient(myProvider, '0xRegistryAddress');
+ * const txHash = await client.anchorCovenant(anchor);
+ * const isAnchored = await client.verifyCovenant(covenantId);
+ * ```
+ */
+export declare class EVMClient {
+    private readonly provider;
+    private readonly registryAddress;
+    constructor(provider: EVMProvider, registryAddress: string);
+    /**
+     * Anchor a covenant on-chain by calling the registry's anchor() function.
+     *
+     * @param anchor - The covenant anchor data to write on-chain.
+     * @param from - The sender address (must be unlocked in the provider).
+     * @returns The transaction hash.
+     */
+    anchorCovenant(anchor: CovenantAnchor, from: string): Promise<string>;
+    /**
+     * Verify whether a covenant has been anchored on-chain.
+     *
+     * @param covenantId - The 64-char hex covenant ID to check.
+     * @returns true if the covenant is anchored, false otherwise.
+     */
+    verifyCovenant(covenantId: string): Promise<boolean>;
+    /**
+     * Retrieve anchor data for a covenant from the on-chain registry.
+     *
+     * @param covenantId - The 64-char hex covenant ID to look up.
+     * @returns The anchor data, or null if not found.
+     */
+    getAnchor(covenantId: string): Promise<CovenantAnchor | null>;
+    /**
+     * Wait for a transaction to be confirmed.
+     *
+     * @param txHash - The transaction hash to wait for.
+     * @param maxAttempts - Maximum polling attempts (default: 30).
+     * @param intervalMs - Polling interval in milliseconds (default: 2000).
+     * @returns The transaction receipt, or null if not confirmed within maxAttempts.
+     */
+    waitForTransaction(txHash: string, maxAttempts?: number, intervalMs?: number): Promise<TransactionReceipt | null>;
+    /**
+     * Get the current chain ID from the provider.
+     * @returns The chain ID as a number.
+     */
+    getChainId(): Promise<number>;
+}
+/** Export keccak256String for consumers who need EVM-compatible hashing. */
+export { keccak256String as keccak256 };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -1,8 +1,389 @@
 "use strict";
-/**
- * @stele/evm — Solidity contracts and ethers.js bindings for on-chain anchoring.
- *
- * @packageDocumentation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=index.js.map
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EVMClient: () => EVMClient,
+  STELE_REGISTRY_ABI: () => STELE_REGISTRY_ABI,
+  buildAnchorCalldata: () => buildAnchorCalldata,
+  checksumAddress: () => checksumAddress,
+  computeAnchorHash: () => computeAnchorHash,
+  computeFunctionSelector: () => computeFunctionSelector,
+  covenantIdToBytes32: () => covenantIdToBytes32,
+  decodeAddress: () => decodeAddress,
+  decodeBytes32: () => decodeBytes32,
+  decodeUint256: () => decodeUint256,
+  encodeAddress: () => encodeAddress,
+  encodeBytes32: () => encodeBytes32,
+  encodeFunctionCall: () => encodeFunctionCall,
+  encodeString: () => encodeString,
+  encodeUint256: () => encodeUint256,
+  isValidAddress: () => isValidAddress,
+  keccak256: () => keccak256String,
+  parseAnchorFromCalldata: () => parseAnchorFromCalldata
+});
+module.exports = __toCommonJS(index_exports);
+var import_sha3 = require("@noble/hashes/sha3");
+var MAX_UINT256 = 2n ** 256n - 1n;
+function strip0x(hex) {
+  return hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
+}
+function keccak256String(input) {
+  const bytes = new TextEncoder().encode(input);
+  const hash = (0, import_sha3.keccak_256)(bytes);
+  let hex = "";
+  for (let i = 0; i < hash.length; i++) {
+    hex += hash[i].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function keccak256Hex(hexData) {
+  const bytes = new Uint8Array(hexData.length / 2);
+  for (let i = 0; i < hexData.length; i += 2) {
+    bytes[i / 2] = parseInt(hexData.substring(i, i + 2), 16);
+  }
+  const hash = (0, import_sha3.keccak_256)(bytes);
+  let hex = "";
+  for (let i = 0; i < hash.length; i++) {
+    hex += hash[i].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function encodeUint256(value) {
+  if (value < 0n) {
+    throw new Error("uint256 cannot be negative");
+  }
+  if (value > MAX_UINT256) {
+    throw new Error("uint256 overflow");
+  }
+  return value.toString(16).padStart(64, "0");
+}
+function encodeBytes32(hex) {
+  const clean = strip0x(hex);
+  if (clean.length > 64) {
+    throw new Error("bytes32 value exceeds 32 bytes");
+  }
+  if (clean.length > 0 && !/^[0-9a-fA-F]+$/.test(clean)) {
+    throw new Error("Invalid hex string");
+  }
+  return clean.toLowerCase().padEnd(64, "0");
+}
+function encodeAddress(address) {
+  const clean = strip0x(address).toLowerCase();
+  if (clean.length !== 40) {
+    throw new Error("Invalid address: must be 20 bytes (40 hex chars)");
+  }
+  if (!/^[0-9a-f]{40}$/.test(clean)) {
+    throw new Error("Invalid address: not valid hex");
+  }
+  return clean.padStart(64, "0");
+}
+function encodeString(value) {
+  const bytes = new TextEncoder().encode(value);
+  const length = encodeUint256(BigInt(bytes.length));
+  if (bytes.length === 0) {
+    return length;
+  }
+  const paddedLength = Math.ceil(bytes.length / 32) * 32;
+  let dataHex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    dataHex += bytes[i].toString(16).padStart(2, "0");
+  }
+  dataHex = dataHex.padEnd(paddedLength * 2, "0");
+  return length + dataHex;
+}
+function decodeUint256(hex) {
+  const clean = strip0x(hex);
+  if (clean.length !== 64) {
+    throw new Error("Expected 64-character hex string for uint256");
+  }
+  return BigInt("0x" + clean);
+}
+function decodeBytes32(hex) {
+  const clean = strip0x(hex);
+  if (clean.length !== 64) {
+    throw new Error("Expected 64-character hex string for bytes32");
+  }
+  return clean.toLowerCase();
+}
+function decodeAddress(hex) {
+  const clean = strip0x(hex);
+  if (clean.length !== 64) {
+    throw new Error("Expected 64-character hex string for address");
+  }
+  const addrHex = clean.slice(24);
+  return checksumAddress("0x" + addrHex);
+}
+function encodeFunctionCall(selector, ...params) {
+  const cleanSelector = strip0x(selector);
+  if (cleanSelector.length !== 8) {
+    throw new Error("Function selector must be 4 bytes (8 hex chars)");
+  }
+  return "0x" + cleanSelector + params.join("");
+}
+function computeFunctionSelector(signature) {
+  const hash = keccak256String(signature);
+  return hash.slice(0, 8);
+}
+var ANCHOR_SELECTOR = computeFunctionSelector(
+  "anchor(bytes32,bytes32,address,address,uint256)"
+);
+function buildAnchorCalldata(anchor) {
+  return encodeFunctionCall(
+    ANCHOR_SELECTOR,
+    encodeBytes32(anchor.covenantId),
+    encodeBytes32(anchor.constraintsHash),
+    encodeAddress(anchor.issuerAddress),
+    encodeAddress(anchor.beneficiaryAddress),
+    encodeUint256(anchor.timestamp)
+  );
+}
+function parseAnchorFromCalldata(calldata) {
+  const data = strip0x(calldata);
+  if (data.length < 328) {
+    throw new Error("Calldata too short for anchor function");
+  }
+  const selector = data.slice(0, 8);
+  if (selector !== ANCHOR_SELECTOR) {
+    throw new Error(
+      `Invalid function selector: expected ${ANCHOR_SELECTOR}, got ${selector}`
+    );
+  }
+  const covenantId = decodeBytes32(data.slice(8, 72));
+  const constraintsHash = decodeBytes32(data.slice(72, 136));
+  const issuerAddress = decodeAddress(data.slice(136, 200));
+  const beneficiaryAddress = decodeAddress(data.slice(200, 264));
+  const timestamp = decodeUint256(data.slice(264, 328));
+  return {
+    covenantId,
+    constraintsHash,
+    issuerAddress,
+    beneficiaryAddress,
+    timestamp,
+    chainId: 1
+  };
+}
+function computeAnchorHash(anchor) {
+  const encoded = encodeBytes32(anchor.covenantId) + encodeBytes32(anchor.constraintsHash) + encodeAddress(anchor.issuerAddress) + encodeAddress(anchor.beneficiaryAddress) + encodeUint256(anchor.timestamp) + encodeUint256(BigInt(anchor.chainId));
+  return keccak256Hex(encoded);
+}
+var STELE_REGISTRY_ABI = [
+  {
+    name: "anchor",
+    type: "function",
+    inputs: [
+      { name: "covenantId", type: "bytes32" },
+      { name: "constraintsHash", type: "bytes32" },
+      { name: "issuer", type: "address" },
+      { name: "beneficiary", type: "address" },
+      { name: "timestamp", type: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    name: "verify",
+    type: "function",
+    inputs: [{ name: "covenantId", type: "bytes32" }],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    name: "getAnchor",
+    type: "function",
+    inputs: [{ name: "covenantId", type: "bytes32" }],
+    outputs: [
+      { name: "constraintsHash", type: "bytes32" },
+      { name: "issuer", type: "address" },
+      { name: "beneficiary", type: "address" },
+      { name: "timestamp", type: "uint256" }
+    ],
+    stateMutability: "view"
+  }
+];
+function isValidAddress(address) {
+  if (typeof address !== "string") return false;
+  if (!address.startsWith("0x")) return false;
+  const hex = address.slice(2);
+  if (hex.length !== 40) return false;
+  return /^[0-9a-fA-F]{40}$/.test(hex);
+}
+function checksumAddress(address) {
+  if (!isValidAddress(address)) {
+    throw new Error("Invalid EVM address");
+  }
+  const lower = address.slice(2).toLowerCase();
+  const hash = keccak256String(lower);
+  let result = "0x";
+  for (let i = 0; i < 40; i++) {
+    const c = lower[i];
+    if (/[a-f]/.test(c)) {
+      const hashNibble = parseInt(hash[i], 16);
+      result += hashNibble >= 8 ? c.toUpperCase() : c;
+    } else {
+      result += c;
+    }
+  }
+  return result;
+}
+function covenantIdToBytes32(id) {
+  const clean = strip0x(id);
+  if (clean.length !== 64) {
+    throw new Error("Covenant ID must be 32 bytes (64 hex chars)");
+  }
+  if (!/^[0-9a-fA-F]{64}$/.test(clean)) {
+    throw new Error("Invalid hex string");
+  }
+  return "0x" + clean.toLowerCase();
+}
+var EVMClient = class {
+  provider;
+  registryAddress;
+  constructor(provider, registryAddress) {
+    if (!isValidAddress(registryAddress)) {
+      throw new Error("Invalid registry address");
+    }
+    this.provider = provider;
+    this.registryAddress = registryAddress;
+  }
+  /**
+   * Anchor a covenant on-chain by calling the registry's anchor() function.
+   *
+   * @param anchor - The covenant anchor data to write on-chain.
+   * @param from - The sender address (must be unlocked in the provider).
+   * @returns The transaction hash.
+   */
+  async anchorCovenant(anchor, from) {
+    const calldata = buildAnchorCalldata(anchor);
+    const txHash = await this.provider.request({
+      method: "eth_sendTransaction",
+      params: [{
+        from,
+        to: this.registryAddress,
+        data: calldata
+      }]
+    });
+    return txHash;
+  }
+  /**
+   * Verify whether a covenant has been anchored on-chain.
+   *
+   * @param covenantId - The 64-char hex covenant ID to check.
+   * @returns true if the covenant is anchored, false otherwise.
+   */
+  async verifyCovenant(covenantId) {
+    const selector = computeFunctionSelector("verify(bytes32)");
+    const calldata = "0x" + selector + encodeBytes32(covenantId);
+    const result = await this.provider.request({
+      method: "eth_call",
+      params: [{
+        to: this.registryAddress,
+        data: calldata
+      }, "latest"]
+    });
+    return result !== "0x" + "0".repeat(64);
+  }
+  /**
+   * Retrieve anchor data for a covenant from the on-chain registry.
+   *
+   * @param covenantId - The 64-char hex covenant ID to look up.
+   * @returns The anchor data, or null if not found.
+   */
+  async getAnchor(covenantId) {
+    const selector = computeFunctionSelector("getAnchor(bytes32)");
+    const calldata = "0x" + selector + encodeBytes32(covenantId);
+    const result = await this.provider.request({
+      method: "eth_call",
+      params: [{
+        to: this.registryAddress,
+        data: calldata
+      }, "latest"]
+    });
+    const data = result.startsWith("0x") ? result.slice(2) : result;
+    if (!data || data === "0".repeat(256)) {
+      return null;
+    }
+    const constraintsHash = decodeBytes32(data.slice(0, 64));
+    const issuerAddress = decodeAddress(data.slice(64, 128));
+    const beneficiaryAddress = decodeAddress(data.slice(128, 192));
+    const timestamp = decodeUint256(data.slice(192, 256));
+    return {
+      covenantId,
+      constraintsHash,
+      issuerAddress,
+      beneficiaryAddress,
+      timestamp,
+      chainId: 1
+    };
+  }
+  /**
+   * Wait for a transaction to be confirmed.
+   *
+   * @param txHash - The transaction hash to wait for.
+   * @param maxAttempts - Maximum polling attempts (default: 30).
+   * @param intervalMs - Polling interval in milliseconds (default: 2000).
+   * @returns The transaction receipt, or null if not confirmed within maxAttempts.
+   */
+  async waitForTransaction(txHash, maxAttempts = 30, intervalMs = 2e3) {
+    for (let i = 0; i < maxAttempts; i++) {
+      const receipt = await this.provider.request({
+        method: "eth_getTransactionReceipt",
+        params: [txHash]
+      });
+      if (receipt) {
+        return receipt;
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    return null;
+  }
+  /**
+   * Get the current chain ID from the provider.
+   * @returns The chain ID as a number.
+   */
+  async getChainId() {
+    const result = await this.provider.request({
+      method: "eth_chainId",
+      params: []
+    });
+    return parseInt(result, 16);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EVMClient,
+  STELE_REGISTRY_ABI,
+  buildAnchorCalldata,
+  checksumAddress,
+  computeAnchorHash,
+  computeFunctionSelector,
+  covenantIdToBytes32,
+  decodeAddress,
+  decodeBytes32,
+  decodeUint256,
+  encodeAddress,
+  encodeBytes32,
+  encodeFunctionCall,
+  encodeString,
+  encodeUint256,
+  isValidAddress,
+  keccak256,
+  parseAnchorFromCalldata
+});

package/dist/index.mjs

@@ -0,0 +1,347 @@
+// src/index.ts
+import { keccak_256 } from "@noble/hashes/sha3";
+var MAX_UINT256 = 2n ** 256n - 1n;
+function strip0x(hex) {
+  return hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
+}
+function keccak256String(input) {
+  const bytes = new TextEncoder().encode(input);
+  const hash = keccak_256(bytes);
+  let hex = "";
+  for (let i = 0; i < hash.length; i++) {
+    hex += hash[i].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function keccak256Hex(hexData) {
+  const bytes = new Uint8Array(hexData.length / 2);
+  for (let i = 0; i < hexData.length; i += 2) {
+    bytes[i / 2] = parseInt(hexData.substring(i, i + 2), 16);
+  }
+  const hash = keccak_256(bytes);
+  let hex = "";
+  for (let i = 0; i < hash.length; i++) {
+    hex += hash[i].toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function encodeUint256(value) {
+  if (value < 0n) {
+    throw new Error("uint256 cannot be negative");
+  }
+  if (value > MAX_UINT256) {
+    throw new Error("uint256 overflow");
+  }
+  return value.toString(16).padStart(64, "0");
+}
+function encodeBytes32(hex) {
+  const clean = strip0x(hex);
+  if (clean.length > 64) {
+    throw new Error("bytes32 value exceeds 32 bytes");
+  }
+  if (clean.length > 0 && !/^[0-9a-fA-F]+$/.test(clean)) {
+    throw new Error("Invalid hex string");
+  }
+  return clean.toLowerCase().padEnd(64, "0");
+}
+function encodeAddress(address) {
+  const clean = strip0x(address).toLowerCase();
+  if (clean.length !== 40) {
+    throw new Error("Invalid address: must be 20 bytes (40 hex chars)");
+  }
+  if (!/^[0-9a-f]{40}$/.test(clean)) {
+    throw new Error("Invalid address: not valid hex");
+  }
+  return clean.padStart(64, "0");
+}
+function encodeString(value) {
+  const bytes = new TextEncoder().encode(value);
+  const length = encodeUint256(BigInt(bytes.length));
+  if (bytes.length === 0) {
+    return length;
+  }
+  const paddedLength = Math.ceil(bytes.length / 32) * 32;
+  let dataHex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    dataHex += bytes[i].toString(16).padStart(2, "0");
+  }
+  dataHex = dataHex.padEnd(paddedLength * 2, "0");
+  return length + dataHex;
+}
+function decodeUint256(hex) {
+  const clean = strip0x(hex);
+  if (clean.length !== 64) {
+    throw new Error("Expected 64-character hex string for uint256");
+  }
+  return BigInt("0x" + clean);
+}
+function decodeBytes32(hex) {
+  const clean = strip0x(hex);
+  if (clean.length !== 64) {
+    throw new Error("Expected 64-character hex string for bytes32");
+  }
+  return clean.toLowerCase();
+}
+function decodeAddress(hex) {
+  const clean = strip0x(hex);
+  if (clean.length !== 64) {
+    throw new Error("Expected 64-character hex string for address");
+  }
+  const addrHex = clean.slice(24);
+  return checksumAddress("0x" + addrHex);
+}
+function encodeFunctionCall(selector, ...params) {
+  const cleanSelector = strip0x(selector);
+  if (cleanSelector.length !== 8) {
+    throw new Error("Function selector must be 4 bytes (8 hex chars)");
+  }
+  return "0x" + cleanSelector + params.join("");
+}
+function computeFunctionSelector(signature) {
+  const hash = keccak256String(signature);
+  return hash.slice(0, 8);
+}
+var ANCHOR_SELECTOR = computeFunctionSelector(
+  "anchor(bytes32,bytes32,address,address,uint256)"
+);
+function buildAnchorCalldata(anchor) {
+  return encodeFunctionCall(
+    ANCHOR_SELECTOR,
+    encodeBytes32(anchor.covenantId),
+    encodeBytes32(anchor.constraintsHash),
+    encodeAddress(anchor.issuerAddress),
+    encodeAddress(anchor.beneficiaryAddress),
+    encodeUint256(anchor.timestamp)
+  );
+}
+function parseAnchorFromCalldata(calldata) {
+  const data = strip0x(calldata);
+  if (data.length < 328) {
+    throw new Error("Calldata too short for anchor function");
+  }
+  const selector = data.slice(0, 8);
+  if (selector !== ANCHOR_SELECTOR) {
+    throw new Error(
+      `Invalid function selector: expected ${ANCHOR_SELECTOR}, got ${selector}`
+    );
+  }
+  const covenantId = decodeBytes32(data.slice(8, 72));
+  const constraintsHash = decodeBytes32(data.slice(72, 136));
+  const issuerAddress = decodeAddress(data.slice(136, 200));
+  const beneficiaryAddress = decodeAddress(data.slice(200, 264));
+  const timestamp = decodeUint256(data.slice(264, 328));
+  return {
+    covenantId,
+    constraintsHash,
+    issuerAddress,
+    beneficiaryAddress,
+    timestamp,
+    chainId: 1
+  };
+}
+function computeAnchorHash(anchor) {
+  const encoded = encodeBytes32(anchor.covenantId) + encodeBytes32(anchor.constraintsHash) + encodeAddress(anchor.issuerAddress) + encodeAddress(anchor.beneficiaryAddress) + encodeUint256(anchor.timestamp) + encodeUint256(BigInt(anchor.chainId));
+  return keccak256Hex(encoded);
+}
+var STELE_REGISTRY_ABI = [
+  {
+    name: "anchor",
+    type: "function",
+    inputs: [
+      { name: "covenantId", type: "bytes32" },
+      { name: "constraintsHash", type: "bytes32" },
+      { name: "issuer", type: "address" },
+      { name: "beneficiary", type: "address" },
+      { name: "timestamp", type: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    name: "verify",
+    type: "function",
+    inputs: [{ name: "covenantId", type: "bytes32" }],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    name: "getAnchor",
+    type: "function",
+    inputs: [{ name: "covenantId", type: "bytes32" }],
+    outputs: [
+      { name: "constraintsHash", type: "bytes32" },
+      { name: "issuer", type: "address" },
+      { name: "beneficiary", type: "address" },
+      { name: "timestamp", type: "uint256" }
+    ],
+    stateMutability: "view"
+  }
+];
+function isValidAddress(address) {
+  if (typeof address !== "string") return false;
+  if (!address.startsWith("0x")) return false;
+  const hex = address.slice(2);
+  if (hex.length !== 40) return false;
+  return /^[0-9a-fA-F]{40}$/.test(hex);
+}
+function checksumAddress(address) {
+  if (!isValidAddress(address)) {
+    throw new Error("Invalid EVM address");
+  }
+  const lower = address.slice(2).toLowerCase();
+  const hash = keccak256String(lower);
+  let result = "0x";
+  for (let i = 0; i < 40; i++) {
+    const c = lower[i];
+    if (/[a-f]/.test(c)) {
+      const hashNibble = parseInt(hash[i], 16);
+      result += hashNibble >= 8 ? c.toUpperCase() : c;
+    } else {
+      result += c;
+    }
+  }
+  return result;
+}
+function covenantIdToBytes32(id) {
+  const clean = strip0x(id);
+  if (clean.length !== 64) {
+    throw new Error("Covenant ID must be 32 bytes (64 hex chars)");
+  }
+  if (!/^[0-9a-fA-F]{64}$/.test(clean)) {
+    throw new Error("Invalid hex string");
+  }
+  return "0x" + clean.toLowerCase();
+}
+var EVMClient = class {
+  provider;
+  registryAddress;
+  constructor(provider, registryAddress) {
+    if (!isValidAddress(registryAddress)) {
+      throw new Error("Invalid registry address");
+    }
+    this.provider = provider;
+    this.registryAddress = registryAddress;
+  }
+  /**
+   * Anchor a covenant on-chain by calling the registry's anchor() function.
+   *
+   * @param anchor - The covenant anchor data to write on-chain.
+   * @param from - The sender address (must be unlocked in the provider).
+   * @returns The transaction hash.
+   */
+  async anchorCovenant(anchor, from) {
+    const calldata = buildAnchorCalldata(anchor);
+    const txHash = await this.provider.request({
+      method: "eth_sendTransaction",
+      params: [{
+        from,
+        to: this.registryAddress,
+        data: calldata
+      }]
+    });
+    return txHash;
+  }
+  /**
+   * Verify whether a covenant has been anchored on-chain.
+   *
+   * @param covenantId - The 64-char hex covenant ID to check.
+   * @returns true if the covenant is anchored, false otherwise.
+   */
+  async verifyCovenant(covenantId) {
+    const selector = computeFunctionSelector("verify(bytes32)");
+    const calldata = "0x" + selector + encodeBytes32(covenantId);
+    const result = await this.provider.request({
+      method: "eth_call",
+      params: [{
+        to: this.registryAddress,
+        data: calldata
+      }, "latest"]
+    });
+    return result !== "0x" + "0".repeat(64);
+  }
+  /**
+   * Retrieve anchor data for a covenant from the on-chain registry.
+   *
+   * @param covenantId - The 64-char hex covenant ID to look up.
+   * @returns The anchor data, or null if not found.
+   */
+  async getAnchor(covenantId) {
+    const selector = computeFunctionSelector("getAnchor(bytes32)");
+    const calldata = "0x" + selector + encodeBytes32(covenantId);
+    const result = await this.provider.request({
+      method: "eth_call",
+      params: [{
+        to: this.registryAddress,
+        data: calldata
+      }, "latest"]
+    });
+    const data = result.startsWith("0x") ? result.slice(2) : result;
+    if (!data || data === "0".repeat(256)) {
+      return null;
+    }
+    const constraintsHash = decodeBytes32(data.slice(0, 64));
+    const issuerAddress = decodeAddress(data.slice(64, 128));
+    const beneficiaryAddress = decodeAddress(data.slice(128, 192));
+    const timestamp = decodeUint256(data.slice(192, 256));
+    return {
+      covenantId,
+      constraintsHash,
+      issuerAddress,
+      beneficiaryAddress,
+      timestamp,
+      chainId: 1
+    };
+  }
+  /**
+   * Wait for a transaction to be confirmed.
+   *
+   * @param txHash - The transaction hash to wait for.
+   * @param maxAttempts - Maximum polling attempts (default: 30).
+   * @param intervalMs - Polling interval in milliseconds (default: 2000).
+   * @returns The transaction receipt, or null if not confirmed within maxAttempts.
+   */
+  async waitForTransaction(txHash, maxAttempts = 30, intervalMs = 2e3) {
+    for (let i = 0; i < maxAttempts; i++) {
+      const receipt = await this.provider.request({
+        method: "eth_getTransactionReceipt",
+        params: [txHash]
+      });
+      if (receipt) {
+        return receipt;
+      }
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+    return null;
+  }
+  /**
+   * Get the current chain ID from the provider.
+   * @returns The chain ID as a number.
+   */
+  async getChainId() {
+    const result = await this.provider.request({
+      method: "eth_chainId",
+      params: []
+    });
+    return parseInt(result, 16);
+  }
+};
+export {
+  EVMClient,
+  STELE_REGISTRY_ABI,
+  buildAnchorCalldata,
+  checksumAddress,
+  computeAnchorHash,
+  computeFunctionSelector,
+  covenantIdToBytes32,
+  decodeAddress,
+  decodeBytes32,
+  decodeUint256,
+  encodeAddress,
+  encodeBytes32,
+  encodeFunctionCall,
+  encodeString,
+  encodeUint256,
+  isValidAddress,
+  keccak256String as keccak256,
+  parseAnchorFromCalldata
+};

package/dist/index.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.test.d.ts.map

package/dist/index.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.test.d.ts","sourceRoot":"","sources":["../src/index.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,28 +1,44 @@
 {
   "name": "@usekova/evm",
-  "version": "0.1.0",
-  "description": "Solidity contracts and ethers.js bindings for on-chain anchoring",
+  "version": "2.0.0",
+  "description": "EVM anchoring utilities with ABI encoding, Keccak-256 hashing, and JSON-RPC provider interface",
+  "sideEffects": false,
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.js"
+    }
+  },
   "files": [
-    "dist"
+    "dist",
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
-    "build": "tsc --project tsconfig.json",
+    "build": "tsup src/index.ts --format cjs,esm && tsc --emitDeclarationOnly --declaration --outDir dist",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run"
+    "test": "vitest run --config ../../vitest.config.ts",
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@usekova/types": "0.1.0",
-    "@usekova/crypto": "0.1.0",
-    "@usekova/core": "0.1.0"
+    "@usekova/types": "2.0.0",
+    "@usekova/crypto": "2.0.0",
+    "@usekova/core": "2.0.0",
+    "@noble/hashes": "^1.4.0"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
   },
   "publishConfig": {
     "access": "public"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/agbusiness195/stele",
+    "url": "https://github.com/agbusiness195/Stele.git",
     "directory": "packages/evm"
   },
   "homepage": "https://stele.dev",
@@ -30,5 +46,14 @@
     "url": "https://github.com/agbusiness195/stele/issues"
   },
   "author": "Stele Labs, Inc.",
-  "license": "MIT"
+  "keywords": [
+    "stele",
+    "covenant",
+    "ai-accountability",
+    "evm",
+    "ethereum",
+    "solidity",
+    "blockchain"
+  ],
+  "module": "./dist/index.mjs"
 }

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG"}