easctl 0.1.0

package/src/client.ts

@@ -0,0 +1,53 @@
+import { ethers } from 'ethers';
+import { EAS, SchemaRegistry } from '@ethereum-attestation-service/eas-sdk';
+import { getChainConfig, type ChainConfig } from './chains.js';
+import { getStoredPrivateKey } from './config.js';
+
+export interface EASClient {
+  eas: EAS;
+  schemaRegistry: SchemaRegistry;
+  signer: ethers.Wallet;
+  provider: ethers.JsonRpcProvider;
+  chainConfig: ChainConfig;
+  address: string;
+}
+
+export function getPrivateKey(): string {
+  const key = process.env.EAS_PRIVATE_KEY || getStoredPrivateKey();
+  if (!key) {
+    throw new Error(
+      'No private key found. Set one with: eas set-key <key>  (or set EAS_PRIVATE_KEY env var)'
+    );
+  }
+  return key.startsWith('0x') ? key : `0x${key}`;
+}
+
+export function createEASClient(chainName: string, rpcUrl?: string): EASClient {
+  const chainConfig = getChainConfig(chainName);
+  const privateKey = getPrivateKey();
+
+  const provider = new ethers.JsonRpcProvider(rpcUrl || chainConfig.defaultRpc);
+  const signer = new ethers.Wallet(privateKey, provider);
+
+  const eas = new EAS(chainConfig.eas, { signer });
+  const schemaRegistry = new SchemaRegistry(chainConfig.schemaRegistry, { signer });
+
+  return {
+    eas,
+    schemaRegistry,
+    signer,
+    provider,
+    chainConfig,
+    address: signer.address,
+  };
+}
+
+export function createReadOnlyEASClient(chainName: string, rpcUrl?: string) {
+  const chainConfig = getChainConfig(chainName);
+  const provider = new ethers.JsonRpcProvider(rpcUrl || chainConfig.defaultRpc);
+
+  const eas = new EAS(chainConfig.eas, { signer: provider });
+  const schemaRegistry = new SchemaRegistry(chainConfig.schemaRegistry, { signer: provider });
+
+  return { eas, schemaRegistry, provider, chainConfig };
+}

package/src/commands/attest.ts

@@ -0,0 +1,73 @@
+import { Command } from 'commander';
+import { SchemaEncoder, NO_EXPIRATION, ZERO_BYTES32 } from '@ethereum-attestation-service/eas-sdk';
+import { createEASClient } from '../client.js';
+import { output, handleError } from '../output.js';
+import { resolveInput } from '../stdin.js';
+import { validateAddress, validateBytes32 } from '../validation.js';
+
+export const attestCommand = new Command('attest')
+  .description('Create an on-chain attestation')
+  .requiredOption('-s, --schema <uid>', 'Schema UID to attest with')
+  .requiredOption('-d, --data <json>', 'Attestation data as JSON array: [{"name":"field","type":"uint256","value":"123"}]')
+  .option('-r, --recipient <address>', 'Recipient address', '0x0000000000000000000000000000000000000000')
+  .option('--ref-uid <uid>', 'Referenced attestation UID', ZERO_BYTES32)
+  .option('--expiration <timestamp>', 'Expiration timestamp (0 for none)', '0')
+  .option('--revocable', 'Whether the attestation is revocable', true)
+  .option('--no-revocable', 'Make the attestation non-revocable')
+  .option('--value <wei>', 'ETH value to send (in wei)', '0')
+  .option('-c, --chain <name>', 'Chain name', 'ethereum')
+  .option('--rpc-url <url>', 'Custom RPC URL')
+  .option('--dry-run', 'Estimate gas without sending the transaction')
+  .action(async (opts) => {
+    try {
+      validateBytes32(opts.schema, 'schema UID');
+      if (opts.recipient !== '0x0000000000000000000000000000000000000000') {
+        validateAddress(opts.recipient, 'recipient');
+      }
+
+      const client = createEASClient(opts.chain, opts.rpcUrl);
+
+      const rawData = await resolveInput(opts.data);
+      let dataItems;
+      try {
+        dataItems = JSON.parse(rawData);
+      } catch (e) {
+        throw new Error(`Invalid JSON in --data: ${e instanceof Error ? e.message : e}`);
+      }
+      const schemaString = dataItems.map((item: any) => `${item.type} ${item.name}`).join(', ');
+      const encoder = new SchemaEncoder(schemaString);
+      const encodedData = encoder.encodeData(dataItems);
+
+      const tx = await client.eas.attest({
+        schema: opts.schema,
+        data: {
+          recipient: opts.recipient,
+          expirationTime: BigInt(opts.expiration) === 0n ? NO_EXPIRATION : BigInt(opts.expiration),
+          revocable: opts.revocable,
+          refUID: opts.refUid,
+          data: encodedData,
+          value: BigInt(opts.value),
+        },
+      });
+
+      if (opts.dryRun) {
+        const gasEstimate = await tx.estimateGas();
+        output({ success: true, data: { dryRun: true, estimatedGas: gasEstimate.toString(), chain: opts.chain } });
+      } else {
+        const uid = await tx.wait();
+        output({
+          success: true,
+          data: {
+            uid,
+            txHash: tx.receipt!.hash,
+            attester: client.address,
+            recipient: opts.recipient,
+            schema: opts.schema,
+            chain: opts.chain,
+          },
+        });
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });

package/src/commands/clear-key.ts

@@ -0,0 +1,15 @@
+import { Command } from 'commander';
+import { clearStoredPrivateKey, getStoredPrivateKey } from '../config.js';
+import { output } from '../output.js';
+
+export const clearKeyCommand = new Command('clear-key')
+  .description('Remove the stored private key from ~/.eas-cli')
+  .action(() => {
+    if (!getStoredPrivateKey()) {
+      output({ success: true, data: { cleared: false, message: 'No private key is currently stored' } });
+      return;
+    }
+
+    clearStoredPrivateKey();
+    output({ success: true, data: { cleared: true } });
+  });

package/src/commands/get-attestation.ts

@@ -0,0 +1,58 @@
+import { Command } from 'commander';
+import { SchemaEncoder } from '@ethereum-attestation-service/eas-sdk';
+import { createReadOnlyEASClient } from '../client.js';
+import { output, handleError } from '../output.js';
+import { validateBytes32 } from '../validation.js';
+
+export const getAttestationCommand = new Command('get-attestation')
+  .description('Get an attestation by UID')
+  .requiredOption('-u, --uid <uid>', 'Attestation UID')
+  .option('--decode [schema]', 'Decode data using schema string, or pass without value to auto-fetch from chain')
+  .option('-c, --chain <name>', 'Chain name', 'ethereum')
+  .option('--rpc-url <url>', 'Custom RPC URL')
+  .action(async (opts) => {
+    try {
+      validateBytes32(opts.uid, 'attestation UID');
+
+      const client = createReadOnlyEASClient(opts.chain, opts.rpcUrl);
+      const attestation = await client.eas.getAttestation(opts.uid);
+
+      const result: Record<string, unknown> = {
+        uid: attestation.uid,
+        schema: attestation.schema,
+        attester: attestation.attester,
+        recipient: attestation.recipient,
+        refUID: attestation.refUID,
+        revocable: attestation.revocable,
+        revocationTime: Number(attestation.revocationTime),
+        expirationTime: Number(attestation.expirationTime),
+        time: Number(attestation.time),
+        data: attestation.data,
+      };
+
+      if (opts.decode) {
+        try {
+          let schemaString: string;
+          if (typeof opts.decode === 'string') {
+            schemaString = opts.decode;
+          } else {
+            const schemaRecord = await client.schemaRegistry.getSchema({ uid: attestation.schema });
+            schemaString = schemaRecord.schema;
+          }
+          const encoder = new SchemaEncoder(schemaString);
+          const decoded = encoder.decodeData(attestation.data);
+          result.decodedData = decoded.map((item) => ({
+            name: item.name,
+            type: item.type,
+            value: typeof item.value.value === 'bigint' ? item.value.value.toString() : item.value.value,
+          }));
+        } catch (decodeErr) {
+          result.decodeError = decodeErr instanceof Error ? decodeErr.message : String(decodeErr);
+        }
+      }
+
+      output({ success: true, data: result });
+    } catch (err) {
+      handleError(err);
+    }
+  });

package/src/commands/multi-attest.ts

@@ -0,0 +1,75 @@
+import { Command } from 'commander';
+import { SchemaEncoder, NO_EXPIRATION, ZERO_BYTES32 } from '@ethereum-attestation-service/eas-sdk';
+import { createEASClient } from '../client.js';
+import { output, handleError } from '../output.js';
+import { resolveInput } from '../stdin.js';
+
+interface AttestationInput {
+  schema: string;
+  recipient?: string;
+  refUID?: string;
+  expirationTime?: string;
+  revocable?: boolean;
+  value?: string;
+  data: Array<{ name: string; type: string; value: unknown }>;
+}
+
+export const multiAttestCommand = new Command('multi-attest')
+  .description('Create multiple on-chain attestations in a single transaction')
+  .requiredOption('-i, --input <json>', 'JSON array of attestation objects')
+  .option('-c, --chain <name>', 'Chain name', 'ethereum')
+  .option('--rpc-url <url>', 'Custom RPC URL')
+  .option('--dry-run', 'Estimate gas without sending the transaction')
+  .action(async (opts) => {
+    try {
+      const client = createEASClient(opts.chain, opts.rpcUrl);
+      const rawInput = await resolveInput(opts.input);
+      let inputs: AttestationInput[];
+      try {
+        inputs = JSON.parse(rawInput);
+      } catch (e) {
+        throw new Error(`Invalid JSON in --input: ${e instanceof Error ? e.message : e}`);
+      }
+
+      const grouped = new Map<string, { schema: string; data: any[] }>();
+
+      for (const input of inputs) {
+        const schemaString = input.data.map((item) => `${item.type} ${item.name}`).join(', ');
+        const encoder = new SchemaEncoder(schemaString);
+        const encodedData = encoder.encodeData(input.data as any);
+
+        if (!grouped.has(input.schema)) {
+          grouped.set(input.schema, { schema: input.schema, data: [] });
+        }
+
+        grouped.get(input.schema)!.data.push({
+          recipient: input.recipient || '0x0000000000000000000000000000000000000000',
+          expirationTime: input.expirationTime ? BigInt(input.expirationTime) : NO_EXPIRATION,
+          revocable: input.revocable ?? true,
+          refUID: input.refUID || ZERO_BYTES32,
+          data: encodedData,
+          value: input.value ? BigInt(input.value) : 0n,
+        });
+      }
+
+      const tx = await client.eas.multiAttest(Array.from(grouped.values()));
+
+      if (opts.dryRun) {
+        const gasEstimate = await tx.estimateGas();
+        output({ success: true, data: { dryRun: true, estimatedGas: gasEstimate.toString(), chain: opts.chain } });
+      } else {
+        const uids = await tx.wait();
+        output({
+          success: true,
+          data: {
+            uids,
+            count: uids.length,
+            txHash: tx.receipt!.hash,
+            chain: opts.chain,
+          },
+        });
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });

package/src/commands/multi-revoke.ts

@@ -0,0 +1,60 @@
+import { Command } from 'commander';
+import { createEASClient } from '../client.js';
+import { output, handleError } from '../output.js';
+import { resolveInput } from '../stdin.js';
+
+interface RevocationInput {
+  schema: string;
+  uid: string;
+  value?: string;
+}
+
+export const multiRevokeCommand = new Command('multi-revoke')
+  .description('Revoke multiple attestations in a single transaction')
+  .requiredOption('-i, --input <json>', 'JSON array of revocation objects: [{"schema":"0x...","uid":"0x..."}]')
+  .option('-c, --chain <name>', 'Chain name', 'ethereum')
+  .option('--rpc-url <url>', 'Custom RPC URL')
+  .option('--dry-run', 'Estimate gas without sending the transaction')
+  .action(async (opts) => {
+    try {
+      const client = createEASClient(opts.chain, opts.rpcUrl);
+      const rawInput = await resolveInput(opts.input);
+      let inputs: RevocationInput[];
+      try {
+        inputs = JSON.parse(rawInput);
+      } catch (e) {
+        throw new Error(`Invalid JSON in --input: ${e instanceof Error ? e.message : e}`);
+      }
+
+      const grouped = new Map<string, { schema: string; data: any[] }>();
+
+      for (const input of inputs) {
+        if (!grouped.has(input.schema)) {
+          grouped.set(input.schema, { schema: input.schema, data: [] });
+        }
+        grouped.get(input.schema)!.data.push({
+          uid: input.uid,
+          value: input.value ? BigInt(input.value) : 0n,
+        });
+      }
+
+      const tx = await client.eas.multiRevoke(Array.from(grouped.values()));
+
+      if (opts.dryRun) {
+        const gasEstimate = await tx.estimateGas();
+        output({ success: true, data: { dryRun: true, estimatedGas: gasEstimate.toString(), chain: opts.chain } });
+      } else {
+        await tx.wait();
+        output({
+          success: true,
+          data: {
+            revoked: inputs.length,
+            txHash: tx.receipt!.hash,
+            chain: opts.chain,
+          },
+        });
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });

package/src/commands/multi-timestamp.ts

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import { createEASClient } from '../client.js';
+import { output, handleError } from '../output.js';
+import { resolveInput } from '../stdin.js';
+
+export const multiTimestampCommand = new Command('multi-timestamp')
+  .description('Timestamp multiple data items in a single transaction')
+  .requiredOption('-d, --data <json>', 'JSON array of bytes32 hex strings to timestamp')
+  .option('-c, --chain <name>', 'Chain name', 'ethereum')
+  .option('--rpc-url <url>', 'Custom RPC URL')
+  .option('--dry-run', 'Estimate gas without sending the transaction')
+  .action(async (opts) => {
+    try {
+      const client = createEASClient(opts.chain, opts.rpcUrl);
+      const rawData = await resolveInput(opts.data);
+      let items: string[];
+      try {
+        items = JSON.parse(rawData);
+      } catch (e) {
+        throw new Error(`Invalid JSON in --data: ${e instanceof Error ? e.message : e}`);
+      }
+
+      const tx = await client.eas.multiTimestamp(items);
+
+      if (opts.dryRun) {
+        const gasEstimate = await tx.estimateGas();
+        output({ success: true, data: { dryRun: true, estimatedGas: gasEstimate.toString(), chain: opts.chain } });
+      } else {
+        const timestamps = await tx.wait();
+        output({
+          success: true,
+          data: {
+            timestamps: timestamps.map((t) => t.toString()),
+            count: timestamps.length,
+            txHash: tx.receipt!.hash,
+            chain: opts.chain,
+          },
+        });
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });

package/src/commands/offchain-attest.ts

@@ -0,0 +1,78 @@
+import { Command } from 'commander';
+import {
+  SchemaEncoder,
+  NO_EXPIRATION,
+  ZERO_BYTES32,
+  createOffchainURL,
+} from '@ethereum-attestation-service/eas-sdk';
+import { createEASClient } from '../client.js';
+import { output, handleError } from '../output.js';
+import { resolveInput } from '../stdin.js';
+import { validateAddress, validateBytes32 } from '../validation.js';
+import { EASSCAN_URLS } from '../graphql.js';
+
+export const offchainAttestCommand = new Command('offchain-attest')
+  .description('Create an off-chain attestation (signed but not submitted on-chain)')
+  .requiredOption('-s, --schema <uid>', 'Schema UID')
+  .requiredOption('-d, --data <json>', 'Attestation data as JSON array: [{"name":"field","type":"uint256","value":"123"}]')
+  .option('-r, --recipient <address>', 'Recipient address', '0x0000000000000000000000000000000000000000')
+  .option('--ref-uid <uid>', 'Referenced attestation UID', ZERO_BYTES32)
+  .option('--expiration <timestamp>', 'Expiration timestamp (0 for none)', '0')
+  .option('--revocable', 'Whether the attestation is revocable', true)
+  .option('--no-revocable', 'Make the attestation non-revocable')
+  .option('-c, --chain <name>', 'Chain name', 'ethereum')
+  .option('--rpc-url <url>', 'Custom RPC URL')
+  .action(async (opts) => {
+    try {
+      validateBytes32(opts.schema, 'schema UID');
+      if (opts.recipient !== '0x0000000000000000000000000000000000000000') {
+        validateAddress(opts.recipient, 'recipient');
+      }
+
+      const client = createEASClient(opts.chain, opts.rpcUrl);
+
+      const rawData = await resolveInput(opts.data);
+      let dataItems;
+      try {
+        dataItems = JSON.parse(rawData);
+      } catch (e) {
+        throw new Error(`Invalid JSON in --data: ${e instanceof Error ? e.message : e}`);
+      }
+      const schemaString = dataItems.map((item: any) => `${item.type} ${item.name}`).join(', ');
+      const encoder = new SchemaEncoder(schemaString);
+      const encodedData = encoder.encodeData(dataItems);
+
+      const offchain = await client.eas.getOffchain();
+
+      const attestation = await offchain.signOffchainAttestation(
+        {
+          schema: opts.schema,
+          recipient: opts.recipient,
+          expirationTime: BigInt(opts.expiration) === 0n ? NO_EXPIRATION : BigInt(opts.expiration),
+          revocable: opts.revocable,
+          refUID: opts.refUid,
+          data: encodedData,
+          time: BigInt(Math.floor(Date.now() / 1000)),
+        },
+        client.signer
+      );
+
+      const pkg = { sig: attestation, signer: client.address };
+      const urlPath = createOffchainURL(pkg);
+      const host = EASSCAN_URLS[opts.chain] || EASSCAN_URLS['ethereum'];
+      const offchainUrl = `${host}${urlPath}`;
+
+      output({
+        success: true,
+        data: {
+          uid: attestation.uid,
+          offchainUrl,
+          attester: client.address,
+          chain: opts.chain,
+          attestation: attestation as unknown as Record<string, unknown>,
+        },
+      });
+    } catch (err) {
+      handleError(err);
+    }
+  });

package/src/commands/query-attestation.ts

@@ -0,0 +1,31 @@
+import { Command } from 'commander';
+import { graphqlQuery, QUERIES } from '../graphql.js';
+import { output, handleError } from '../output.js';
+import { validateBytes32 } from '../validation.js';
+
+export const queryAttestationCommand = new Command('query-attestation')
+  .description('Query an attestation from the EAS GraphQL API')
+  .requiredOption('-u, --uid <uid>', 'Attestation UID')
+  .option('-c, --chain <name>', 'Chain name', 'ethereum')
+  .action(async (opts) => {
+    try {
+      validateBytes32(opts.uid, 'attestation UID');
+
+      const data = await graphqlQuery(opts.chain, QUERIES.getAttestation, { id: opts.uid });
+
+      if (!data.attestation) {
+        throw new Error(`Attestation ${opts.uid} not found on ${opts.chain}`);
+      }
+
+      const att = data.attestation;
+      if (att.decodedDataJson) {
+        try {
+          att.decodedData = JSON.parse(att.decodedDataJson);
+        } catch { /* keep raw */ }
+      }
+
+      output({ success: true, data: att });
+    } catch (err) {
+      handleError(err);
+    }
+  });

package/src/commands/query-attestations.ts

@@ -0,0 +1,57 @@
+import { Command } from 'commander';
+import { graphqlQuery, QUERIES } from '../graphql.js';
+import { output, handleError } from '../output.js';
+import { validateAddress, validateBytes32 } from '../validation.js';
+
+export const queryAttestationsCommand = new Command('query-attestations')
+  .description('Query attestations by schema or attester from the EAS GraphQL API')
+  .option('-s, --schema <uid>', 'Filter by schema UID')
+  .option('-a, --attester <address>', 'Filter by attester address')
+  .option('-n, --limit <number>', 'Max results to return', '10')
+  .option('--skip <number>', 'Number of results to skip (for pagination)', '0')
+  .option('-c, --chain <name>', 'Chain name', 'ethereum')
+  .action(async (opts) => {
+    try {
+      if (!opts.schema && !opts.attester) {
+        throw new Error('Provide at least one filter: --schema or --attester');
+      }
+      if (opts.schema) validateBytes32(opts.schema, 'schema UID');
+      if (opts.attester) validateAddress(opts.attester, 'attester');
+
+      const take = parseInt(opts.limit, 10);
+      const skip = parseInt(opts.skip, 10);
+      if (isNaN(take) || take < 1) throw new Error('--limit must be a positive integer');
+      if (isNaN(skip) || skip < 0) throw new Error('--skip must be a non-negative integer');
+      let data;
+
+      if (opts.schema) {
+        data = await graphqlQuery(opts.chain, QUERIES.getAttestationsBySchema, {
+          schemaId: opts.schema,
+          take,
+          skip,
+        });
+      } else {
+        data = await graphqlQuery(opts.chain, QUERIES.getAttestationsByAttester, {
+          attester: opts.attester,
+          take,
+          skip,
+        });
+      }
+
+      const attestations = data.attestations || [];
+      for (const att of attestations) {
+        if (att.decodedDataJson) {
+          try {
+            att.decodedData = JSON.parse(att.decodedDataJson);
+          } catch { /* keep raw */ }
+        }
+      }
+
+      output({
+        success: true,
+        data: { count: attestations.length, attestations },
+      });
+    } catch (err) {
+      handleError(err);
+    }
+  });

package/src/commands/query-schema.ts

@@ -0,0 +1,24 @@
+import { Command } from 'commander';
+import { graphqlQuery, QUERIES } from '../graphql.js';
+import { output, handleError } from '../output.js';
+import { validateBytes32 } from '../validation.js';
+
+export const querySchemaCommand = new Command('query-schema')
+  .description('Query a schema from the EAS GraphQL API')
+  .requiredOption('-u, --uid <uid>', 'Schema UID')
+  .option('-c, --chain <name>', 'Chain name', 'ethereum')
+  .action(async (opts) => {
+    try {
+      validateBytes32(opts.uid, 'schema UID');
+
+      const data = await graphqlQuery(opts.chain, QUERIES.getSchema, { id: opts.uid });
+
+      if (!data.schema) {
+        throw new Error(`Schema ${opts.uid} not found on ${opts.chain}`);
+      }
+
+      output({ success: true, data: data.schema });
+    } catch (err) {
+      handleError(err);
+    }
+  });

package/src/commands/query-schemas.ts

@@ -0,0 +1,35 @@
+import { Command } from 'commander';
+import { graphqlQuery, QUERIES } from '../graphql.js';
+import { output, handleError } from '../output.js';
+import { validateAddress } from '../validation.js';
+
+export const querySchemasCommand = new Command('query-schemas')
+  .description('Query schemas by creator from the EAS GraphQL API')
+  .requiredOption('-a, --creator <address>', 'Creator address')
+  .option('-n, --limit <number>', 'Max results to return', '10')
+  .option('--skip <number>', 'Number of results to skip (for pagination)', '0')
+  .option('-c, --chain <name>', 'Chain name', 'ethereum')
+  .action(async (opts) => {
+    try {
+      validateAddress(opts.creator, 'creator');
+
+      const take = parseInt(opts.limit, 10);
+      const skip = parseInt(opts.skip, 10);
+      if (isNaN(take) || take < 1) throw new Error('--limit must be a positive integer');
+      if (isNaN(skip) || skip < 0) throw new Error('--skip must be a non-negative integer');
+      const data = await graphqlQuery(opts.chain, QUERIES.getSchemata, {
+        creator: opts.creator,
+        take,
+        skip,
+      });
+
+      const schemas = data.schemata || [];
+
+      output({
+        success: true,
+        data: { count: schemas.length, schemas },
+      });
+    } catch (err) {
+      handleError(err);
+    }
+  });

package/src/commands/revoke.ts

@@ -0,0 +1,48 @@
+import { Command } from 'commander';
+import { createEASClient } from '../client.js';
+import { output, handleError } from '../output.js';
+import { validateBytes32 } from '../validation.js';
+
+export const revokeCommand = new Command('revoke')
+  .description('Revoke an on-chain attestation')
+  .requiredOption('-s, --schema <uid>', 'Schema UID of the attestation')
+  .requiredOption('-u, --uid <uid>', 'Attestation UID to revoke')
+  .option('--value <wei>', 'ETH value to send (in wei)', '0')
+  .option('-c, --chain <name>', 'Chain name', 'ethereum')
+  .option('--rpc-url <url>', 'Custom RPC URL')
+  .option('--dry-run', 'Estimate gas without sending the transaction')
+  .action(async (opts) => {
+    try {
+      validateBytes32(opts.schema, 'schema UID');
+      validateBytes32(opts.uid, 'attestation UID');
+
+      const client = createEASClient(opts.chain, opts.rpcUrl);
+
+      const tx = await client.eas.revoke({
+        schema: opts.schema,
+        data: {
+          uid: opts.uid,
+          value: BigInt(opts.value),
+        },
+      });
+
+      if (opts.dryRun) {
+        const gasEstimate = await tx.estimateGas();
+        output({ success: true, data: { dryRun: true, estimatedGas: gasEstimate.toString(), chain: opts.chain } });
+      } else {
+        await tx.wait();
+        output({
+          success: true,
+          data: {
+            revoked: true,
+            uid: opts.uid,
+            txHash: tx.receipt!.hash,
+            schema: opts.schema,
+            chain: opts.chain,
+          },
+        });
+      }
+    } catch (err) {
+      handleError(err);
+    }
+  });