chore: Remove logs from the SDK

sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@verax-attestation-registry/verax-sdk",
-  "version": "1.8.1",
+  "version": "1.8.2",
   "description": "Verax Attestation Registry SDK to interact with the subgraph and the contracts",
   "keywords": [
     "linea-attestation-registry",

sdk/src/dataMapper/AttestationDataMapper.ts

@@ -1,10 +1,10 @@
 import BaseDataMapper from "./BaseDataMapper";
 import { abiAttestationRegistry } from "../abi/AttestationRegistry";
 import { Attestation, AttestationPayload, OffchainData, Schema } from "../types";
+import { ActionType, Constants } from "../utils/constants";
 import { Attestation_filter, Attestation_orderBy, OrderDirection } from "../../.graphclient";
-import { Constants } from "../utils/constants";
-import { handleSimulationError } from "../utils/simulationErrorHandler";
-import { Address } from "viem";
+import { handleError } from "../utils/errorHandler";
+import { Address, Hex } from "viem";
 import { decodeWithRetry, encode } from "../utils/abiCoder";
 import { executeTransaction } from "../utils/transactionSender";
 import { getIPFSContent } from "../utils/ipfsClient";
@@ -59,7 +59,7 @@ export default class AttestationDataMapper extends BaseDataMapper<
 
   private async enrichAttestation(attestation: Attestation) {
     const schema = (await this.veraxSdk.schema.findOneById(attestation.schemaId)) as Schema;
-    attestation.decodedPayload = decodeWithRetry(schema.schema, attestation.attestationData as `0x${string}`);
+    attestation.decodedPayload = decodeWithRetry(schema.schema, attestation.attestationData as Hex);
 
     attestation.attestedDate = Number(attestation.attestedDate);
     attestation.expirationDate = Number(attestation.expirationDate);
@@ -82,10 +82,7 @@ export default class AttestationDataMapper extends BaseDataMapper<
             const offchainDataSchema = (await this.veraxSdk.schema.findOneById(
               attestation.offchainData.schemaId,
             )) as Schema;
-            attestation.decodedPayload = decodeWithRetry(
-              offchainDataSchema.schema,
-              attestation.attestationData as `0x${string}`,
-            );
+            attestation.decodedPayload = decodeWithRetry(offchainDataSchema.schema, attestation.attestationData as Hex);
           } else {
             attestation.decodedPayload = response as unknown as object;
           }
@@ -207,7 +204,7 @@ export default class AttestationDataMapper extends BaseDataMapper<
 
       return request;
     } catch (err) {
-      handleSimulationError(err);
+      handleError(ActionType.Simulation, err);
     }
   }
 }

sdk/src/dataMapper/BaseDataMapper.ts

@@ -2,8 +2,7 @@ import { PublicClient, WalletClient } from "viem";
 import { Conf } from "../types";
 import { OrderDirection } from "../../.graphclient";
 import { VeraxSdk } from "../VeraxSdk";
-import { stringifyWhereClause } from "../utils/graphClientHelper";
-import axios from "axios";
+import { stringifyWhereClause, subgraphCall } from "../utils/graphClientHelper";
 
 export default abstract class BaseDataMapper<T, TFilter, TOrder> {
   protected readonly conf: Conf;
@@ -23,7 +22,7 @@ export default abstract class BaseDataMapper<T, TFilter, TOrder> {
   async findOneById(id: string) {
     const query = `query get_${this.typeName} { ${this.typeName}(id: "${id}") ${this.gqlInterface} }`;
 
-    const { data, status } = await this.subgraphCall(query);
+    const { data, status } = await subgraphCall(query, this.conf.subgraphUrl);
 
     if (status != 200) {
       throw new Error(`Error(s) while fetching ${this.typeName}`);
@@ -46,25 +45,12 @@ export default abstract class BaseDataMapper<T, TFilter, TOrder> {
         }
     `;
 
-    const { data, status } = await this.subgraphCall(query);
+    const { data, status } = await subgraphCall(query, this.conf.subgraphUrl);
 
     if (status != 200) {
       throw new Error(`Error(s) while fetching ${this.typeName}s`);
     }
 
     return data?.data ? (data.data[`${this.typeName}s`] as T[]) : [];
   }
-
-  async subgraphCall(query: string) {
-    return axios.post(
-      this.conf.subgraphUrl,
-      { query },
-      {
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "application/json",
-        },
-      },
-    );
-  }
 }

sdk/src/dataMapper/ModuleDataMapper.ts

@@ -1,9 +1,10 @@
 import { Address } from "viem";
 import { Module_filter, Module_orderBy } from "../../.graphclient";
 import { AttestationPayload, Module } from "../types";
+import { ActionType } from "../utils/constants";
 import BaseDataMapper from "./BaseDataMapper";
 import { abiModuleRegistry } from "../abi/ModuleRegistry";
-import { handleSimulationError } from "../utils/simulationErrorHandler";
+import { handleError } from "../utils/errorHandler";
 import { executeTransaction } from "../utils/transactionSender";
 import { encode } from "../utils/abiCoder";
 
@@ -143,7 +144,7 @@ export default class ModuleDataMapper extends BaseDataMapper<Module, Module_filt
 
       return request;
     } catch (err) {
-      handleSimulationError(err);
+      handleError(ActionType.Simulation, err);
     }
   }
 }

sdk/src/dataMapper/PortalDataMapper.ts

@@ -1,11 +1,12 @@
 import { AttestationPayload, Portal } from "../types";
+import { ActionType } from "../utils/constants";
 import BaseDataMapper from "./BaseDataMapper";
 import { abiDefaultPortal } from "../abi/DefaultPortal";
 import { Address } from "viem";
 import { encode } from "../utils/abiCoder";
 import { Portal_filter, Portal_orderBy } from "../../.graphclient";
 import { abiPortalRegistry } from "../abi/PortalRegistry";
-import { handleSimulationError } from "../utils/simulationErrorHandler";
+import { handleError } from "../utils/errorHandler";
 import { executeTransaction } from "../utils/transactionSender";
 
 export default class PortalDataMapper extends BaseDataMapper<Portal, Portal_filter, Portal_orderBy> {
@@ -252,7 +253,7 @@ export default class PortalDataMapper extends BaseDataMapper<Portal, Portal_filt
 
       return request;
     } catch (err) {
-      handleSimulationError(err);
+      handleError(ActionType.Simulation, err);
     }
   }
 
@@ -275,7 +276,7 @@ export default class PortalDataMapper extends BaseDataMapper<Portal, Portal_filt
 
       return request;
     } catch (err) {
-      handleSimulationError(err);
+      handleError(ActionType.Simulation, err);
     }
   }
 }

sdk/src/dataMapper/SchemaDataMapper.ts

@@ -1,10 +1,11 @@
 import { Address, TransactionReceipt } from "viem";
 import { Schema_filter, Schema_orderBy } from "../../.graphclient";
 import { Schema } from "../types";
+import { ActionType } from "../utils/constants";
 import BaseDataMapper from "./BaseDataMapper";
 import { abiSchemaRegistry } from "../abi/SchemaRegistry";
 import { executeTransaction } from "../utils/transactionSender";
-import { handleSimulationError } from "../utils/simulationErrorHandler";
+import { handleError } from "../utils/errorHandler";
 
 export default class SchemaDataMapper extends BaseDataMapper<Schema, Schema_filter, Schema_orderBy> {
   typeName = "schema";
@@ -94,7 +95,7 @@ export default class SchemaDataMapper extends BaseDataMapper<Schema, Schema_filt
 
       return request;
     } catch (err) {
-      handleSimulationError(err);
+      handleError(ActionType.Simulation, err);
     }
   }
 }

sdk/src/dataMapper/UtilsDataMapper.ts

@@ -4,6 +4,7 @@ import { abiModuleRegistry } from "../abi/ModuleRegistry";
 import { abiPortalRegistry } from "../abi/PortalRegistry";
 import { abiSchemaRegistry } from "../abi/SchemaRegistry";
 import { decode, encode } from "../utils/abiCoder";
+import { Hex } from "viem";
 
 export default class UtilsDataMapper extends BaseDataMapper<object, unknown, unknown> {
   typeName = "counter";
@@ -54,11 +55,11 @@ export default class UtilsDataMapper extends BaseDataMapper<object, unknown, unk
     });
   }
 
-  encode(schema: string, values: unknown[]): `0x${string}` {
+  encode(schema: string, values: unknown[]): Hex {
     return encode(schema, values);
   }
 
-  decode(schema: string, attestationData: `0x${string}`): readonly unknown[] {
+  decode(schema: string, attestationData: Hex): readonly unknown[] {
     return decode(schema, attestationData);
   }
 }

sdk/src/types/index.ts

@@ -18,10 +18,6 @@ export type AttestationPayload = {
   attestationData: object[]; // The attestation data.
 };
 
-export type AttestationWithDecodeObject = Attestation & {
-  decodeObject: { [propName: string]: unknown };
-};
-
 export type Attestation = OnChainAttestation & {
   id: string;
   schemaString: string;

sdk/src/utils/abiCoder.ts

@@ -1,16 +1,16 @@
-import { AbiParameter, BaseError, decodeAbiParameters, encodeAbiParameters, parseAbiParameters } from "viem";
+import { AbiParameter, BaseError, decodeAbiParameters, encodeAbiParameters, Hex, parseAbiParameters } from "viem";
 
-const ENCODED_PARENTHESIS: `0x${string}` = "0x0000000000000000000000000000000000000000000000000000000000000020";
+const ENCODED_PARENTHESIS: Hex = "0x0000000000000000000000000000000000000000000000000000000000000020";
 
-export function encode(schema: string, values: unknown[]): `0x${string}` {
+export function encode(schema: string, values: unknown[]): Hex {
   return encodeAbiParameters(parseAbiParameters(schema), values);
 }
 
-export function decode(schema: string, attestationData: `0x${string}`): readonly unknown[] {
+export function decode(schema: string, attestationData: Hex): readonly unknown[] {
   return decodeAbiParameters(parseAbiParameters(schema), attestationData);
 }
 
-export function decodeWithRetry(schema: string, attestationData: `0x${string}`): readonly unknown[] {
+export function decodeWithRetry(schema: string, attestationData: Hex): readonly unknown[] {
   const wrappedSchema = schema.startsWith("(") ? schema : `(${schema})`;
   let result = decodeWrapped(wrappedSchema, attestationData);
 
@@ -21,7 +21,7 @@ export function decodeWithRetry(schema: string, attestationData: `0x${string}`):
   return result;
 }
 
-function decodeWrapped(schema: string, attestationData: `0x${string}`): readonly unknown[] {
+function decodeWrapped(schema: string, attestationData: Hex): readonly unknown[] {
   try {
     const parsedParams = tryParse(schema);
     return decodeAbiParameters(parsedParams, attestationData);

sdk/src/utils/constants.ts

@@ -9,3 +9,8 @@ export enum SDKMode {
   BACKEND = "BACKEND",
   FRONTEND = "FRONTEND",
 }
+
+export enum ActionType {
+  Simulation = "Simulation",
+  Transaction = "Transaction",
+}

sdk/src/utils/simulationErrorHandler.ts → sdk/src/utils/errorHandler.ts

@@ -1,15 +1,16 @@
 import { BaseError, ContractFunctionRevertedError } from "viem";
+import { ActionType } from "./constants";
 
-export function handleSimulationError(err: unknown): never {
+export function handleError(type: ActionType, err: unknown): never {
   if (err instanceof BaseError) {
     const revertError = err.walk((err) => err instanceof ContractFunctionRevertedError);
     if (revertError instanceof ContractFunctionRevertedError) {
       const errorName = revertError.data?.errorName ?? "";
-      console.error(`Failing with ${errorName}`);
+      throw new Error(`${type} failed with ${errorName}`);
     }
   } else {
-    console.error(err);
+    throw new Error(`${type} failed with ${err}`);
   }
 
-  throw new Error("Simulation failed");
+  throw new Error("${type} failed");
 }

sdk/src/utils/graphClientHelper.ts

@@ -1,4 +1,19 @@
+import axios from "axios";
+
 export function stringifyWhereClause(whereClauseObj: Record<string, unknown>) {
   const json = JSON.stringify(whereClauseObj);
   return json.replace(/"([^"]+)":/g, "$1:");
 }
+
+export function subgraphCall(query: string, url: string) {
+  return axios.post(
+    url,
+    { query },
+    {
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+      },
+    },
+  );
+}

sdk/src/utils/ipfsClient.ts

@@ -1,9 +1,7 @@
 import axios from "axios";
 
 export const getIPFSContent = async (ipfsHash: string): Promise<string> => {
-  // Use the Cloudflare IPFS gateway URL
   const ipfsGatewayUrl = `https://cloudflare-ipfs.com/ipfs/${ipfsHash}`;
-  // Make a request to the IPFS gateway
   const response = await axios.get(ipfsGatewayUrl);
   return response.data;
 };

sdk/src/utils/transactionSender.ts

@@ -1,4 +1,6 @@
 import { Hash, PublicClient, TransactionReceipt, WalletClient } from "viem";
+import { handleError } from "./errorHandler";
+import { ActionType } from "./constants";
 
 // TODO: Use correct type for request
 export async function executeTransaction(
@@ -14,17 +16,14 @@ export async function executeTransaction(
 
   try {
     const hash: Hash = await walletClient.writeContract(request);
-    console.log(`Transaction sent with hash ${hash}`);
 
     if (waitForConfirmation) {
       // Wait for the transaction to be confirmed
       return await publicClient.waitForTransactionReceipt({ hash });
     }
 
     return { transactionHash: hash };
-  } catch (error) {
-    // Handle errors or rethrow if needed
-    console.error("Error while executing transaction:", error);
-    throw error;
+  } catch (err) {
+    handleError(ActionType.Transaction, err);
   }
 }