@joclaim/attestor-core 0.2.0 → 0.2.3

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

@@ -0,0 +1,12 @@
+import type { TaskCompletedEventObject } from '../../avs/contracts/ReclaimServiceManager.js';
+import type { CreateClaimOnAvsOpts } from '../../avs/types/index.js';
+import type { ProviderClaimData } from '../../proto/api.js';
+import type { ProviderName } from '../../types/index.js';
+/**
+ * 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: TaskCompletedEventObject;
+    txHash: string;
+}>;

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

@@ -0,0 +1,138 @@
+import { ethers, 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 = ethers.utils.hexlify(new Uint8Array(32));
+/**
+ * Creates a Reclaim claim on the AVS chain.
+ */
+export async function createClaimOnAvs({ onStep, createClaimOnAttestor = _createClaimOnAttestor, chainId = SELECTED_CHAIN_ID, payer, ...opts }) {
+    const { logger = LOGGER, ownerPrivateKey, name, params, context, } = opts;
+    const { contract, wallet } = initialiseContracts(CHAIN_CONFIGS[chainId], ownerPrivateKey);
+    logger.info({ owner: wallet.address, contract: contract.address }, '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 wallet = new Wallet(ownerPrivateKey, contract.provider);
+            const { task } = await createNewClaimRequestOnChain({
+                request,
+                payer: wallet,
+                owner: wallet,
+                chainId
+            });
+            return task;
+        }
+        const requestSignature = await signClaimRequest(request, wallet, chainId);
+        const client = getAttestorClientFromPool(payer.attestor);
+        await client.waitForInit();
+        const rslt = await client.rpc('createClaimOnChain', {
+            chainId: +chainId,
+            jsonCreateClaimRequest: JSON.stringify(request),
+            requestSignature
+        });
+        return JSON.parse(rslt.jsonTask);
+    }
+    async function completeTask() {
+        const data = {
+            task: arg.task,
+            signatures: responses
+                .map(res => (ethers.utils.hexlify(res.signatures?.claimSignature))),
+        };
+        if (!payer) {
+            const tx = await contract.taskCompleted(data, arg.taskIndex);
+            const rslt = await tx.wait();
+            // check task created event was emitted
+            const ev = rslt.events?.[0];
+            return {
+                object: ev?.args,
+                txHash: rslt.transactionHash
+            };
+        }
+        const client = getAttestorClientFromPool(payer.attestor);
+        await client.waitForInit();
+        const rslt = await client.rpc('completeClaimOnChain', {
+            chainId: +chainId,
+            taskIndex: arg.taskIndex,
+            completedTaskJson: JSON.stringify(data)
+        });
+        const object = JSON.parse(rslt.taskCompletedObjectJson);
+        return { object, txHash: rslt.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';
+    }
+}

package/lib/avs/config.d.ts

@@ -0,0 +1,7 @@
+import type { ChainConfig } from '../avs/types/index.js';
+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/avs/config.js

@@ -0,0 +1,20 @@
+import { getEnvVariable } from '../utils/env.js';
+export 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'
+    }
+};
+export const PRIVATE_KEY = getEnvVariable('PRIVATE_KEY');
+export const SELECTED_CHAIN_ID = getEnvVariable('CHAIN_ID');
+export const RECLAIM_PUBLIC_URL = getEnvVariable('RECLAIM_PUBLIC_URL');