@certik/skynet 0.22.1 → 0.22.3

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

package/dist/s3.js

@@ -1,110 +1,122 @@
-import { S3Client, GetObjectCommand, HeadObjectCommand, PutObjectCommand, DeleteObjectCommand, ListObjectsV2Command, NotFound, NoSuchKey, } from "@aws-sdk/client-s3";
-let _s3Client;
+// src/s3.ts
+import {
+  S3Client,
+  GetObjectCommand,
+  HeadObjectCommand,
+  PutObjectCommand,
+  DeleteObjectCommand,
+  ListObjectsV2Command,
+  NotFound,
+  NoSuchKey
+} from "@aws-sdk/client-s3";
+var _s3Client;
 function getS3(forceNew = false) {
-    if (!_s3Client || forceNew) {
-        _s3Client = new S3Client();
-    }
-    return _s3Client;
+  if (!_s3Client || forceNew) {
+    _s3Client = new S3Client;
+  }
+  return _s3Client;
 }
 async function readFile(bucketName, key, verbose = false) {
-    const s3 = getS3();
-    const params = { Bucket: bucketName, Key: key };
-    try {
-        const result = await s3.send(new GetObjectCommand(params));
-        return result.Body?.transformToString();
-    }
-    catch (error) {
-        if (error instanceof NoSuchKey) {
-            if (verbose) {
-                console.log("no such bucket or key", bucketName, key);
-            }
-            // do nothing
-            return null;
-        }
-        throw error;
+  const s3 = getS3();
+  const params = { Bucket: bucketName, Key: key };
+  try {
+    const result = await s3.send(new GetObjectCommand(params));
+    return result.Body?.transformToString();
+  } catch (error) {
+    if (error instanceof NoSuchKey) {
+      if (verbose) {
+        console.log("no such bucket or key", bucketName, key);
+      }
+      return null;
     }
+    throw error;
+  }
 }
 async function hasFile(bucketName, key) {
-    const s3 = getS3();
-    try {
-        await s3.send(new HeadObjectCommand({ Bucket: bucketName, Key: key }));
-        return true;
-    }
-    catch (headErr) {
-        if (headErr instanceof NotFound) {
-            return false;
-        }
-        throw headErr;
+  const s3 = getS3();
+  try {
+    await s3.send(new HeadObjectCommand({ Bucket: bucketName, Key: key }));
+    return true;
+  } catch (headErr) {
+    if (headErr instanceof NotFound) {
+      return false;
     }
+    throw headErr;
+  }
 }
 async function getFileSize(bucketName, key) {
-    const s3 = getS3();
-    const result = await s3.send(new HeadObjectCommand({
-        Bucket: bucketName,
-        Key: key,
-    }));
-    return result.ContentLength;
+  const s3 = getS3();
+  const result = await s3.send(new HeadObjectCommand({
+    Bucket: bucketName,
+    Key: key
+  }));
+  return result.ContentLength;
 }
 async function writeFile(bucketName, key, body, options = {}) {
-    const s3 = getS3();
-    if (options.skipIfExists) {
-        if (await hasFile(bucketName, key)) {
-            return;
-        }
-    }
-    const verbose = options.verbose || false;
-    const params = { Bucket: bucketName, Key: key, Body: body };
-    if (options.acl) {
-        params.ACL = options.acl;
-    }
-    if (options.contentType) {
-        params.ContentType = options.contentType;
+  const s3 = getS3();
+  if (options.skipIfExists) {
+    if (await hasFile(bucketName, key)) {
+      return;
     }
-    if (verbose) {
-        console.log("uploading", key);
-    }
-    await s3.send(new PutObjectCommand(params));
+  }
+  const verbose = options.verbose || false;
+  const params = { Bucket: bucketName, Key: key, Body: body };
+  if (options.acl) {
+    params.ACL = options.acl;
+  }
+  if (options.contentType) {
+    params.ContentType = options.contentType;
+  }
+  if (verbose) {
+    console.log("uploading", key);
+  }
+  await s3.send(new PutObjectCommand(params));
 }
 async function deleteFile(bucketName, key, verbose = false) {
-    const s3 = getS3();
-    const params = { Bucket: bucketName, Key: key };
-    try {
-        await s3.send(new DeleteObjectCommand(params));
-    }
-    catch (error) {
-        if (error instanceof NoSuchKey) {
-            if (verbose) {
-                console.log("no such bucket or key", bucketName, key);
-            }
-            // do nothing
-            return null;
-        }
-        throw error;
+  const s3 = getS3();
+  const params = { Bucket: bucketName, Key: key };
+  try {
+    await s3.send(new DeleteObjectCommand(params));
+  } catch (error) {
+    if (error instanceof NoSuchKey) {
+      if (verbose) {
+        console.log("no such bucket or key", bucketName, key);
+      }
+      return null;
     }
+    throw error;
+  }
 }
 async function listKeys(bucketName, prefix, continuationToken) {
-    const s3 = getS3();
-    const params = {
-        Bucket: bucketName,
-        Prefix: prefix,
-        ContinuationToken: continuationToken,
-    };
-    let data;
-    try {
-        data = await s3.send(new ListObjectsV2Command(params));
-    }
-    catch (err) {
-        if (err instanceof Error && "statusCode" in err && err.statusCode === 400) {
-            return null;
-        }
-        throw `unable to list keys with prefix ${prefix}: ${err}`;
-    }
-    if (!data.Contents) {
-        return { keys: [] };
+  const s3 = getS3();
+  const params = {
+    Bucket: bucketName,
+    Prefix: prefix,
+    ContinuationToken: continuationToken
+  };
+  let data;
+  try {
+    data = await s3.send(new ListObjectsV2Command(params));
+  } catch (err) {
+    if (err instanceof Error && "statusCode" in err && err.statusCode === 400) {
+      return null;
     }
-    return {
-        keys: data.Contents.map(({ Key }) => Key),
-        continuationToken: data.IsTruncated ? data.NextContinuationToken : undefined,
-    };
+    throw `unable to list keys with prefix ${prefix}: ${err}`;
+  }
+  if (!data.Contents) {
+    return { keys: [] };
+  }
+  return {
+    keys: data.Contents.map(({ Key }) => Key),
+    continuationToken: data.IsTruncated ? data.NextContinuationToken : undefined
+  };
 }
-export { getS3, hasFile, readFile, writeFile, deleteFile, getFileSize, listKeys };
+export {
+  writeFile,
+  readFile,
+  listKeys,
+  hasFile,
+  getS3,
+  getFileSize,
+  deleteFile
+};

package/dist/search.d.ts

@@ -3,4 +3,3 @@ type ElasticSearchRecord = {
 };
 export declare function sendToSearch(indexPrefix: string, record: ElasticSearchRecord, throws?: boolean): Promise<void>;
 export {};
-//# sourceMappingURL=search.d.ts.map

package/dist/search.js

@@ -1,30 +1,105 @@
-import { isProduction } from "./env";
-import { inline } from "./log";
+// src/env.ts
+function ensureAndGet(envName, defaultValue) {
+  return process.env[envName] || defaultValue;
+}
+function getEnvironment() {
+  return ensureAndGet("SKYNET_ENVIRONMENT", "dev");
+}
+function getEnvOrThrow(envName) {
+  if (!process.env[envName]) {
+    throw new Error(`Must set environment variable ${envName}`);
+  }
+  return process.env[envName];
+}
+function isProduction() {
+  return getEnvironment() === "prd";
+}
+function isDev() {
+  return getEnvironment() === "dev";
+}
+// src/log.ts
+function isObject(a) {
+  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}`;
+}
+function getLine(params) {
+  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();
+}
+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);
+    }
+  }
+};
+// src/search.ts
 import { Client, HttpConnection } from "@elastic/elasticsearch";
 import osModule from "os";
-export async function sendToSearch(indexPrefix, record, throws = false) {
-    if (!process.env["SKYNET_ELASTICSEARCH_CLOUD_ID"] || !process.env["SKYNET_ELASTICSEARCH_API_KEY"]) {
-        throw new Error("SKYNET_ELASTICSEARCH_CLOUD_ID or SKYNET_ELASTICSEARCH_API_KEY is not set");
-    }
-    const client = new Client({
-        cloud: { id: process.env["SKYNET_ELASTICSEARCH_CLOUD_ID"] },
-        auth: { apiKey: process.env["SKYNET_ELASTICSEARCH_API_KEY"] },
-        Connection: HttpConnection, // bun compatibility, see https://github.com/oven-sh/bun/issues/7920
+async function sendToSearch(indexPrefix, record, throws = false) {
+  if (!process.env["SKYNET_ELASTICSEARCH_CLOUD_ID"] || !process.env["SKYNET_ELASTICSEARCH_API_KEY"]) {
+    throw new Error("SKYNET_ELASTICSEARCH_CLOUD_ID or SKYNET_ELASTICSEARCH_API_KEY is not set");
+  }
+  const client = new Client({
+    cloud: { id: process.env["SKYNET_ELASTICSEARCH_CLOUD_ID"] },
+    auth: { apiKey: process.env["SKYNET_ELASTICSEARCH_API_KEY"] },
+    Connection: HttpConnection
+  });
+  const now = new Date;
+  const indexName = [indexPrefix, isProduction() ? "prod" : "dev", now.toISOString().slice(0, 7)].join("-");
+  try {
+    await client.index({
+      index: indexName,
+      document: { instance: osModule.hostname(), timestamp: now, record }
     });
-    const now = new Date();
-    const indexName = [indexPrefix, isProduction() ? "prod" : "dev", now.toISOString().slice(0, 7)].join("-");
-    // best as possible delivery
-    // by default not throw
-    try {
-        await client.index({
-            index: indexName,
-            document: { instance: osModule.hostname(), timestamp: now, record },
-        });
-    }
-    catch (err) {
-        inline.error(err);
-        if (throws) {
-            throw err;
-        }
+  } catch (err) {
+    inline.error(err);
+    if (throws) {
+      throw err;
     }
+  }
 }
+export {
+  sendToSearch
+};

package/dist/selector.d.ts

@@ -15,4 +15,3 @@ declare function getSelectorFlags<TSelector extends Selector>(selector: Selector
 declare function toSelectorString<TSelector extends Selector>(selectorFlags: SelectorFlags<TSelector>, delim?: string): string;
 declare function getJobName<TSelector extends Selector>(name: string, selectorFlags: SelectorFlags<TSelector>, mode?: string): string;
 export { getJobName, getSelectorDesc, getSelectorFlags, toSelectorString };
-//# sourceMappingURL=selector.d.ts.map