verbose logging

Author: klpx

src/codestorage/infura.ts

@@ -4,6 +4,10 @@ import fs from "fs";
 import { of } from "ipfs-only-hash";
 import { CodeStorageProvider, FileUploadSpec } from "./provider";
 import { ToContent } from "ipfs-core-types/src/utils";
+import { getLogger } from "../logger";
+
+const logger = getLogger("infura");
+
 export class Infura implements CodeStorageProvider {
   #client: IPFSHTTPClient;
 
@@ -23,25 +27,63 @@ export class Infura implements CodeStorageProvider {
   }
 
   async writeFromContent(files: ToContent[], pin: boolean): Promise<string[]> {
-    return Promise.all(
-      files.map((f) =>
+    logger.debug("Writing content to IPFS", { filesCount: files.length, pin });
+    const startTime = Date.now();
+
+    const results = await Promise.all(
+      files.map((f, index) =>
         this.#client.add({ content: f }, { pin }).then((r) => {
-          return `ipfs://${r.cid.toString()}`;
+          const cid = `ipfs://${r.cid.toString()}`;
+          logger.debug("File uploaded to IPFS", { index, cid });
+          return cid;
         }),
       ),
     );
+
+    logger.info("Content written to IPFS successfully", {
+      filesCount: results.length,
+      duration: Date.now() - startTime,
+    });
+
+    return results;
   }
 
   async write(files: FileUploadSpec[], pin: boolean): Promise<string[]> {
+    logger.debug("Writing files to IPFS", {
+      filesCount: files.length,
+      pin,
+      files: files.map((f) => f.name),
+    });
     return this.writeFromContent(
       files.map((f) => fs.createReadStream(f.path)),
       pin,
     );
   }
 
   async read(pointer: string): Promise<string> {
-    return (
-      await fetch(`https://${process.env.IPFS_PROVIDER}/ipfs/${pointer.replace("ipfs://", "")}`)
-    ).text();
+    logger.debug("Reading from IPFS", { pointer });
+    const startTime = Date.now();
+
+    const url = `https://${process.env.IPFS_PROVIDER}/ipfs/${pointer.replace("ipfs://", "")}`;
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      logger.error("Failed to read from IPFS", {
+        pointer,
+        url,
+        status: response.status,
+        statusText: response.statusText,
+      });
+      throw new Error(`IPFS read failed: ${response.status} ${response.statusText}`);
+    }
+
+    const text = await response.text();
+    logger.debug("Successfully read from IPFS", {
+      pointer,
+      duration: Date.now() - startTime,
+      size: text.length,
+    });
+
+    return text;
   }
 }

src/codestorage/pinata.ts

@@ -5,6 +5,9 @@ import { of } from "ipfs-only-hash";
 import { Readable } from "stream";
 import { PinataSDK } from "pinata";
 import { CodeStorageProvider, FileUploadSpec } from "./provider";
+import { getLogger } from "../logger";
+
+const logger = getLogger("pinata");
 
 export class Pinata implements CodeStorageProvider {
   #pinata: PinataSDK;
@@ -20,8 +23,11 @@ export class Pinata implements CodeStorageProvider {
   }
 
   async writeFromContent(files: ToContent[], pin: boolean): Promise<string[]> {
-    return Promise.all(
-      files.map(async (f) => {
+    logger.debug("Writing content to IPFS", { filesCount: files.length, pin });
+    const startTime = Date.now();
+
+    const results = await Promise.all(
+      files.map(async (f, index) => {
         // Convert ToContent to a File-like object that Pinata SDK can handle
         let fileData: Buffer;
         if (Buffer.isBuffer(f)) {
@@ -41,25 +47,73 @@ export class Pinata implements CodeStorageProvider {
         // Create a File from the buffer
         const file = new File([fileData], "file");
         const result = await this.#pinata.upload.public.file(file);
-        return `ipfs://${result.cid}`;
+        const cid = `ipfs://${result.cid}`;
+        logger.debug("File uploaded to IPFS", { index, cid });
+        return cid;
       }),
     );
+
+    logger.info("Content written to IPFS successfully", {
+      filesCount: results.length,
+      duration: Date.now() - startTime,
+    });
+
+    return results;
   }
 
   async write(files: FileUploadSpec[], pin: boolean): Promise<string[]> {
-    return Promise.all(
-      files.map(async (fileSpec) => {
+    logger.debug("Writing files to IPFS", {
+      filesCount: files.length,
+      pin,
+      files: files.map((f) => f.name),
+    });
+    const startTime = Date.now();
+
+    const results = await Promise.all(
+      files.map(async (fileSpec, index) => {
         // Read the file from the filesystem
         const fileData = await fs.promises.readFile(fileSpec.path);
         const file = new File([fileData], fileSpec.name);
         const result = await this.#pinata.upload.public.file(file);
-        return `ipfs://${result.cid}`;
+        const cid = `ipfs://${result.cid}`;
+        logger.debug("File uploaded to IPFS", { index, fileName: fileSpec.name, cid });
+        return cid;
       }),
     );
+
+    logger.info("Files written to IPFS successfully", {
+      filesCount: results.length,
+      duration: Date.now() - startTime,
+    });
+
+    return results;
   }
 
   async read(pointer: string): Promise<string> {
+    logger.debug("Reading from IPFS", { pointer });
+    const startTime = Date.now();
+
     const hash = pointer.replace("ipfs://", "");
-    return (await fetch(`https://${this.#gateway}/ipfs/${hash}`)).text();
+    const url = `https://${this.#gateway}/ipfs/${hash}`;
+    const response = await fetch(url);
+
+    if (!response.ok) {
+      logger.error("Failed to read from IPFS", {
+        pointer,
+        url,
+        status: response.status,
+        statusText: response.statusText,
+      });
+      throw new Error(`IPFS read failed: ${response.status} ${response.statusText}`);
+    }
+
+    const text = await response.text();
+    logger.debug("Successfully read from IPFS", {
+      pointer,
+      duration: Date.now() - startTime,
+      size: text.length,
+    });
+
+    return text;
   }
 }

src/controller.ts

@@ -61,31 +61,54 @@ export class Controller {
   }
 
   async addSource(verificationPayload: SourceVerifyPayload): Promise<VerifyResult> {
+    logger.info("Starting source verification", {
+      compiler: verificationPayload.compiler,
+      knownContractHash: verificationPayload.knownContractHash,
+      sourcesCount: verificationPayload.sources.length,
+    });
+
     // Compile
+    logger.debug("Compiling sources", { compiler: verificationPayload.compiler });
     const compiler = this.compilers[verificationPayload.compiler];
     const compileResult = await compiler.verify(verificationPayload);
+
     if (compileResult.error || compileResult.result !== "similar" || !compileResult.hash) {
+      logger.warn("Compilation failed or hash mismatch", {
+        result: compileResult.result,
+        error: compileResult.error,
+        hash: compileResult.hash,
+      });
       return {
         compileResult,
       };
     }
 
+    logger.info("Compilation successful", {
+      hash: compileResult.hash,
+      result: compileResult.result,
+    });
+
     if (!this.config.allowReverification) {
+      logger.debug("Checking if proof already deployed");
       const isDeployed = await this.tonReaderClient.isProofDeployed(
         verificationPayload.knownContractHash,
         this.config.verifierId,
       );
       if (isDeployed) {
+        logger.warn("Contract already verified", {
+          knownContractHash: verificationPayload.knownContractHash,
+        });
         return {
           compileResult: {
             result: "unknown_error",
-            error: "Contract is already deployed",
+            error: "Proof has already been deployed",
             hash: null,
             compilerSettings: compileResult.compilerSettings,
             sources: compileResult.sources,
           },
         };
       }
+      logger.debug("Proof not deployed, proceeding");
     }
 
     // Upload sources to IPFS
@@ -101,7 +124,14 @@ export class Controller {
         name: s.filename,
       }),
     );
+
+    logger.info("Uploading sources to IPFS", {
+      sourcesCount: sourcesToUpload.length,
+    });
     const fileLocators = await this.ipfsProvider.write(sourcesToUpload, true);
+    logger.info("Sources uploaded to IPFS", {
+      filesUploaded: fileLocators.length,
+    });
 
     const sourceSpec: SourceItem = {
       compilerSettings: compileResult.compilerSettings,
@@ -118,14 +148,16 @@ export class Controller {
     };
 
     // Upload source spec JSON to IPFS
+    logger.debug("Uploading source spec to IPFS");
     const [ipfsLink] = await this.ipfsProvider.writeFromContent(
       [Buffer.from(JSON.stringify(sourceSpec))],
       true,
     );
 
-    logger.info(ipfsLink);
+    logger.info("Source spec uploaded", { ipfsLink });
 
     const queryId = random64BitNumber();
+    logger.debug("Signing message", { queryId });
 
     // This is the message that will be forwarded to verifier registry
     const msgToSign = cellToSign(
@@ -139,6 +171,11 @@ export class Controller {
 
     const { sig, sigCell } = signatureCell(msgToSign, this.keypair);
 
+    logger.info("Source verification completed successfully", {
+      ipfsLink,
+      hash: compileResult.hash,
+    });
+
     return {
       compileResult,
       sig: sig.toString("base64"),
@@ -148,13 +185,17 @@ export class Controller {
   }
 
   public async sign({ messageCell, tmpDir }: { messageCell: Buffer; tmpDir: string }) {
+    logger.info("Starting message signing");
+
     const cell = Cell.fromBoc(Buffer.from(messageCell))[0];
 
+    logger.debug("Getting verifier config");
     const verifierConfig = await this.tonReaderClient.getVerifierConfig(
       this.config.verifierId,
       this.config.sourcesRegistryAddress,
     );
 
+    logger.debug("Validating message cell");
     const { ipfsPointer, codeCellHash, senderAddress, queryId } = validateMessageCell(
       cell,
       this.VERIFIER_SHA256,
@@ -163,16 +204,31 @@ export class Controller {
       verifierConfig,
     );
 
+    logger.debug("Reading source spec from IPFS", { ipfsPointer });
     const sourceTemp = await this.ipfsProvider.read(ipfsPointer);
 
     const json: SourceItem = JSON.parse(sourceTemp);
 
+    logger.debug("Verifying code hash", {
+      expectedHash: codeCellHash,
+      actualHash: json.hash,
+    });
+
     if (json.hash !== codeCellHash) {
+      logger.error("Code hash mismatch", {
+        expectedHash: codeCellHash,
+        actualHash: json.hash,
+      });
       throw new Error("Code hash mismatch");
     }
 
     const compiler = this.compilers[json.compiler];
 
+    logger.debug("Reading sources from IPFS", {
+      sourcesCount: json.sources.length,
+      compiler: json.compiler,
+    });
+
     const sources = await Promise.all(
       json.sources.map(async (s) => {
         const content = await this.ipfsProvider.read(s.url);
@@ -188,6 +244,10 @@ export class Controller {
       }),
     );
 
+    logger.info("Sources downloaded from IPFS", {
+      sourcesCount: sources.length,
+    });
+
     const sourceToVerify: SourceVerifyPayload = {
       sources: sources,
       compiler: json.compiler,
@@ -203,17 +263,27 @@ export class Controller {
       senderAddress: senderAddress.toString(),
     };
 
+    logger.debug("Verifying compilation");
     const compileResult = await compiler.verify(sourceToVerify);
 
     if (compileResult.result !== "similar") {
+      logger.error("Compilation verification failed", {
+        result: compileResult.result,
+        error: compileResult.error,
+      });
       throw new Error("Invalid compilation result: " + compileResult.result);
     }
 
+    logger.info("Compilation verified successfully");
+
+    logger.debug("Creating signature cell");
     const slice = cell.beginParse();
     const msgToSign = slice.loadRef();
     const { sigCell } = signatureCell(msgToSign, this.keypair);
     let updateSigCell = addSignatureCell(slice.loadRef(), sigCell);
 
+    logger.info("Message signing completed successfully");
+
     return {
       msgCell: slice.asBuilder().storeRef(msgToSign).storeRef(updateSigCell).asCell().toBoc(),
     };