@reclaimprotocol/attestor-core 5.0.1-beta.1 → 5.0.1-beta.3

package/lib/avs/contracts/factories/index.d.ts

@@ -0,0 +1 @@
+export { ReclaimServiceManager__factory } from "./ReclaimServiceManager__factory.ts";

package/lib/avs/contracts/factories/index.js

@@ -0,0 +1,4 @@
+import { ReclaimServiceManager__factory } from "./ReclaimServiceManager__factory.js";
+export {
+  ReclaimServiceManager__factory
+};

package/lib/avs/contracts/index.d.ts

@@ -0,0 +1,3 @@
+export type { ReclaimServiceManager } from "./ReclaimServiceManager.ts";
+export * as factories from "./factories/index.ts";
+export { ReclaimServiceManager__factory } from "./factories/ReclaimServiceManager__factory.ts";

package/lib/avs/contracts/index.js

@@ -0,0 +1,6 @@
+import * as factories from "./factories/index.js";
+import { ReclaimServiceManager__factory } from "./factories/ReclaimServiceManager__factory.js";
+export {
+  ReclaimServiceManager__factory,
+  factories
+};

package/lib/avs/types/index.d.ts

@@ -0,0 +1,55 @@
+import type { NewTaskCreatedEvent } from '#src/avs/contracts/ReclaimServiceManager.ts';
+import type { createClaimOnAttestor } from '#src/client/index.ts';
+import type { ClaimTunnelResponse } from '#src/proto/api.ts';
+import type { CreateClaimOnAttestorOpts, ProofGenerationStep, ProviderName } from '#src/types/index.ts';
+export type ChainConfig = {
+    rpcUrl: string;
+    /**
+     * Reclaim AVS contract address
+     */
+    contractAddress: string;
+    delegationManagerAddress: string;
+    stakeRegistryAddress: string;
+    avsDirectoryAddress: string;
+};
+export type CreateClaimOnAvsStep = {
+    type: 'taskCreated';
+    data: NewTaskCreatedEvent.OutputObject;
+} | {
+    type: 'attestorStep';
+    data: {
+        operatorAddress: string;
+        step: ProofGenerationStep;
+    };
+} | {
+    type: 'attestorDone';
+    data: {
+        task: NewTaskCreatedEvent.OutputObject;
+        /**
+         * Index of the operator in the task
+         * that has finished the proof generation
+         */
+        responsesDone: ClaimTunnelResponse[];
+    };
+};
+export type CreateClaimOnAvsOpts<N extends ProviderName> = (Omit<CreateClaimOnAttestorOpts<N>, 'onStep' | 'client'>) & {
+    /**
+     * Chain ID to use for the claim
+     * @default -- env variable CHAIN_ID
+     */
+    chainId?: string;
+    /**
+     * Who will pay for the claim creation, including gas
+     * costs. Note: the attestor can choose to reject the
+     * claim if 'attestor' is chosen.
+     * @default undefined (owner of the claim)
+     */
+    payer?: {
+        attestor: string;
+    };
+    onStep?(step: CreateClaimOnAvsStep): void;
+    /**
+     * Override the default createClaimOnAttestor function
+     */
+    createClaimOnAttestor?: typeof createClaimOnAttestor;
+};

package/lib/avs/utils/contracts.d.ts

@@ -0,0 +1,21 @@
+import { Contract, JsonRpcProvider, Wallet } from 'ethers';
+import type { ChainConfig } from '#src/avs/types/index.ts';
+/**
+ * get the contracts for the given chain ID
+ */
+export declare function getContracts(chainId?: string): {
+    provider: JsonRpcProvider;
+    wallet: Wallet | undefined;
+    delegationManager: Contract;
+    contract: import("#src/avs/contracts/index.ts").ReclaimServiceManager;
+    registryContract: Contract;
+    avsDirectory: Contract;
+};
+export declare function initialiseContracts({ rpcUrl, stakeRegistryAddress, avsDirectoryAddress, contractAddress, delegationManagerAddress, }: ChainConfig, privateKey?: string | undefined): {
+    provider: JsonRpcProvider;
+    wallet: Wallet | undefined;
+    delegationManager: Contract;
+    contract: import("#src/avs/contracts/index.ts").ReclaimServiceManager;
+    registryContract: Contract;
+    avsDirectory: Contract;
+};

package/lib/avs/utils/contracts.js

@@ -0,0 +1,53 @@
+import { Contract, JsonRpcProvider, Wallet } from "ethers";
+import { avsDirectoryABI } from "../../avs/abis/avsDirectoryABI.js";
+import { delegationABI } from "../../avs/abis/delegationABI.js";
+import { registryABI } from "../../avs/abis/registryABI.js";
+import { CHAIN_CONFIGS, PRIVATE_KEY, SELECTED_CHAIN_ID } from "../../avs/config.js";
+import { ReclaimServiceManager__factory } from "../../avs/contracts/index.js";
+const configs = {};
+function getContracts(chainId = SELECTED_CHAIN_ID) {
+  const config = CHAIN_CONFIGS[chainId];
+  if (!config) {
+    throw new Error(`No config found for chain ID: ${chainId}`);
+  }
+  configs[chainId] ||= initialiseContracts(config);
+  return configs[chainId];
+}
+function initialiseContracts({
+  rpcUrl,
+  stakeRegistryAddress,
+  avsDirectoryAddress,
+  contractAddress,
+  delegationManagerAddress
+}, privateKey = PRIVATE_KEY) {
+  const provider = new JsonRpcProvider(rpcUrl);
+  const wallet = privateKey ? new Wallet(privateKey, provider) : void 0;
+  return {
+    provider,
+    wallet,
+    delegationManager: new Contract(
+      delegationManagerAddress,
+      delegationABI,
+      wallet || provider
+    ),
+    // eslint-disable-next-line camelcase
+    contract: ReclaimServiceManager__factory.connect(
+      contractAddress,
+      wallet || provider
+    ),
+    registryContract: new Contract(
+      stakeRegistryAddress,
+      registryABI,
+      wallet || provider
+    ),
+    avsDirectory: new Contract(
+      avsDirectoryAddress,
+      avsDirectoryABI,
+      wallet || provider
+    )
+  };
+}
+export {
+  getContracts,
+  initialiseContracts
+};

package/lib/avs/utils/register.d.ts

@@ -0,0 +1,27 @@
+import type { Wallet } from 'ethers';
+import { logger as LOGGER } from '#src/utils/index.ts';
+type RegisterOpts = {
+    logger?: typeof LOGGER;
+    /**
+     * What chain to register the operator on
+     * @default -- env variable CHAIN_ID
+     */
+    chainId?: string;
+    /**
+     * wallet of the operator.
+     * @default -- wallet specified in the contracts
+     *  fetched by the chainId
+     */
+    wallet?: Wallet;
+    /**
+     * URL of the Reclaim RPC server.
+     * @default -- env variable RECLAIM_PUBLIC_URL
+     */
+    reclaimRpcUrl?: string;
+};
+/**
+ * Registers the operator on the chain, if required.
+ * If already registered -- will just pass through
+ */
+export declare function registerOperator({ logger, chainId, wallet, reclaimRpcUrl }?: RegisterOpts): Promise<void>;
+export {};

package/lib/avs/utils/register.js

@@ -0,0 +1,74 @@
+import { hexlify, randomBytes, SigningKey } from "ethers";
+import { RECLAIM_PUBLIC_URL, SELECTED_CHAIN_ID } from "../../avs/config.js";
+import { getContracts } from "../../avs/utils/contracts.js";
+import { logger as LOGGER } from "../../utils/index.js";
+async function registerOperator({
+  logger = LOGGER,
+  chainId = SELECTED_CHAIN_ID,
+  wallet = getContracts(chainId).wallet,
+  reclaimRpcUrl = RECLAIM_PUBLIC_URL
+} = {}) {
+  const contracts = getContracts(chainId);
+  const delegationManager = contracts.delegationManager.connect(wallet);
+  const avsDirectory = contracts.avsDirectory.connect(wallet);
+  const contract = contracts.contract.connect(wallet);
+  const registryContract = contracts.registryContract.connect(wallet);
+  const addr = wallet.address;
+  try {
+    const tx1 = await delegationManager.registerAsOperator({
+      earningsReceiver: addr,
+      delegationApprover: "0x0000000000000000000000000000000000000000",
+      stakerOptOutWindowBlocks: 0
+    }, "");
+    await tx1.wait();
+    logger.info("operator registered on DM successfully");
+  } catch (err) {
+    if (!err.message.includes("operator has already registered")) {
+      throw err;
+    }
+    logger.info("Operator already registered on EL");
+  }
+  const salt = hexlify(randomBytes(32));
+  const expiry = Math.floor(Date.now() / 1e3) + 3600;
+  const operatorSignature = {
+    expiry,
+    salt,
+    signature: ""
+  };
+  const contractAddress = await contract.getAddress();
+  const digestHash = await avsDirectory.calculateOperatorAVSRegistrationDigestHash(
+    addr,
+    contractAddress,
+    salt,
+    expiry
+  );
+  const signingKey = new SigningKey(
+    wallet.privateKey
+  );
+  const signature = signingKey.sign(digestHash);
+  operatorSignature.signature = signature.serialized;
+  logger.info("operator signature generated successfully");
+  if (!await registryContract.operatorRegistered(addr)) {
+    const tx2 = await registryContract.registerOperatorWithSignature(addr, operatorSignature);
+    await tx2.wait();
+    logger.info("operator registered on AVS successfully");
+  } else {
+    logger.info("Operator already registered on AVS");
+  }
+  const existingMetadata = await contract.getMetadataForOperator(addr).catch((err) => {
+    if (err.message.includes("Operator not found")) {
+      return void 0;
+    }
+    throw err;
+  });
+  const metadata = { addr, url: reclaimRpcUrl };
+  if (existingMetadata?.addr === metadata.addr && existingMetadata?.url === metadata.url) {
+    logger.info("operator metadata already up to date");
+    return;
+  }
+  await contract.updateOperatorMetadata(metadata);
+  logger.info({ metadata }, "operator metadata updated successfully");
+}
+export {
+  registerOperator
+};

package/lib/avs/utils/tasks.d.ts

@@ -0,0 +1,22 @@
+import { type Wallet } from 'ethers';
+import type { IReclaimServiceManager, NewTaskCreatedEvent } from '#src/avs/contracts/ReclaimServiceManager.ts';
+type CreateClaimWithoutOwner = Omit<IReclaimServiceManager.ClaimRequestStruct, 'owner'>;
+type CreateNewClaimRequestOnChainOpts = {
+    request: CreateClaimWithoutOwner;
+    payer: Wallet;
+    chainId?: string;
+} & ({
+    owner: Wallet;
+} | {
+    /**
+     * Address of the owner of the claim
+     */
+    owner: string;
+    requestSignature?: string | Uint8Array;
+});
+export declare function createNewClaimRequestOnChain({ request, payer, chainId, ...rest }: CreateNewClaimRequestOnChainOpts): Promise<{
+    task: NewTaskCreatedEvent.OutputObject;
+    tx: import("ethers").ContractTransactionReceipt | null;
+}>;
+export declare function signClaimRequest(request: IReclaimServiceManager.ClaimRequestStruct, owner: Wallet, chainId?: string): Promise<Uint8Array<ArrayBufferLike>>;
+export {};

package/lib/avs/utils/tasks.js

@@ -0,0 +1,48 @@
+import { EventLog, getBytes } from "ethers";
+import { getContracts } from "../../avs/utils/contracts.js";
+async function createNewClaimRequestOnChain({
+  request,
+  payer,
+  chainId,
+  ...rest
+}) {
+  const contracts = getContracts(chainId);
+  const contract = contracts.contract.connect(payer);
+  const ownerAddress = typeof rest.owner === "string" ? rest.owner : rest.owner.address;
+  const fullRequest = {
+    ...request,
+    owner: ownerAddress
+  };
+  const signature = await getSignature();
+  const task = await contract.createNewTask(fullRequest, signature || "0x00");
+  const rslt = await task.wait();
+  const logs = rslt?.logs ?? [];
+  const eventLogs = logs.filter((log) => log instanceof EventLog);
+  const ev = eventLogs[0];
+  const arg = ev?.args;
+  return { task: arg, tx: rslt };
+  function getSignature() {
+    if (ownerAddress.toLowerCase() === payer.address.toLowerCase()) {
+      return;
+    }
+    if ("requestSignature" in rest) {
+      return rest.requestSignature;
+    }
+    if (typeof rest.owner !== "object") {
+      throw new Error(
+        "Owner wallet must be provided or requestSignature must be provided"
+      );
+    }
+    return signClaimRequest(fullRequest, rest.owner, chainId);
+  }
+}
+async function signClaimRequest(request, owner, chainId) {
+  const contract = getContracts(chainId).contract;
+  const encoded = await contract.encodeClaimRequest(request);
+  const strSig = await owner.signMessage(getBytes(encoded));
+  return getBytes(strSig);
+}
+export {
+  createNewClaimRequestOnChain,
+  signClaimRequest
+};

package/lib/browser/avs/abis/avsDirectoryABI.d.ts

@@ -0,0 +1,60 @@
+export declare const avsDirectoryABI: ({
+    type: string;
+    inputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    stateMutability: string;
+    name?: undefined;
+    outputs?: undefined;
+    anonymous?: undefined;
+} | {
+    type: string;
+    name: string;
+    inputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    outputs: {
+        name: string;
+        type: string;
+        internalType: string;
+    }[];
+    stateMutability: string;
+    anonymous?: undefined;
+} | {
+    type: string;
+    name: string;
+    inputs: ({
+        name: string;
+        type: string;
+        internalType: string;
+        components?: undefined;
+    } | {
+        name: string;
+        type: string;
+        internalType: string;
+        components: {
+            name: string;
+            type: string;
+            internalType: string;
+        }[];
+    })[];
+    outputs: never[];
+    stateMutability: string;
+    anonymous?: undefined;
+} | {
+    type: string;
+    name: string;
+    inputs: {
+        name: string;
+        type: string;
+        indexed: boolean;
+        internalType: string;
+    }[];
+    anonymous: boolean;
+    stateMutability?: undefined;
+    outputs?: undefined;
+})[];