@reclaimprotocol/attestor-core 5.0.1-beta.2 → 5.0.1-beta.4

package/lib/browser/avs/client/create-claim-on-avs.d.ts

@@ -0,0 +1,12 @@
+import type { TaskCompletedEvent } from '#src/avs/contracts/ReclaimServiceManager.ts';
+import type { CreateClaimOnAvsOpts } from '#src/avs/types/index.ts';
+import type { ProviderClaimData } from '#src/proto/api.ts';
+import type { ProviderName } from '#src/types/index.ts';
+/**
+ * Creates a Reclaim claim on the AVS chain.
+ */
+export declare function createClaimOnAvs<N extends ProviderName>({ onStep, createClaimOnAttestor, chainId, payer, ...opts }: CreateClaimOnAvsOpts<N>): Promise<{
+    claimData: ProviderClaimData;
+    object: TaskCompletedEvent.OutputObject;
+    txHash: string;
+}>;

package/lib/browser/avs/client/create-claim-on-avs.js

@@ -0,0 +1,168 @@
+import { EventLog, hexlify, Wallet } from "ethers";
+import { CHAIN_CONFIGS, SELECTED_CHAIN_ID } from "../../../avs/config.js";
+import { initialiseContracts } from "../../../avs/utils/contracts.js";
+import { createNewClaimRequestOnChain, signClaimRequest } from "../../../avs/utils/tasks.js";
+import { createClaimOnAttestor as _createClaimOnAttestor, getAttestorClientFromPool } from "../../../client/index.js";
+import { AttestorError, canonicalStringify, getIdentifierFromClaimInfo, logger as LOGGER, unixTimestampSeconds } from "../../../utils/index.js";
+const EMPTY_CLAIM_USER_ID = hexlify(new Uint8Array(32));
+async function createClaimOnAvs({
+  onStep,
+  createClaimOnAttestor = _createClaimOnAttestor,
+  chainId = SELECTED_CHAIN_ID,
+  payer,
+  ...opts
+}) {
+  const {
+    logger = LOGGER,
+    ownerPrivateKey,
+    name,
+    params,
+    context
+  } = opts;
+  const { contract, wallet, provider } = initialiseContracts(
+    CHAIN_CONFIGS[chainId],
+    ownerPrivateKey
+  );
+  logger.info(
+    { owner: wallet.address, contract: await contract.getAddress() },
+    "creating claim"
+  );
+  const arg = await requestClaimCreation();
+  logger.info(
+    {
+      index: arg.taskIndex,
+      operators: arg.task.operators.length
+    },
+    "task created, collecting claim signatures..."
+  );
+  onStep?.({ type: "taskCreated", data: arg });
+  const responses = [];
+  const timestampS = +arg.task.createdAt.toString();
+  for (const op of arg.task.operators) {
+    const res = await createClaimOnAttestor({
+      ...opts,
+      client: { url: op.url },
+      timestampS,
+      onStep: (step) => onStep?.({
+        type: "attestorStep",
+        data: {
+          operatorAddress: op.addr,
+          step
+        }
+      }),
+      logger: logger.child({ operator: op.addr })
+    });
+    const signature = res.signatures?.claimSignature;
+    if (!signature) {
+      throw new Error("INTERNAL: Claim signature not generated");
+    }
+    const diff = getClaimRequestDifference(res.request?.data, res.claim);
+    if (diff) {
+      throw new AttestorError(
+        "ERROR_INVALID_CLAIM",
+        `Claim request does not match the claim res data: ${diff}`,
+        {
+          diff,
+          request: res.request?.data?.[diff],
+          claim: res.claim?.[diff]
+        }
+      );
+    }
+    responses.push(res);
+    logger.info({ operator: op.addr }, "signature generated");
+    onStep?.({
+      type: "attestorDone",
+      data: {
+        task: arg,
+        responsesDone: responses
+      }
+    });
+  }
+  const rslt = await completeTask();
+  logger.info(
+    { tx: rslt.txHash, task: arg.taskIndex },
+    "claim submitted & validated"
+  );
+  return { ...rslt, claimData: responses[0].claim };
+  async function requestClaimCreation() {
+    const request = {
+      provider: name,
+      // blank for now -- till we figure out the right
+      // algorithm for this
+      claimUserId: EMPTY_CLAIM_USER_ID,
+      claimHash: getIdentifierFromClaimInfo({
+        provider: name,
+        parameters: canonicalStringify(params),
+        context: context ? canonicalStringify(context) : ""
+      }),
+      owner: wallet.address,
+      requestedAt: unixTimestampSeconds()
+    };
+    if (!payer) {
+      const payerWallet = new Wallet(ownerPrivateKey, provider);
+      const { task } = await createNewClaimRequestOnChain({
+        request,
+        payer: payerWallet,
+        owner: payerWallet,
+        chainId
+      });
+      return task;
+    }
+    const requestSignature = await signClaimRequest(
+      request,
+      wallet,
+      chainId
+    );
+    const client = getAttestorClientFromPool(payer.attestor);
+    await client.waitForInit();
+    const rslt2 = await client.rpc("createClaimOnChain", {
+      chainId: +chainId,
+      jsonCreateClaimRequest: JSON.stringify(request),
+      requestSignature
+    });
+    return JSON.parse(rslt2.jsonTask);
+  }
+  async function completeTask() {
+    const data = {
+      task: arg.task,
+      signatures: responses.map((res) => hexlify(res.signatures?.claimSignature))
+    };
+    if (!payer) {
+      const tx = await contract.taskCompleted(data, arg.taskIndex);
+      const rslt3 = await tx.wait();
+      const logs = rslt3?.logs ?? [];
+      const eventLogs = logs.filter((log) => log instanceof EventLog);
+      const ev = eventLogs[0];
+      return {
+        object: ev?.args,
+        txHash: rslt3.hash
+      };
+    }
+    const client = getAttestorClientFromPool(payer.attestor);
+    await client.waitForInit();
+    const rslt2 = await client.rpc("completeClaimOnChain", {
+      chainId: +chainId,
+      taskIndex: Number(arg.taskIndex),
+      completedTaskJson: JSON.stringify(data)
+    });
+    const object = JSON.parse(rslt2.taskCompletedObjectJson);
+    return { object, txHash: rslt2.txHash };
+  }
+}
+function getClaimRequestDifference(a, b) {
+  if (a.provider !== b.provider) {
+    return "provider";
+  }
+  if (a.context !== b.context) {
+    return "context";
+  }
+  if (a.parameters !== b.parameters) {
+    return "parameters";
+  }
+  if (a.timestampS !== b.timestampS) {
+    return "timestampS";
+  }
+}
+export {
+  createClaimOnAvs
+};

package/lib/browser/avs/config.d.ts

@@ -0,0 +1,7 @@
+import type { ChainConfig } from '#src/avs/types/index.ts';
+export declare const CHAIN_CONFIGS: {
+    [key: string]: ChainConfig;
+};
+export declare const PRIVATE_KEY: string;
+export declare const SELECTED_CHAIN_ID: string | undefined;
+export declare const RECLAIM_PUBLIC_URL: string;

package/lib/browser/avs/config.js

@@ -0,0 +1,26 @@
+import { getEnvVariable } from "../../utils/env.js";
+const CHAIN_CONFIGS = {
+  "31337": {
+    rpcUrl: "http://localhost:8545",
+    contractAddress: "0x84eA74d481Ee0A5332c457a4d796187F6Ba67fEB",
+    delegationManagerAddress: "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9",
+    stakeRegistryAddress: "0x9E545E3C0baAB3E08CdfD552C960A1050f373042",
+    avsDirectoryAddress: "0x5FC8d32690cc91D4c39d9d3abcBD16989F875707"
+  },
+  "17000": {
+    rpcUrl: getEnvVariable("RPC_URL") || "https://rpc.holesky.ethpandaops.io",
+    contractAddress: "0x0861afc305999bfD3028dB66145395BdD7299366",
+    delegationManagerAddress: "0xA44151489861Fe9e3055d95adC98FbD462B948e7",
+    stakeRegistryAddress: "0xDa11C9Da04Ab02C4AF9374B27A5E727944D3E1dD",
+    avsDirectoryAddress: "0x055733000064333CaDDbC92763c58BF0192fFeBf"
+  }
+};
+const PRIVATE_KEY = getEnvVariable("PRIVATE_KEY");
+const SELECTED_CHAIN_ID = getEnvVariable("CHAIN_ID");
+const RECLAIM_PUBLIC_URL = getEnvVariable("RECLAIM_PUBLIC_URL");
+export {
+  CHAIN_CONFIGS,
+  PRIVATE_KEY,
+  RECLAIM_PUBLIC_URL,
+  SELECTED_CHAIN_ID
+};