@brian-ai/ee-core/dist/index.cjs

To install dependencies:

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var index_exports = {};
__export(index_exports, {
  BrianExecutionEngine: () => BrianExecutionEngine,
  Solver: () => Solver,
  calculateSimilarity: () => calculateSimilarity,
  getAmountToApprove: () => getAmountToApprove,
  levenshteinDistance: () => levenshteinDistance
});
module.exports = __toCommonJS(index_exports);

// src/engine.ts
var BrianExecutionEngine = class {
  solversMap;
  constructor(solversMap) {
    this.solversMap = solversMap;
  }
  getSolversMap() {
    return this.solversMap;
  }
  setSolversMap(solversMap) {
    this.solversMap = solversMap;
  }
  addSolver(solver, action) {
    this.solversMap[action].push(solver);
  }
  removeSolver(solver, action) {
    this.solversMap[action] = this.solversMap[action].filter(
      (s) => s.name !== solver.name
    );
  }
  async execute(action, data, allowedSolvers = []) {
    const solvers = this.solversMap[action];
    const solversToExecute = allowedSolvers.length > 0 ? solvers.filter((s) => allowedSolvers.includes(s.name)) : solvers;
    const results = await Promise.allSettled(
      solversToExecute.map((solver) => solver.execute(action, data))
    );
    const fulfilledResults = results.filter((item) => item.status === "fulfilled").map((item) => item.value);
    const rejectedResults = results.filter((item) => item.status === "rejected").map((item) => item.reason);
    console.log("[execution engine] fulfilled results", fulfilledResults);
    console.log("[execution engine] rejected results", rejectedResults);
    return fulfilledResults;
  }
};

// src/solver.ts
var Solver = class {
  name;
  allowedChains;
  constructor(name, allowedChains) {
    this.name = name;
    this.allowedChains = allowedChains;
  }
};

// src/utils/approve.ts
var import_viem = require("viem");
async function getAmountToApprove(tokenAddress, holderAddress, spenderAddress, amountToSpend, chain) {
  const publicClient = (0, import_viem.createPublicClient)({
    chain,
    transport: (0, import_viem.http)()
  });
  const allowance = await publicClient.readContract({
    address: tokenAddress,
    abi: import_viem.erc20Abi,
    functionName: "allowance",
    args: [holderAddress, spenderAddress]
  });
  return allowance >= amountToSpend ? BigInt(0) : amountToSpend;
}

// src/utils/similarity.ts
var calculateSimilarity = (str1, str2) => {
  const s1 = str1.toLowerCase();
  const s2 = str2.toLowerCase();
  const base1 = s1.replace(/[-_]?v?\d+$/g, "").replace(/[^a-z0-9]/g, "");
  const base2 = s2.replace(/[-_]?v?\d+$/g, "").replace(/[^a-z0-9]/g, "");
  if (base2.includes(base1) || base1.includes(base2)) {
    return 0.9;
  }
  const distance = levenshteinDistance(base1, base2);
  const maxLength = Math.max(base1.length, base2.length);
  const similarity = 1 - distance / maxLength;
  return similarity;
};
var levenshteinDistance = (str1, str2) => {
  const matrix = [];
  for (let i = 0; i <= str1.length; i++) {
    matrix[i] = [i];
  }
  for (let j = 0; j <= str2.length; j++) {
    matrix[0][j] = j;
  }
  for (let i = 1; i <= str1.length; i++) {
    for (let j = 1; j <= str2.length; j++) {
      if (str1[i - 1] === str2[j - 1]) {
        matrix[i][j] = matrix[i - 1][j - 1];
      } else {
        matrix[i][j] = Math.min(
          matrix[i - 1][j - 1] + 1,
          // substitution
          matrix[i][j - 1] + 1,
          // insertion
          matrix[i - 1][j] + 1
          // deletion
        );
      }
    }
  }
  return matrix[str1.length][str2.length];
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  BrianExecutionEngine,
  Solver,
  calculateSimilarity,
  getAmountToApprove,
  levenshteinDistance
});