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

package/lib/utils/claims.js

@@ -1,89 +1,98 @@
-import canonicalize from "canonicalize";
-import { keccak256 } from "ethers";
+import canonicalize from 'canonicalize';
+import { keccak256 } from 'ethers';
 import { DEFAULT_METADATA } from "../config/index.js";
 import { ClaimTunnelResponse } from "../proto/api.js";
-import { SIGNATURES, strToUint8Array } from "../utils/index.js";
-function createSignDataForClaim(data) {
-  const lines = [
-    getIdentifierFromClaimInfo(data),
-    // we lowercase the owner to ensure that the
-    // ETH addresses always serialize the same way
-    data.owner.toLowerCase(),
-    data.timestampS.toString(),
-    data.epoch.toString()
-  ];
-  return lines.join("\n");
+import { SIGNATURES, strToUint8Array } from "../..";
+/**
+ * Creates the standard string to sign for a claim.
+ * This data is what the attestor will sign when it successfully
+ * verifies a claim.
+ */
+export function createSignDataForClaim(data) {
+    const lines = [
+        getIdentifierFromClaimInfo(data),
+        // we lowercase the owner to ensure that the
+        // ETH addresses always serialize the same way
+        data.owner.toLowerCase(),
+        data.timestampS.toString(),
+        data.epoch.toString(),
+    ];
+    return lines.join('\n');
 }
-async function assertValidClaimSignatures({
-  signatures,
-  ...res
-}, metadata = DEFAULT_METADATA) {
-  if (!signatures) {
-    throw new Error("No signatures provided");
-  }
-  const {
-    resultSignature,
-    claimSignature,
-    attestorAddress
-  } = signatures;
-  const { verify } = SIGNATURES[metadata.signatureType];
-  if (signatures?.resultSignature) {
-    const resBytes = ClaimTunnelResponse.encode(ClaimTunnelResponse.create(res)).finish();
-    const verified = await verify(resBytes, resultSignature, attestorAddress);
-    if (!verified) {
-      throw new Error("Invalid result signature");
+/**
+ * Verify the claim tunnel response from a attestor.
+ *
+ * If you'd only like to verify the claim signature, you can
+ * optionally only pass "claim" & "signatures.claimSignature"
+ * to this function.
+ *
+ * The successful run of this function means that the claim
+ * is valid, and the attestor that signed the claim is valid.
+ */
+export async function assertValidClaimSignatures({ signatures, ...res }, metadata = DEFAULT_METADATA) {
+    if (!signatures) {
+        throw new Error('No signatures provided');
+    }
+    const { resultSignature, claimSignature, attestorAddress } = signatures;
+    const { verify } = SIGNATURES[metadata.signatureType];
+    if (signatures?.resultSignature) {
+        const resBytes = ClaimTunnelResponse
+            .encode(ClaimTunnelResponse.create(res)).finish();
+        const verified = await verify(resBytes, resultSignature, attestorAddress);
+        if (!verified) {
+            throw new Error('Invalid result signature');
+        }
+    }
+    // claim wasn't generated -- i.e. the transcript
+    // did not contain the necessary data
+    if (!res.claim) {
+        return;
+    }
+    const signData = createSignDataForClaim(res.claim);
+    const verifiedClaim = await verify(strToUint8Array(signData), claimSignature, attestorAddress);
+    if (!verifiedClaim) {
+        throw new Error('Invalid claim signature');
     }
-  }
-  if (!res.claim) {
-    return;
-  }
-  const signData = createSignDataForClaim(res.claim);
-  const verifiedClaim = await verify(
-    strToUint8Array(signData),
-    claimSignature,
-    attestorAddress
-  );
-  if (!verifiedClaim) {
-    throw new Error("Invalid claim signature");
-  }
 }
-function getIdentifierFromClaimInfo(info) {
-  if (info.context?.length > 0) {
-    try {
-      const ctx = JSON.parse(info.context);
-      info.context = canonicalStringify(ctx);
-    } catch {
-      throw new Error("unable to parse non-empty context. Must be JSON");
+/**
+ * Generates a unique identifier for given claim info
+ * @param info
+ * @returns
+ */
+export function getIdentifierFromClaimInfo(info) {
+    //re-canonicalize context if it's not empty
+    if (info.context?.length > 0) {
+        try {
+            const ctx = JSON.parse(info.context);
+            info.context = canonicalStringify(ctx);
+        }
+        catch {
+            throw new Error('unable to parse non-empty context. Must be JSON');
+        }
     }
-  }
-  const str = `${info.provider}
-${info.parameters}
-${info.context || ""}`;
-  return keccak256(strToUint8Array(str)).toLowerCase();
+    const str = `${info.provider}\n${info.parameters}\n${info.context || ''}`;
+    //console.log('Identifier: ' + btoa(str))
+    return keccak256(strToUint8Array(str)).toLowerCase();
 }
-function canonicalStringify(params) {
-  if (!params) {
-    return "";
-  }
-  return canonicalize(params) || "";
+/**
+ * Canonically stringifies an object, so that the same object will always
+ * produce the same string despite the order of keys
+ */
+export function canonicalStringify(params) {
+    if (!params) {
+        return '';
+    }
+    // have to cast as ESM isn't correctly typing this
+    return canonicalize(params) || '';
 }
-function hashProviderParams(params) {
-  const filteredParams = {
-    url: params.url,
-    method: params.method,
-    body: params.body,
-    responseMatches: params.responseMatches,
-    responseRedactions: params.responseRedactions
-  };
-  const serializedParams = canonicalStringify(filteredParams);
-  return keccak256(
-    strToUint8Array(serializedParams)
-  ).toLowerCase();
+export function hashProviderParams(params) {
+    const filteredParams = {
+        url: params.url,
+        method: params.method,
+        body: params.body,
+        responseMatches: params.responseMatches,
+        responseRedactions: params.responseRedactions
+    };
+    const serializedParams = canonicalStringify(filteredParams);
+    return keccak256(strToUint8Array(serializedParams)).toLowerCase();
 }
-export {
-  assertValidClaimSignatures,
-  canonicalStringify,
-  createSignDataForClaim,
-  getIdentifierFromClaimInfo,
-  hashProviderParams
-};

package/lib/utils/env.js

@@ -1,19 +1,15 @@
-function detectEnvironment() {
-  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
-    return "react-native";
-  }
-  if (typeof window !== "undefined") {
-    return "browser";
-  }
-  return "node";
+export function detectEnvironment() {
+    if (typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
+        return 'react-native';
+    }
+    if (typeof window !== 'undefined') {
+        return 'browser';
+    }
+    return 'node';
 }
-function getEnvVariable(name) {
-  if (typeof process === "undefined") {
-    return void 0;
-  }
-  return process?.env[name];
+export function getEnvVariable(name) {
+    if (typeof process === 'undefined') {
+        return undefined;
+    }
+    return process?.env[name];
 }
-export {
-  detectEnvironment,
-  getEnvVariable
-};

package/lib/utils/error.js

@@ -1,54 +1,50 @@
 import { ErrorCode, ErrorData } from "../proto/api.js";
 const PROTO_ERROR = ErrorData.fromJSON({});
-class AttestorError extends Error {
-  name = "AttestorError";
-  code;
-  data;
-  constructor(code, message, data) {
-    super(message);
-    this.code = code;
-    this.data = data;
-  }
-  /**
-   * Encodes the error as a ErrorData
-   * protobuf message
-   */
-  toProto() {
-    return ErrorData.create({
-      code: ErrorCode[this.code],
-      message: this.message,
-      data: JSON.stringify(this.data)
-    });
-  }
-  static fromProto(data = PROTO_ERROR) {
-    return new AttestorError(
-      typeof data.code === "number" ? getKeyForValue(ErrorCode, data.code) || "UNRECOGNIZED" : data.code,
-      data.message,
-      data.data ? JSON.parse(data.data) : void 0
-    );
-  }
-  static fromError(err, code = "ERROR_INTERNAL") {
-    if (err instanceof AttestorError) {
-      return err;
+/**
+ * Represents an error that can be thrown by the Attestor Core
+ * or server. Provides a code, and optional data
+ * to pass along with the error.
+ */
+export class AttestorError extends Error {
+    name = 'AttestorError';
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+    /**
+     * Encodes the error as a ErrorData
+     * protobuf message
+     */
+    toProto() {
+        return ErrorData.create({
+            code: ErrorCode[this.code],
+            message: this.message,
+            data: JSON.stringify(this.data)
+        });
+    }
+    static fromProto(data = PROTO_ERROR) {
+        return new AttestorError(typeof data.code === 'number'
+            ? getKeyForValue(ErrorCode, data.code) || 'UNRECOGNIZED'
+            : data.code, data.message, data.data ? JSON.parse(data.data) : undefined);
+    }
+    static fromError(err, code = 'ERROR_INTERNAL') {
+        if (err instanceof AttestorError) {
+            return err;
+        }
+        return new AttestorError(code, err.message);
+    }
+    static badRequest(message, data) {
+        return new AttestorError('ERROR_BAD_REQUEST', message, data);
     }
-    return new AttestorError(code, err.message);
-  }
-  static badRequest(message, data) {
-    return new AttestorError(
-      "ERROR_BAD_REQUEST",
-      message,
-      data
-    );
-  }
 }
 function getKeyForValue(obj, value) {
-  for (const key in obj) {
-    if (obj[key] === value) {
-      return key;
+    for (const key in obj) {
+        if (obj[key] === value) {
+            return key;
+        }
     }
-  }
-  return void 0;
+    return undefined;
 }
-export {
-  AttestorError
-};