@steerprotocol/curator-tools 1.0.2

package/README.md

@@ -0,0 +1,104 @@
+# Steer Curator Override Registry
+
+This project implements a centralized "Top-Level Authority" for the EAS (Ethereum Attestation Service) Key-Value store. It allows a protocol administrator to manage a registry of authorized curators who can attest to vault-specific overrides (e.g., updating strategy IPFS hashes).
+
+## Components
+
+### Smart Contracts
+- **SteerAuthorityResolver.sol**: An EAS Schema Resolver that enforces curator permissions. It validates that the attester is authorized for the specified vault and that the attestation is made on the correct network.
+- **Access Control**: Uses OpenZeppelin's `Ownable2Step` for secure management of the top-level authority role.
+
+### Management Tooling
+- **ManageCurators.s.sol**: A Foundry script for programmatically authorizing or revoking curators via CLI.
+
+### Client-Side Integration
+- **StrategyStore.ts**: A TypeScript class providing helpers to check admin status, curator authorization, and encode management transactions. Includes built-in `Zod` validation for runtime safety.
+
+## Getting Started
+
+### Prerequisites
+- [Foundry](https://getfoundry.sh/)
+- [Node.js](https://nodejs.org/) (v18+)
+
+### Installation
+1. Install Foundry dependencies:
+   ```bash
+   forge install
+   ```
+2. Install Node dependencies:
+   ```bash
+   npm install
+   ```
+
+### Testing
+- Run Smart Contract tests:
+  ```bash
+  forge test
+  ```
+- Run Client-Side tests:
+  ```bash
+  npm test
+  ```
+
+## Usage
+
+### Managing Curators via CLI
+To authorize a curator for a vault, use the `ManageCurators` script:
+
+```bash
+export RESOLVER_ADDRESS=<DEPLYOED_RESOLVER>
+export VAULT=<VAULT_ADDRESS>
+export CURATOR=<CURATOR_ADDRESS>
+export STATUS=true # true to authorize, false to revoke
+export PRIVATE_KEY=<ADMIN_PRIVATE_KEY>
+
+forge script script/ManageCurators.s.sol --rpc-url <RPC_URL> --broadcast
+```
+
+### Using the TypeScript Client
+The `@steerprotocol/curator-tools` client (provided by the `StrategyStore` class) provides helpers to interact with the authority layer. It supports automatic address resolution via the `@steerprotocol/sdk`.
+
+#### Basic Initialization
+```typescript
+import { StrategyStore } from '@steerprotocol/curator-tools';
+import { ethers } from 'ethers';
+
+const provider = new ethers.JsonRpcProvider(RPC_URL);
+
+// Automatic resolution for supported networks (e.g., Arbitrum: 42161)
+const store = new StrategyStore({ chainId: 42161 }, provider);
+
+// OR explicit address
+const store = new StrategyStore({ 
+    resolverAddress: '0x...',
+    registryAddress: '0x...' // Optional: Enables strict vault validation
+}, provider);
+```
+
+#### Verification & Transactions
+```typescript
+// Check if a curator is authorized (includes strict vault validation if registry is set)
+const authorized = await store.isCurator(vaultAddress, curatorAddress);
+
+// Generate transaction data for the admin dashboard (async due to registry validation)
+const tx = await store.registerCuratorTx(vaultAddress, curatorAddress, true);
+```
+
+## CI/CD Pipeline
+The project uses GitHub Actions for continuous integration and delivery.
+
+### Automated Testing
+On every pull request and push to `master`, the following checks are performed:
+- **Smart Contracts**: Solidity formatting check (`forge fmt`) and unit tests (`forge test`).
+- **Client Package**: TypeScript type-checking (`tsc`) and unit tests (`npm test`).
+
+### Automated Releases
+Automated versioning and NPM publishing are handled via **Semantic Release**.
+- Releases are triggered on every push to the `master` branch after tests pass.
+- Version numbers and changelogs are automatically generated based on [Conventional Commits](https://www.conventionalcommits.org/).
+- **Required Secrets**: To enable publishing, ensure the repository has an `NPM_TOKEN` secret configured.
+
+## Security
+- All administrative actions are restricted to the `owner`.
+- Attestations are strictly validated against `block.chainid` to prevent replay attacks.
+- Input validation is enforced on both smart contract and client-side levels.

package/dist/index.d.mts

@@ -0,0 +1,59 @@
+import { ethers } from 'ethers';
+
+interface StrategyStoreConfig {
+    chainId?: number;
+    resolverAddress?: string;
+    registryAddress?: string;
+}
+declare class StrategyStore {
+    private resolver;
+    private registry?;
+    private resolverAddress;
+    private registryAddress?;
+    constructor(config: string | StrategyStoreConfig, providerOrSigner: ethers.Provider | ethers.Signer, overrides?: {
+        resolver?: any;
+        registry?: any;
+    });
+    /**
+     * Checks if an address is the top-level admin.
+     * @param address The address to check.
+     */
+    isAdmin(address: string): Promise<boolean>;
+    /**
+
+     * Checks if a curator is authorized for a specific vault.
+
+     * @param vault The vault address.
+
+     * @param curator The curator address.
+
+     */
+    isCurator(vault: string, curator: string): Promise<boolean>;
+    /**
+
+
+
+     * Encodes a transaction to register or revoke a curator.
+
+
+
+     * @param vault The vault address.
+
+
+
+     * @param curator The curator address.
+
+
+
+     * @param status The status to set (default: true).
+
+
+
+     */
+    registerCuratorTx(vault: string, curator: string, status?: boolean): Promise<{
+        to: string;
+        data: string;
+    }>;
+}
+
+export { StrategyStore, type StrategyStoreConfig };

package/dist/index.mjs

@@ -0,0 +1,118 @@
+// src/StrategyStore.ts
+import { ethers } from "ethers";
+import { z } from "zod";
+import { getContractAddressByChainIdAndContractName } from "@steerprotocol/sdk";
+var AddressSchema = z.string().refine((addr) => ethers.isAddress(addr), {
+  message: "Invalid Ethereum address"
+});
+var RESOLVER_ABI = [
+  "function owner() view returns (address)",
+  "function isCurator(address vault, address curator) view returns (bool)",
+  "function setCurator(address vault, address curator, bool status) external"
+];
+var REGISTRY_ABI = [
+  "function totalVaultCount() view returns (uint256)",
+  "function getVaultDetails(address _address) view returns (tuple(uint8 state, uint256 tokenId, uint256 vaultID, string payloadIpfs, address vaultAddress, string beaconName))"
+];
+var StrategyStore = class {
+  resolver;
+  registry;
+  resolverAddress;
+  registryAddress;
+  constructor(config, providerOrSigner, overrides) {
+    let resAddr;
+    let regAddr;
+    if (typeof config === "string") {
+      resAddr = config;
+    } else {
+      resAddr = config.resolverAddress;
+      regAddr = config.registryAddress;
+      if (!resAddr && config.chainId) {
+        resAddr = getContractAddressByChainIdAndContractName(config.chainId, "SteerAuthorityResolver");
+      }
+      if (!regAddr && config.chainId) {
+        regAddr = getContractAddressByChainIdAndContractName(config.chainId, "VaultRegistry");
+        if (!regAddr) {
+          throw new Error(`VaultRegistry address not found for chainId ${config.chainId}`);
+        }
+      }
+    }
+    if (!resAddr) {
+      throw new Error("Resolver address is required (either explicitly or via chainId)");
+    }
+    this.resolverAddress = AddressSchema.parse(resAddr);
+    this.resolver = overrides?.resolver || new ethers.Contract(this.resolverAddress, RESOLVER_ABI, providerOrSigner);
+    if (regAddr) {
+      this.registryAddress = AddressSchema.parse(regAddr);
+      this.registry = overrides?.registry || new ethers.Contract(this.registryAddress, REGISTRY_ABI, providerOrSigner);
+    }
+  }
+  /**
+   * Checks if an address is the top-level admin.
+   * @param address The address to check.
+   */
+  async isAdmin(address) {
+    const validatedAddress = AddressSchema.parse(address);
+    const owner = await this.resolver.owner();
+    return owner.toLowerCase() === validatedAddress.toLowerCase();
+  }
+  /**
+  
+           * Checks if a curator is authorized for a specific vault.
+  
+           * @param vault The vault address.
+  
+           * @param curator The curator address.
+  
+           */
+  async isCurator(vault, curator) {
+    const validatedVault = AddressSchema.parse(vault);
+    const validatedCurator = AddressSchema.parse(curator);
+    if (this.registry) {
+      const details = await this.registry.getVaultDetails(validatedVault);
+      if (details.vaultAddress === ethers.ZeroAddress || details.vaultAddress.toLowerCase() !== validatedVault.toLowerCase()) {
+        throw new Error(`Address ${validatedVault} is not a valid Steer vault`);
+      }
+    }
+    return await this.resolver.isCurator(validatedVault, validatedCurator);
+  }
+  /**
+  
+      
+  
+               * Encodes a transaction to register or revoke a curator.
+  
+      
+  
+               * @param vault The vault address.
+  
+      
+  
+               * @param curator The curator address.
+  
+      
+  
+               * @param status The status to set (default: true).
+  
+      
+  
+               */
+  async registerCuratorTx(vault, curator, status = true) {
+    const validatedVault = AddressSchema.parse(vault);
+    const validatedCurator = AddressSchema.parse(curator);
+    if (this.registry) {
+      const details = await this.registry.getVaultDetails(validatedVault);
+      if (details.vaultAddress === ethers.ZeroAddress || details.vaultAddress.toLowerCase() !== validatedVault.toLowerCase()) {
+        throw new Error(`Address ${validatedVault} is not a valid Steer vault`);
+      }
+    }
+    const data = this.resolver.interface.encodeFunctionData("setCurator", [validatedVault, validatedCurator, status]);
+    return {
+      to: this.resolverAddress,
+      data
+    };
+  }
+};
+export {
+  StrategyStore
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@steerprotocol/curator-tools",
+  "version": "1.0.2",
+  "description": "Steer Protocol Curator Override Tools",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "directories": {
+    "lib": "lib",
+    "test": "test"
+  },
+  "scripts": {
+    "test": "jest",
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [],
+  "author": "Derek Barrera",
+  "license": "ISC",
+  "dependencies": {
+    "@steerprotocol/sdk": "^1.22.4",
+    "ethers": "^6.16.0",
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.2",
+    "@semantic-release/npm": "^13.1.3",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.0.3",
+    "@uniswap/sdk-core": "^7.10.0",
+    "@uniswap/v3-sdk": "^3.27.0",
+    "jest": "^30.2.0",
+    "semantic-release": "^25.0.2",
+    "ts-jest": "^29.4.6",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}