@totems/evm 1.0.7 → 1.0.9

package/test/helpers.js

@@ -1,297 +0,0 @@
-// test/helpers.ts
-import {network} from "hardhat";
-import {keccak256, toBytes, decodeErrorResult} from "viem";
-function errorSelector(signature) {
-  return keccak256(toBytes(signature)).slice(0, 10);
-}
-var getErrorData = function(error) {
-  const data = error?.cause?.cause?.data || error?.cause?.data || error?.data || error?.message?.match(/return data: (0x[a-fA-F0-9]+)/)?.[1] || error?.message?.match(/data: (0x[a-fA-F0-9]+)/)?.[1];
-  return data || null;
-};
-async function expectCustomError(promise, expectedSelector, errorName) {
-  try {
-    await promise;
-    throw new Error(`Expected ${errorName} but transaction succeeded`);
-  } catch (e) {
-    if (e.message?.startsWith(`Expected ${errorName}`))
-      throw e;
-    const data = getErrorData(e);
-    if (!data) {
-      throw new Error(`Expected ${errorName} but got error without revert data: ${e.message}`);
-    }
-    const actualSelector = data.slice(0, 10).toLowerCase();
-    const expected = expectedSelector.toLowerCase();
-    if (actualSelector !== expected) {
-      throw new Error(`Expected ${errorName} (${expected}) but got selector ${actualSelector}\nFull data: ${data}`);
-    }
-  }
-}
-async function expectRevertMessage(promise, expectedMessage) {
-  const ERROR_STRING_SELECTOR = "0x08c379a0";
-  try {
-    await promise;
-    throw new Error(`Expected revert with "${expectedMessage}" but transaction succeeded`);
-  } catch (e) {
-    if (e.message?.startsWith("Expected revert"))
-      throw e;
-    const data = getErrorData(e);
-    if (!data) {
-      const matches = typeof expectedMessage === "string" ? e.message?.includes(expectedMessage) : expectedMessage.test(e.message);
-      if (!matches) {
-        throw new Error(`Expected revert with "${expectedMessage}" but got: ${e.message}`);
-      }
-      return;
-    }
-    const selector = data.slice(0, 10).toLowerCase();
-    if (selector !== ERROR_STRING_SELECTOR) {
-      const matches = typeof expectedMessage === "string" ? e.message?.includes(expectedMessage) : expectedMessage.test(e.message);
-      if (!matches) {
-        throw new Error(`Expected string revert but got custom error with selector ${selector}`);
-      }
-      return;
-    }
-    try {
-      const abi = [{
-        type: "error",
-        name: "Error",
-        inputs: [{ name: "message", type: "string" }]
-      }];
-      const decoded = decodeErrorResult({ abi, data });
-      const message = decoded.args[0];
-      const matches = typeof expectedMessage === "string" ? message.includes(expectedMessage) : expectedMessage.test(message);
-      if (!matches) {
-        throw new Error(`Expected revert with "${expectedMessage}" but got "${message}"`);
-      }
-    } catch (decodeError) {
-      const matches = typeof expectedMessage === "string" ? e.message?.includes(expectedMessage) : expectedMessage.test(e.message);
-      if (!matches) {
-        throw new Error(`Expected revert with "${expectedMessage}" but decoding failed: ${e.message}`);
-      }
-    }
-  }
-}
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-var ErrorSelectors = {
-  InvalidModEventOrigin: errorSelector("InvalidModEventOrigin()"),
-  NotLicensed: errorSelector("NotLicensed()"),
-  Unauthorized: errorSelector("Unauthorized()"),
-  TotemNotFound: errorSelector("TotemNotFound(string)"),
-  TotemNotActive: errorSelector("TotemNotActive()"),
-  InsufficientBalance: errorSelector("InsufficientBalance(uint256,uint256)"),
-  CantSetLicense: errorSelector("CantSetLicense()")
-};
-var MIN_BASE_FEE = 500000000000000n;
-var BURNED_FEE = 100000000000000n;
-var Hook = {
-  Created: 0,
-  Mint: 1,
-  Burn: 2,
-  Transfer: 3,
-  TransferOwnership: 4
-};
-var setupTotemsTest = async (minBaseFee = MIN_BASE_FEE, burnedFee = BURNED_FEE) => {
-  const { viem } = await network.connect();
-  const publicClient = await viem.getPublicClient();
-  const walletClient = await viem.getWalletClient();
-  const addresses = await walletClient.getAddresses();
-  const proxyModInitializer = addresses[0];
-  const proxyMod = await viem.deployContract("ProxyMod", [
-    proxyModInitializer
-  ]);
-  let market = await viem.deployContract("ModMarket", [minBaseFee, burnedFee]);
-  let totems = await viem.deployContract("Totems", [
-    market.address,
-    proxyMod.address,
-    minBaseFee,
-    burnedFee
-  ]);
-  totems = await viem.getContractAt("ITotems", totems.address);
-  market = await viem.getContractAt("IMarket", market.address);
-  await proxyMod.write.initialize([totems.address, market.address], { account: proxyModInitializer });
-  return {
-    viem,
-    publicClient,
-    market,
-    totems,
-    accounts: addresses.slice(0, addresses.length),
-    proxyModSeller: addresses[0],
-    proxyMod
-  };
-};
-var modDetails = (details) => Object.assign({
-  name: "Test Mod",
-  summary: "A test mod",
-  markdown: "## Test Mod\nThis is a test mod.",
-  image: "https://example.com/image.png",
-  website: "https://example.com",
-  websiteTickerPath: "/path/to/{ticker}",
-  isMinter: false,
-  needsUnlimited: false
-}, details || {});
-var publishMod = async (market, seller, contract, hooks = [], details = modDetails(), requiredActions = [], referrer = ZERO_ADDRESS, price = 1000000n, fee = undefined) => {
-  fee = fee ?? await market.read.getFee([referrer]);
-  return market.write.publish([
-    contract,
-    hooks,
-    price,
-    details,
-    requiredActions,
-    referrer
-  ], { value: fee, account: seller });
-};
-var totemDetails = (ticker, decimals) => {
-  return {
-    ticker,
-    decimals,
-    name: `${ticker} Totem`,
-    description: `This is the ${ticker} totem.`,
-    image: `https://example.com/${ticker.toLowerCase()}.png`,
-    website: `https://example.com/${ticker.toLowerCase()}`,
-    seed: "0x1110762033e7a10db4502359a19a61eb81312834769b8419047a2c9ae03ee847"
-  };
-};
-var createTotem = async (totems, market, creator, ticker, decimals, allocations, mods, referrer = ZERO_ADDRESS, details = undefined) => {
-  const baseFee = await totems.read.getFee([referrer]);
-  const _mods = Object.assign({
-    transfer: [],
-    mint: [],
-    burn: [],
-    created: [],
-    transferOwnership: []
-  }, mods || {});
-  const uniqueMods = new Set;
-  Object.values(_mods).forEach((modList) => {
-    modList.forEach((m) => uniqueMods.add(m));
-  });
-  const modsFee = await market.read.getModsFee([[...uniqueMods]]);
-  return await totems.write.create([
-    details ? Object.assign({
-      ticker,
-      decimals
-    }, details) : totemDetails(ticker, decimals),
-    allocations.map((a) => ({
-      ...a,
-      label: a.label || "",
-      isMinter: a.hasOwnProperty("isMinter") ? a.isMinter : false
-    })),
-    _mods,
-    referrer
-  ], { account: creator, value: baseFee + modsFee });
-};
-var transfer = async (totems, ticker, from, to, amount, memo = "") => {
-  return await totems.write.transfer([
-    ticker,
-    from,
-    to,
-    amount,
-    memo
-  ], { account: from });
-};
-var mint = async (totems, mod, minter, ticker, amount, memo = "", payment = 0n) => {
-  return await totems.write.mint([
-    mod,
-    minter,
-    ticker,
-    amount,
-    memo
-  ], { account: minter, value: payment });
-};
-var burn = async (totems, ticker, owner, amount, memo = "") => {
-  return await totems.write.burn([
-    ticker,
-    owner,
-    amount,
-    memo
-  ], { account: owner });
-};
-var getBalance = async (totems, ticker, account) => {
-  return await totems.read.getBalance([ticker, account]);
-};
-var getTotem = async (totems, ticker) => {
-  return await totems.read.getTotem([ticker]);
-};
-var getTotems = async (totems, tickers) => {
-  return await totems.read.getTotems([tickers]);
-};
-var getStats = async (totems, ticker) => {
-  return await totems.read.getStats([ticker]);
-};
-var transferOwnership = async (totems, ticker, currentOwner, newOwner) => {
-  return await totems.write.transferOwnership([
-    ticker,
-    newOwner
-  ], { account: currentOwner });
-};
-var getMod = async (market, mod) => {
-  return await market.read.getMod([mod]);
-};
-var getMods = async (market, mods) => {
-  return await market.read.getMods([mods]);
-};
-var getModFee = async (market, mod) => {
-  return await market.read.getModFee([mod]);
-};
-var getModsFee = async (market, mods) => {
-  return await market.read.getModsFee([mods]);
-};
-var isLicensed = async (totems, ticker, mod) => {
-  return await totems.read.isLicensed([ticker, mod]);
-};
-var getRelays = async (totems, ticker) => {
-  return await totems.read.getRelays([ticker]);
-};
-var getSupportedHooks = async (market, mod) => {
-  return await market.read.getSupportedHooks([mod]);
-};
-var isUnlimitedMinter = async (market, mod) => {
-  return await market.read.isUnlimitedMinter([mod]);
-};
-var addMod = async (proxyMod, totems, market, ticker, hooks, mod, caller, referrer = ZERO_ADDRESS) => {
-  const modFee = await market.read.getModFee([mod]);
-  const referrerFee = await totems.read.getFee([referrer]);
-  return await proxyMod.write.addMod([
-    ticker,
-    hooks,
-    mod,
-    referrer
-  ], { account: caller, value: modFee + referrerFee });
-};
-var removeMod = async (proxyMod, ticker, mod, caller) => {
-  return await proxyMod.write.removeMod([
-    ticker,
-    mod
-  ], { account: caller });
-};
-export {
-  transferOwnership,
-  transfer,
-  totemDetails,
-  setupTotemsTest,
-  removeMod,
-  publishMod,
-  modDetails,
-  mint,
-  isUnlimitedMinter,
-  isLicensed,
-  getTotems,
-  getTotem,
-  getSupportedHooks,
-  getStats,
-  getRelays,
-  getModsFee,
-  getMods,
-  getModFee,
-  getMod,
-  getBalance,
-  expectRevertMessage,
-  expectCustomError,
-  errorSelector,
-  createTotem,
-  burn,
-  addMod,
-  ZERO_ADDRESS,
-  MIN_BASE_FEE,
-  Hook,
-  ErrorSelectors,
-  BURNED_FEE
-};