@certik/skynet 0.25.0 → 0.25.2

package/dist/log.d.ts

@@ -0,0 +1,13 @@
+declare function print(o: unknown): string;
+declare function getLine(params: unknown[]): string;
+declare const inline: {
+    debug: (...args: unknown[]) => void;
+    log: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};
+declare const logger: {
+    debug: (...args: unknown[]) => void;
+    log: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+};
+export { print, getLine, inline, logger };

package/dist/log.js

@@ -0,0 +1,63 @@
+// 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);
+    }
+  }
+};
+export {
+  print,
+  logger,
+  inline,
+  getLine
+};

package/dist/object-hash.d.ts

@@ -0,0 +1 @@
+export declare function getHash(obj: unknown): string;

package/dist/object-hash.js

@@ -0,0 +1,61 @@
+// src/object-hash.ts
+import xh from "@node-rs/xxhash";
+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}`);
+  }
+}
+function arrayHash(array, xxh3) {
+  xxh3.update("[");
+  for (const obj of array) {
+    hash(obj, xxh3);
+  }
+  xxh3.update("]");
+}
+function setHash(_set, _xxh3) {
+  throw new Error("Set hashing not implemented");
+}
+function mapHash(map, 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);
+  }
+}
+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);
+  }
+}
+export {
+  getHash
+};

package/dist/por.d.ts

@@ -0,0 +1,37 @@
+export interface UserLiability {
+    userHash: string;
+    balance: number;
+    token?: string;
+}
+export interface MerkleProof {
+    userHash: string;
+    balance: number;
+    token?: string;
+    proof: string[];
+    positions: ("left" | "right")[];
+    rootHash: string;
+    leafIndex: number;
+    hashFunction?: (data: string) => string;
+}
+export interface MerkleNode {
+    hash: string;
+    left?: MerkleNode;
+    right?: MerkleNode;
+    data?: UserLiability;
+}
+export declare class MerkleTreePoR {
+    private leaves;
+    private tree;
+    private userMap;
+    private userData;
+    private hashFunction;
+    constructor(users: UserLiability[], hashFunction?: (data: string) => string);
+    private static defaultSHA256Hash;
+    private defaultSHA256Hash;
+    private hash;
+    private createLeafHash;
+    private buildTree;
+    getRootHash(): string;
+    generateProof(userHash: string, token?: string): MerkleProof;
+    static verifyProof(merkleProof: MerkleProof): boolean;
+}

package/dist/por.js

@@ -0,0 +1,120 @@
+// @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");
+    }
+    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
+        });
+      }
+      currentLevel = nextLevel;
+      this.tree.push(nextLevelNodes);
+    }
+  }
+  getRootHash() {
+    if (this.tree.length === 0) {
+      throw new Error("Merkle tree not built");
+    }
+    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}`);
+    }
+    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);
+    }
+    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

@@ -0,0 +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 | null | undefined>;
+declare function hasFile(bucketName: string, key: string): Promise<boolean>;
+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<null | undefined>;
+declare function listKeys(bucketName: string, prefix?: string, continuationToken?: string): Promise<{
+    keys: never[];
+    continuationToken?: undefined;
+} | {
+    keys: (string | undefined)[];
+    continuationToken: string | undefined;
+} | null>;
+export { getS3, hasFile, readFile, writeFile, deleteFile, getFileSize, listKeys };

package/dist/s3.js

@@ -0,0 +1,122 @@
+// 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;
+}
+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);
+      }
+      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;
+  }
+}
+async function getFileSize(bucketName, key) {
+  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;
+  }
+  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);
+      }
+      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: [] };
+  }
+  return {
+    keys: data.Contents.map(({ Key }) => Key),
+    continuationToken: data.IsTruncated ? data.NextContinuationToken : undefined
+  };
+}
+export {
+  writeFile,
+  readFile,
+  listKeys,
+  hasFile,
+  getS3,
+  getFileSize,
+  deleteFile
+};

package/dist/search.d.ts

@@ -0,0 +1,5 @@
+type ElasticSearchRecord = {
+    [key: string]: unknown;
+};
+export declare function sendToSearch(indexPrefix: string, record: ElasticSearchRecord, throws?: boolean): Promise<void>;
+export {};

package/dist/search.js

@@ -0,0 +1,105 @@
+// 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";
+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 }
+    });
+  } catch (err) {
+    inline.error(err);
+    if (throws) {
+      throw err;
+    }
+  }
+}
+export {
+  sendToSearch
+};

package/dist/selector.d.ts

@@ -0,0 +1,17 @@
+import type { Flag, Result } from "meow";
+type StringFlag = Flag<"string", string> | Flag<"string", string[], true>;
+type BooleanFlag = Flag<"boolean", boolean> | Flag<"boolean", boolean[], true>;
+type NumberFlag = Flag<"number", number> | Flag<"number", number[], true>;
+type AnyFlag = StringFlag | BooleanFlag | NumberFlag;
+export type Selector = Record<string, AnyFlag & {
+    desc?: string;
+    description?: string;
+    optional?: boolean;
+    aliases?: string[];
+}>;
+export type SelectorFlags<TSelector extends Selector> = Result<TSelector>["flags"];
+declare function getSelectorDesc(selector: Selector): string;
+declare function getSelectorFlags<TSelector extends Selector>(selector: Selector): TSelector;
+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 };

package/dist/selector.js

@@ -0,0 +1,44 @@
+// src/selector.ts
+function getSelectorDesc(selector) {
+  return Object.keys(selector).map((name) => {
+    return `          --${name.padEnd(14)}${selector[name].desc || selector[name].description || ""}`;
+  }).join(`
+`);
+}
+function getSelectorFlags(selector) {
+  return Object.keys(selector).reduce((acc, name) => {
+    const flag = {
+      type: selector[name].type || "string",
+      ...selector[name]
+    };
+    if (!selector[name].optional && selector[name].isRequired !== false) {
+      flag.isRequired = true;
+    }
+    return { ...acc, [name]: flag };
+  }, {});
+}
+function toSelectorString(selectorFlags, delim = ",") {
+  return Object.keys(selectorFlags).sort().map((flag) => {
+    return `${flag}=${selectorFlags[flag]}`;
+  }).join(delim);
+}
+function normalizeSelectorValue(v) {
+  return v.replace(/[^A-Za-z0-9]+/g, "-");
+}
+function getJobName(name, selectorFlags, mode) {
+  const selectorNamePart = Object.keys(selectorFlags).sort().map((name2) => selectorFlags[name2]).join("-");
+  let jobName = name;
+  if (mode) {
+    jobName += `-${mode}`;
+  }
+  if (selectorNamePart.length > 0) {
+    jobName += `-${normalizeSelectorValue(selectorNamePart)}`;
+  }
+  return jobName;
+}
+export {
+  toSelectorString,
+  getSelectorFlags,
+  getSelectorDesc,
+  getJobName
+};

package/dist/slack.d.ts

@@ -0,0 +1,14 @@
+import type { ChatPostMessageArguments } from "@slack/web-api";
+declare function postMessageToConversation({ conversationId, message, token, verbose, }: {
+    conversationId: string;
+    message: string;
+    token?: string;
+    verbose?: boolean;
+} | {
+    conversationId?: undefined;
+    message: ChatPostMessageArguments;
+    token?: string;
+    verbose?: boolean;
+}): Promise<void>;
+export { postMessageToConversation };
+export type { ChatPostMessageArguments };

package/dist/slack.js

@@ -0,0 +1,29 @@
+// src/slack.ts
+import { WebClient } from "@slack/web-api";
+function getClient(token) {
+  return new WebClient(token);
+}
+async function postMessageToConversation({
+  conversationId,
+  message,
+  token,
+  verbose
+}) {
+  if (!token) {
+    throw new Error("missing slack token");
+  }
+  try {
+    const client = getClient(token);
+    const post = typeof conversationId === "string" ? { channel: conversationId, text: message } : message;
+    if (verbose) {
+      console.log(`posting to slack:`, JSON.stringify(post, null, 2));
+    }
+    await client.chat.postMessage(post);
+  } catch (error) {
+    console.error("failed to post slack message", error);
+    throw error;
+  }
+}
+export {
+  postMessageToConversation
+};

package/dist/util.d.ts

@@ -0,0 +1,4 @@
+declare function range(startAt: number, endAt: number, step: number): [number, number][];
+declare function arrayGroup<T>(array: T[], groupSize: number): T[][];
+declare function fillRange(start: number, end: number): number[];
+export { arrayGroup, range, fillRange };

package/dist/util.js

@@ -0,0 +1,27 @@
+// src/util.ts
+function range(startAt, endAt, step) {
+  const arr = [];
+  for (let i = startAt;i <= endAt; i += step) {
+    arr.push([i, Math.min(endAt, i + step - 1)]);
+  }
+  return arr;
+}
+function arrayGroup(array, groupSize) {
+  const groups = [];
+  for (let i = 0;i < array.length; i += groupSize) {
+    groups.push(array.slice(i, i + groupSize));
+  }
+  return groups;
+}
+function fillRange(start, end) {
+  const result = [];
+  for (let i = start;i <= end; i++) {
+    result.push(i);
+  }
+  return result;
+}
+export {
+  range,
+  fillRange,
+  arrayGroup
+};