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

To install dependencies:

// 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
import { createPublicClient, erc20Abi, http } from "viem";
async function getAmountToApprove(tokenAddress, holderAddress, spenderAddress, amountToSpend, chain) {
  const publicClient = createPublicClient({
    chain,
    transport: http()
  });
  const allowance = await publicClient.readContract({
    address: tokenAddress,
    abi: 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];
};
export {
  BrianExecutionEngine,
  Solver,
  calculateSimilarity,
  getAmountToApprove,
  levenshteinDistance
};