@certik/skynet 0.22.1 → 0.22.2

package/dist/log.d.ts

@@ -11,4 +11,3 @@ declare const logger: {
     error: (...args: unknown[]) => void;
 };
 export { print, getLine, inline, logger };
-//# sourceMappingURL=log.d.ts.map

package/dist/log.js

@@ -1,62 +1,63 @@
+// src/log.ts
 function isObject(a) {
-    return !!a && a.constructor === Object;
+  return !!a && a.constructor === Object;
 }
 function print(o) {
-    if (Array.isArray(o)) {
-        return `[${o.map(print).join(", ")}]`;
-    }
-    if (isObject(o)) {
-        return `{${Object.keys(o)
-            .map((k) => `${k}: ${o[k]}`)
-            .join(", ")}}`;
-    }
-    return `${o}`;
+  if (Array.isArray(o)) {
+    return `[${o.map(print).join(", ")}]`;
+  }
+  if (isObject(o)) {
+    return `{${Object.keys(o).map((k) => `${k}: ${o[k]}`).join(", ")}}`;
+  }
+  return `${o}`;
 }
 function getLine(params) {
-    let line = "";
-    // Convert to string and filter out newline to tabs (AWS Athena)
-    for (let i = 0, l = params.length; i < l; i++) {
-        // Certain objects don't get converted
-        // Note using JSON.stringfy may be too slow for large objects
-        line += `${print(params[i])} `.replace(/\n/gm, "\t");
-    }
-    return line.trim();
+  let line = "";
+  for (let i = 0, l = params.length;i < l; i++) {
+    line += `${print(params[i])} `.replace(/\n/gm, "\t");
+  }
+  return line.trim();
 }
 function timestamp() {
-    return new Date().toISOString();
+  return new Date().toISOString();
 }
-const inline = {
-    debug: function (...args) {
-        if (process.env.NODE_ENV === "development") {
-            console.log(`${timestamp()} ${getLine(args)}`);
-        }
-    },
-    log: function (...args) {
-        if (process.env.NODE_ENV !== "test") {
-            console.log(`${timestamp()} ${getLine(args)}`);
-        }
-    },
-    error: function (...args) {
-        if (process.env.NODE_ENV !== "test") {
-            console.error(`${timestamp()} ${getLine(args)}`);
-        }
-    },
+var inline = {
+  debug: function(...args) {
+    if (true) {
+      console.log(`${timestamp()} ${getLine(args)}`);
+    }
+  },
+  log: function(...args) {
+    if (true) {
+      console.log(`${timestamp()} ${getLine(args)}`);
+    }
+  },
+  error: function(...args) {
+    if (true) {
+      console.error(`${timestamp()} ${getLine(args)}`);
+    }
+  }
+};
+var logger = {
+  debug: function(...args) {
+    if (true) {
+      console.log(`[${timestamp()}]`, ...args);
+    }
+  },
+  log: function(...args) {
+    if (true) {
+      console.log(`[${timestamp()}]`, ...args);
+    }
+  },
+  error: function(...args) {
+    if (true) {
+      console.error(`[${timestamp()}]`, ...args);
+    }
+  }
 };
-const logger = {
-    debug: function (...args) {
-        if (process.env.NODE_ENV === "development") {
-            console.log(`[${timestamp()}]`, ...args);
-        }
-    },
-    log: function (...args) {
-        if (process.env.NODE_ENV !== "test") {
-            console.log(`[${timestamp()}]`, ...args);
-        }
-    },
-    error: function (...args) {
-        if (process.env.NODE_ENV !== "test") {
-            console.error(`[${timestamp()}]`, ...args);
-        }
-    },
+export {
+  print,
+  logger,
+  inline,
+  getLine
 };
-export { print, getLine, inline, logger };

package/dist/object-hash.d.ts

@@ -1,2 +1 @@
 export declare function getHash(obj: unknown): string;
-//# sourceMappingURL=object-hash.d.ts.map

package/dist/object-hash.js

@@ -1,71 +1,61 @@
+// src/object-hash.ts
 import xh from "@node-rs/xxhash";
-export function getHash(obj) {
-    const xxh3 = xh.xxh3.Xxh3.withSeed();
-    hash(obj, xxh3);
-    return xxh3.digest().toString(16);
+function getHash(obj) {
+  const xxh3 = xh.xxh3.Xxh3.withSeed();
+  hash(obj, xxh3);
+  return xxh3.digest().toString(16);
 }
 function hash(obj, xxh3) {
-    if (obj === null) {
-        xxh3.update("null");
-    }
-    else if (obj === undefined) {
-        xxh3.update("undefined");
-    }
-    else if (typeof obj === "string") {
-        xxh3.update(obj);
-    }
-    else if (typeof obj === "number") {
-        xxh3.update(obj.toString());
-    }
-    else if (typeof obj === "boolean") {
-        xxh3.update(obj.toString());
-    }
-    else if (typeof obj === "bigint") {
-        xxh3.update(obj.toString());
-    }
-    else if (obj instanceof Date) {
-        xxh3.update(obj.toISOString());
-    }
-    else if (Array.isArray(obj)) {
-        arrayHash(obj, xxh3);
-    }
-    else if (obj instanceof Set) {
-        setHash(obj, xxh3);
-    }
-    else if (obj instanceof Map) {
-        mapHash(obj, xxh3);
-    }
-    else if (typeof obj === "object") {
-        objectHash(obj, xxh3);
-    }
-    else {
-        throw new Error(`Unsupported type: ${obj}`);
-    }
+  if (obj === null) {
+    xxh3.update("null");
+  } else if (obj === undefined) {
+    xxh3.update("undefined");
+  } else if (typeof obj === "string") {
+    xxh3.update(obj);
+  } else if (typeof obj === "number") {
+    xxh3.update(obj.toString());
+  } else if (typeof obj === "boolean") {
+    xxh3.update(obj.toString());
+  } else if (typeof obj === "bigint") {
+    xxh3.update(obj.toString());
+  } else if (obj instanceof Date) {
+    xxh3.update(obj.toISOString());
+  } else if (Array.isArray(obj)) {
+    arrayHash(obj, xxh3);
+  } else if (obj instanceof Set) {
+    setHash(obj, xxh3);
+  } else if (obj instanceof Map) {
+    mapHash(obj, xxh3);
+  } else if (typeof obj === "object") {
+    objectHash(obj, xxh3);
+  } else {
+    throw new Error(`Unsupported type: ${obj}`);
+  }
 }
 function arrayHash(array, xxh3) {
-    xxh3.update("[");
-    for (const obj of array) {
-        hash(obj, xxh3);
-    }
-    xxh3.update("]");
+  xxh3.update("[");
+  for (const obj of array) {
+    hash(obj, xxh3);
+  }
+  xxh3.update("]");
 }
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function setHash(_set, _xxh3) {
-    throw new Error("Set hashing not implemented");
+  throw new Error("Set hashing not implemented");
 }
 function mapHash(map, xxh3) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const array = Array.from(map.entries()).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
-    for (const [key, value] of array) {
-        hash(key, xxh3);
-        hash(value, xxh3);
-    }
+  const array = Array.from(map.entries()).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
+  for (const [key, value] of array) {
+    hash(key, xxh3);
+    hash(value, xxh3);
+  }
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function objectHash(obj, xxh3) {
-    const array = Object.entries(obj).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
-    for (const [key, value] of array) {
-        hash(key, xxh3);
-        hash(value, xxh3);
-    }
+  const array = Object.entries(obj).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
+  for (const [key, value] of array) {
+    hash(key, xxh3);
+    hash(value, xxh3);
+  }
 }
+export {
+  getHash
+};

package/dist/opsgenie.d.ts

@@ -11,6 +11,7 @@ type OpsgenieResponse = {
     };
     took: number;
     requestId: string;
+    result: string;
 };
 export declare function postGenieMessage(body: {
     alias?: string;
@@ -18,4 +19,3 @@ export declare function postGenieMessage(body: {
     description?: string;
 }, apiKey?: string, verbose?: boolean): Promise<OpsgenieResponse>;
 export {};
-//# sourceMappingURL=opsgenie.d.ts.map

package/dist/opsgenie.js

@@ -1,38 +1,39 @@
+// src/opsgenie.ts
 import md5 from "md5";
 function getGenieKey(key) {
-    return key || process.env["SKYNET_OPSGENIE_API_KEY"];
+  return key || process.env["SKYNET_OPSGENIE_API_KEY"];
 }
 function getGenieEndPoint() {
-    return process.env["SKYNET_OPSGENIE_END_POINT"] || "https://api.opsgenie.com/v2/alerts";
+  return process.env["SKYNET_OPSGENIE_END_POINT"] || "https://api.opsgenie.com/v2/alerts";
 }
-export async function postGenieMessage(body, apiKey, verbose) {
-    try {
-        const genieKey = apiKey || getGenieKey();
-        const genieEndPoint = getGenieEndPoint();
-        // Prevents duplicate alerts (See Opsgenie doc about alias)
-        if (!body.alias) {
-            body.alias = md5(body.message);
-        }
-        if (verbose) {
-            console.log(`Making API call to Opsgenie`, JSON.stringify(body, null, 2));
-        }
-        // Makes the call using fetch and ENV variables
-        const response = await fetch(genieEndPoint, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `GenieKey ${genieKey}`,
-            },
-            body: JSON.stringify(body),
-        });
-        const result = await response.json();
-        if (verbose) {
-            console.log(`Result of API call to Opsgenie... ${result}`);
-        }
-        return result;
+async function postGenieMessage(body, apiKey, verbose) {
+  try {
+    const genieKey = apiKey || getGenieKey();
+    const genieEndPoint = getGenieEndPoint();
+    if (!body.alias) {
+      body.alias = md5(body.message);
     }
-    catch (error) {
-        console.error("Failed to make opsgenie API call", error);
-        throw error;
+    if (verbose) {
+      console.log(`Making API call to Opsgenie`, JSON.stringify(body, null, 2));
     }
+    const response = await fetch(genieEndPoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `GenieKey ${genieKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    const result = await response.json();
+    if (verbose) {
+      console.log(`Result of API call to Opsgenie... ${result}`);
+    }
+    return result;
+  } catch (error) {
+    console.error("Failed to make opsgenie API call", error);
+    throw error;
+  }
 }
+export {
+  postGenieMessage
+};

package/dist/por.d.ts

@@ -35,4 +35,3 @@ export declare class MerkleTreePoR {
     generateProof(userHash: string, token?: string): MerkleProof;
     static verifyProof(merkleProof: MerkleProof): boolean;
 }
-//# sourceMappingURL=por.d.ts.map

package/dist/por.js

@@ -1,130 +1,120 @@
-import { CryptoHasher } from "bun";
-export class MerkleTreePoR {
-    constructor(users, hashFunction) {
-        this.leaves = [];
-        this.tree = [];
-        this.userMap = new Map();
-        this.userData = [];
-        this.userData = [...users];
-        this.hashFunction = hashFunction || this.defaultSHA256Hash;
-        this.buildTree();
+// @bun
+// src/por.ts
+var {CryptoHasher } = globalThis.Bun;
+
+class MerkleTreePoR {
+  leaves = [];
+  tree = [];
+  userMap = new Map;
+  userData = [];
+  hashFunction;
+  constructor(users, hashFunction) {
+    this.userData = [...users];
+    this.hashFunction = hashFunction || this.defaultSHA256Hash;
+    this.buildTree();
+  }
+  static defaultSHA256Hash(data) {
+    const hasher = new CryptoHasher("sha256");
+    hasher.update(data);
+    return hasher.digest("hex");
+  }
+  defaultSHA256Hash(data) {
+    return MerkleTreePoR.defaultSHA256Hash(data);
+  }
+  hash(data) {
+    return this.hashFunction(data);
+  }
+  createLeafHash(user) {
+    const leafData = `${user.userHash}:${user.balance}:${user.token || ""}`;
+    return this.hash(leafData);
+  }
+  buildTree() {
+    if (this.userData.length === 0) {
+      throw new Error("Cannot build tree with empty user data");
     }
-    // Default SHA-256 hash function
-    static defaultSHA256Hash(data) {
-        const hasher = new CryptoHasher("sha256");
-        hasher.update(data);
-        return hasher.digest("hex");
-    }
-    defaultSHA256Hash(data) {
-        return MerkleTreePoR.defaultSHA256Hash(data);
-    }
-    // Configurable hash function
-    hash(data) {
-        return this.hashFunction(data);
-    }
-    // hash user data
-    createLeafHash(user) {
-        const leafData = `${user.userHash}:${user.balance}:${user.token || ''}`;
-        return this.hash(leafData);
-    }
-    buildTree() {
-        if (this.userData.length === 0) {
-            throw new Error('Cannot build tree with empty user data');
-        }
-        // Create leaf hashes and store user mapping
-        this.leaves = this.userData.map((user, index) => {
-            const leafHash = this.createLeafHash(user);
-            this.userMap.set(`${user.userHash}:${user.token || ''}`, index);
-            return leafHash;
+    this.leaves = this.userData.map((user, index) => {
+      const leafHash = this.createLeafHash(user);
+      this.userMap.set(`${user.userHash}:${user.token || ""}`, index);
+      return leafHash;
+    });
+    let currentLevel = this.leaves;
+    this.tree.push(currentLevel.map((hash) => ({ hash })));
+    while (currentLevel.length > 1) {
+      const nextLevel = [];
+      const nextLevelNodes = [];
+      for (let i = 0;i < currentLevel.length; i += 2) {
+        const left = currentLevel[i];
+        const right = i + 1 < currentLevel.length ? currentLevel[i + 1] : left;
+        const parentHash = this.hash(left + right);
+        nextLevel.push(parentHash);
+        const leftNode = this.tree[this.tree.length - 1][i];
+        const rightNode = i + 1 < currentLevel.length ? this.tree[this.tree.length - 1][i + 1] : leftNode;
+        nextLevelNodes.push({
+          hash: parentHash,
+          left: leftNode,
+          right: rightNode
         });
-        // Start with leaf level
-        let currentLevel = this.leaves;
-        this.tree.push(currentLevel.map(hash => ({ hash })));
-        // Build tree bottom-up
-        while (currentLevel.length > 1) {
-            const nextLevel = [];
-            const nextLevelNodes = [];
-            for (let i = 0; i < currentLevel.length; i += 2) {
-                const left = currentLevel[i];
-                const right = i + 1 < currentLevel.length
-                    ? currentLevel[i + 1]
-                    : left; // Duplicate if odd number
-                const parentHash = this.hash(left + right);
-                nextLevel.push(parentHash);
-                const leftNode = this.tree[this.tree.length - 1][i];
-                const rightNode = i + 1 < currentLevel.length
-                    ? this.tree[this.tree.length - 1][i + 1]
-                    : leftNode;
-                nextLevelNodes.push({
-                    hash: parentHash,
-                    left: leftNode,
-                    right: rightNode
-                });
-            }
-            currentLevel = nextLevel;
-            this.tree.push(nextLevelNodes);
-        }
+      }
+      currentLevel = nextLevel;
+      this.tree.push(nextLevelNodes);
+    }
+  }
+  getRootHash() {
+    if (this.tree.length === 0) {
+      throw new Error("Merkle tree not built");
     }
-    // get root hash of created tree
-    getRootHash() {
-        if (this.tree.length === 0) {
-            throw new Error('Merkle tree not built');
-        }
-        return this.tree[this.tree.length - 1][0].hash;
+    return this.tree[this.tree.length - 1][0].hash;
+  }
+  generateProof(userHash, token) {
+    const key = `${userHash}:${token || ""}`;
+    const leafIndex = this.userMap.get(key);
+    if (leafIndex === undefined) {
+      throw new Error(`${userHash} not found in merkle tree for token ${token}`);
     }
-    // generate merkle proof
-    generateProof(userHash, token) {
-        const key = `${userHash}:${token || ''}`;
-        const leafIndex = this.userMap.get(key);
-        if (leafIndex === undefined) {
-            throw new Error(`${userHash} not found in merkle tree for token ${token}`);
-        }
-        const user = this.userData[leafIndex];
-        const proof = [];
-        const positions = [];
-        let currentIndex = leafIndex;
-        // Walk up the tree collecting sibling hashes
-        for (let level = 0; level < this.tree.length - 1; level++) {
-            const currentLevelSize = this.tree[level].length;
-            const isRightNode = currentIndex % 2 === 1;
-            const siblingIndex = isRightNode ? currentIndex - 1 : currentIndex + 1;
-            if (siblingIndex < currentLevelSize) {
-                proof.push(this.tree[level][siblingIndex].hash);
-                positions.push(isRightNode ? 'left' : 'right');
-            }
-            else {
-                // When odd number, the last node is duplicated
-                proof.push(this.tree[level][currentIndex].hash);
-                positions.push(isRightNode ? 'left' : 'right');
-            }
-            currentIndex = Math.floor(currentIndex / 2);
-        }
-        return {
-            userHash: user.userHash,
-            balance: user.balance,
-            token: user.token,
-            proof,
-            positions,
-            rootHash: this.getRootHash(),
-            leafIndex,
-            hashFunction: this.hashFunction !== this.defaultSHA256Hash ? this.hashFunction : undefined
-        };
+    const user = this.userData[leafIndex];
+    const proof = [];
+    const positions = [];
+    let currentIndex = leafIndex;
+    for (let level = 0;level < this.tree.length - 1; level++) {
+      const currentLevelSize = this.tree[level].length;
+      const isRightNode = currentIndex % 2 === 1;
+      const siblingIndex = isRightNode ? currentIndex - 1 : currentIndex + 1;
+      if (siblingIndex < currentLevelSize) {
+        proof.push(this.tree[level][siblingIndex].hash);
+        positions.push(isRightNode ? "left" : "right");
+      } else {
+        proof.push(this.tree[level][currentIndex].hash);
+        positions.push(isRightNode ? "left" : "right");
+      }
+      currentIndex = Math.floor(currentIndex / 2);
     }
-    // verify inclusion using proof
-    static verifyProof(merkleProof) {
-        const leafData = `${merkleProof.userHash}:${merkleProof.balance}:${merkleProof.token || ''}`;
-        const hashFunction = merkleProof.hashFunction || MerkleTreePoR.defaultSHA256Hash;
-        let currentHash = hashFunction(leafData);
-        for (let i = 0; i < merkleProof.proof.length; i++) {
-            const siblingHash = merkleProof.proof[i];
-            const position = merkleProof.positions[i];
-            if (position === 'left') {
-                currentHash = hashFunction(siblingHash + currentHash);
-            }
-            else {
-                currentHash = hashFunction(currentHash + siblingHash);
-            }
-        }
-        return currentHash === merkleProof.rootHash;
+    return {
+      userHash: user.userHash,
+      balance: user.balance,
+      token: user.token,
+      proof,
+      positions,
+      rootHash: this.getRootHash(),
+      leafIndex,
+      hashFunction: this.hashFunction !== this.defaultSHA256Hash ? this.hashFunction : undefined
+    };
+  }
+  static verifyProof(merkleProof) {
+    const leafData = `${merkleProof.userHash}:${merkleProof.balance}:${merkleProof.token || ""}`;
+    const hashFunction = merkleProof.hashFunction || MerkleTreePoR.defaultSHA256Hash;
+    let currentHash = hashFunction(leafData);
+    for (let i = 0;i < merkleProof.proof.length; i++) {
+      const siblingHash = merkleProof.proof[i];
+      const position = merkleProof.positions[i];
+      if (position === "left") {
+        currentHash = hashFunction(siblingHash + currentHash);
+      } else {
+        currentHash = hashFunction(currentHash + siblingHash);
+      }
     }
+    return currentHash === merkleProof.rootHash;
+  }
 }
+export {
+  MerkleTreePoR
+};

package/dist/s3.d.ts

@@ -1,21 +1,20 @@
 import { S3Client, ObjectCannedACL } from "@aws-sdk/client-s3";
 declare function getS3(forceNew?: boolean): S3Client;
-declare function readFile(bucketName: string, key: string, verbose?: boolean): Promise<string>;
+declare function readFile(bucketName: string, key: string, verbose?: boolean): Promise<string | null | undefined>;
 declare function hasFile(bucketName: string, key: string): Promise<boolean>;
-declare function getFileSize(bucketName: string, key: string): Promise<number>;
+declare function getFileSize(bucketName: string, key: string): Promise<number | undefined>;
 declare function writeFile(bucketName: string, key: string, body: string, options?: {
     verbose?: boolean;
     skipIfExists?: boolean;
     acl?: ObjectCannedACL;
     contentType?: string;
 }): Promise<void>;
-declare function deleteFile(bucketName: string, key: string, verbose?: boolean): Promise<any>;
+declare function deleteFile(bucketName: string, key: string, verbose?: boolean): Promise<null | undefined>;
 declare function listKeys(bucketName: string, prefix?: string, continuationToken?: string): Promise<{
-    keys: any[];
+    keys: never[];
     continuationToken?: undefined;
 } | {
-    keys: string[];
-    continuationToken: string;
-}>;
+    keys: (string | undefined)[];
+    continuationToken: string | undefined;
+} | null>;
 export { getS3, hasFile, readFile, writeFile, deleteFile, getFileSize, listKeys };
-//# sourceMappingURL=s3.d.ts.map