@totems/evm 1.0.5 → 1.0.8

package/contracts/ProxyMod.sol

@@ -0,0 +1,331 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+pragma solidity ^0.8.28;
+
+import "../mods/TotemMod.sol";
+import "../interfaces/ITotemTypes.sol";
+import {TotemsLibrary} from "../mods/TotemsLibrary.sol";
+import {IMarket} from "../interfaces/IMarket.sol";
+import {ITotems} from "../interfaces/ITotems.sol";
+import {ReentrancyGuard} from "./ReentrancyGuard.sol";
+import {Shared} from "./Shared.sol";
+
+
+contract ProxyMod is IModTransfer, IModMint, IModMinter, IModBurn, ReentrancyGuard {
+
+    // Can't use ModBase here because it's deployed BEFORE the totems contract,
+    // so need to re-roll some of that here.
+    receive() external payable {}
+    fallback() external payable {}
+    address payable private seller;
+    address public marketContract;
+    address public totemsContract;
+
+    mapping(bytes32 => mapping(ITotemTypes.Hook => mapping(address => bool))) internal isModEnabled;
+    mapping(bytes32 => ITotemTypes.TotemMods) internal totemMods;
+    bytes32[] public totemsWithMods;
+
+    function getSeller() external view returns (address payable) {
+        return seller != address(0) ? payable(address(seller)) : payable(address(this));
+    }
+
+    modifier onlyTotems() {
+        require(msg.sender == totemsContract, "Only Totems contract");
+        _;
+    }
+
+    constructor(address payable _seller) {
+        require(_seller != address(0), "Invalid seller address");
+        seller = _seller;
+    }
+
+    function initialize(
+        address _totemsContract,
+        address _marketContract
+    ) external {
+        require(msg.sender == seller, "Only seller can initialize");
+        require(totemsContract == address(0), "Already initialized");
+        require(_totemsContract != address(0), "Invalid totems contract");
+        require(_marketContract != address(0), "Invalid market contract");
+
+        totemsContract = _totemsContract;
+        marketContract = _marketContract;
+    }
+
+    // ========== Errors ==========
+    error CantUseCreatedHook();
+    error UnknownHook();
+    error ModNotEnabledForMint();
+    error InvalidAddressLength();
+    error InvalidHexCharacter();
+    error NoFeeRequired();
+
+    // ========== Managerial Functions ==========
+
+    function addMod(
+        string calldata ticker,
+        ITotemTypes.Hook[] calldata hooks,
+        address mod,
+        address payable referrer
+    ) external payable nonReentrant {
+        ITotems totems = ITotems(totemsContract);
+        IMarket market = IMarket(marketContract);
+
+        require(
+            totems.getTotem(ticker).creator == msg.sender,
+            "Only the totem creator can add mods"
+        );
+
+        bytes32 tickerBytes = TotemsLibrary.tickerToBytes(ticker);
+
+        if(!totems.isLicensed(ticker, mod)) {
+            uint256 modFee = market.getModFee(mod);
+            uint256 referrerFee = totems.getFee(referrer);
+            uint256 totalFee = modFee + referrerFee;
+            require(msg.value >= totalFee, "Insufficient fee");
+            totems.setLicenseFromProxy(tickerBytes, mod);
+
+            // Pay mod seller
+            ITotemTypes.Mod memory totemMod = market.getMod(mod);
+            if(modFee > 0) {
+                Shared.safeTransfer(totemMod.seller, modFee);
+            }
+
+            // Pay referrer (or burn if no referrer)
+            if(referrerFee > 0) {
+                address recipient = referrer != address(0) ? referrer : address(0);
+                Shared.safeTransfer(recipient, referrerFee);
+            }
+        } else {
+            if(msg.value > 0) revert NoFeeRequired();
+        }
+
+        for (uint256 i = 0; i < hooks.length; i++) {
+            ITotemTypes.Hook hook = hooks[i];
+
+            if (isModEnabled[tickerBytes][hook][mod]) {
+                continue;
+            }
+
+            isModEnabled[tickerBytes][hook][mod] = true;
+
+            _pushModToHook(tickerBytes, hook, mod);
+        }
+    }
+
+    function removeMod(
+        string calldata ticker,
+        address mod
+    ) external {
+        require(
+            TotemsLibrary.getCreator(totemsContract, ticker) == msg.sender,
+            "Only totem creator"
+        );
+
+        bytes32 tickerBytes = TotemsLibrary.tickerToBytes(ticker);
+
+        _removeFromHook(tickerBytes, ITotemTypes.Hook.Transfer, mod);
+        _removeFromHook(tickerBytes, ITotemTypes.Hook.Mint, mod);
+        _removeFromHook(tickerBytes, ITotemTypes.Hook.Burn, mod);
+        _removeFromHook(tickerBytes, ITotemTypes.Hook.Created, mod);
+    }
+
+
+    // ========== Mod Hook Functions ==========
+
+    function onTransfer(
+        string calldata ticker,
+        address from,
+        address to,
+        uint256 amount,
+        string calldata memo
+    ) external override onlyTotems {
+        TotemsLibrary.checkLicense(totemsContract, ticker);
+
+        bytes32 tickerBytes = TotemsLibrary.tickerToBytes(ticker);
+        address[] memory mods = totemMods[tickerBytes].transfer;
+        uint256 length = mods.length;
+
+        for (uint256 i = 0; i < length; i++) {
+            IModTransfer(mods[i]).onTransfer(
+                ticker,
+                from,
+                to,
+                amount,
+                memo
+            );
+        }
+    }
+
+    function onMint(
+        string calldata ticker,
+        address minter,
+        uint256 amount,
+        uint256 payment,
+        string calldata memo
+    ) external override onlyTotems {
+        TotemsLibrary.checkLicense(totemsContract, ticker);
+
+        bytes32 tickerBytes = TotemsLibrary.tickerToBytes(ticker);
+        address[] memory mods = totemMods[tickerBytes].mint;
+        uint256 length = mods.length;
+
+        for (uint256 i = 0; i < length; i++) {
+            IModMint(mods[i]).onMint(
+                ticker,
+                minter,
+                amount,
+                payment,
+                memo
+            );
+        }
+    }
+
+
+    function mint(
+        string calldata ticker,
+        address minter,
+        uint256 amount,
+        string calldata memo
+    ) external onlyTotems payable {
+        TotemsLibrary.checkLicense(totemsContract, ticker);
+
+        // This likely eliminates some use cases, but it's necessary to avoid
+        // ambiguity in which mod to use for minting when multiple are present,
+        // especially when payment is involved and to align with the core mint->mod logic.
+        address mod = _stringToAddress(memo);
+
+        bytes32 tickerBytes = TotemsLibrary.tickerToBytes(ticker);
+        if(!isModEnabled[tickerBytes][ITotemTypes.Hook.Mint][mod]) {
+            revert ModNotEnabledForMint();
+        }
+
+        IModMinter(mod).mint{value: msg.value}(
+            ticker,
+            minter,
+            amount,
+            memo
+        );
+    }
+
+    function onBurn(
+        string calldata ticker,
+        address owner,
+        uint256 amount,
+        string calldata memo
+    ) external override onlyTotems {
+        TotemsLibrary.checkLicense(totemsContract, ticker);
+
+        bytes32 tickerBytes = TotemsLibrary.tickerToBytes(ticker);
+        address[] memory mods = totemMods[tickerBytes].burn;
+        uint256 length = mods.length;
+
+        for (uint256 i = 0; i < length; i++) {
+            IModBurn(mods[i]).onBurn(
+                ticker,
+                owner,
+                amount,
+                memo
+            );
+        }
+    }
+
+
+
+
+
+
+
+    // ========== Internal Functions ==========
+
+    function _stringToAddress(string memory str) internal pure returns (address) {
+        bytes memory strBytes = bytes(str);
+        if(strBytes.length != 42){
+            revert InvalidAddressLength();
+        }
+
+        bytes memory addrBytes = new bytes(20);
+
+        for (uint i = 0; i < 20; i++) {
+            addrBytes[i] = bytes1(
+                _hexCharToByte(strBytes[2 + i * 2]) * 16 +
+                _hexCharToByte(strBytes[3 + i * 2])
+            );
+        }
+
+        address addr;
+        assembly {
+            addr := mload(add(addrBytes, 20))
+        }
+        return addr;
+    }
+
+    function _hexCharToByte(bytes1 char) internal pure returns (uint8) {
+        uint8 byteValue = uint8(char);
+        if (byteValue >= uint8(bytes1('0')) && byteValue <= uint8(bytes1('9'))) {
+            return byteValue - uint8(bytes1('0'));
+        } else if (byteValue >= uint8(bytes1('a')) && byteValue <= uint8(bytes1('f'))) {
+            return 10 + byteValue - uint8(bytes1('a'));
+        } else if (byteValue >= uint8(bytes1('A')) && byteValue <= uint8(bytes1('F'))) {
+            return 10 + byteValue - uint8(bytes1('A'));
+        }
+        revert InvalidHexCharacter();
+    }
+
+    function _pushModToHook(
+        bytes32 ticker,
+        ITotemTypes.Hook hook,
+        address mod
+    ) internal {
+        ITotemTypes.TotemMods storage mods = totemMods[ticker];
+
+        if (hook == ITotemTypes.Hook.Transfer) {
+            mods.transfer.push(mod);
+        } else if (hook == ITotemTypes.Hook.Mint) {
+            mods.mint.push(mod);
+        } else if (hook == ITotemTypes.Hook.Burn) {
+            mods.burn.push(mod);
+        } else if (hook == ITotemTypes.Hook.Created) {
+            revert CantUseCreatedHook();
+        } else {
+            revert UnknownHook();
+        }
+    }
+
+    function _removeFromHook(
+        bytes32 ticker,
+        ITotemTypes.Hook hook,
+        address mod
+    ) internal {
+        if (!isModEnabled[ticker][hook][mod]) {
+            return;
+        }
+
+        delete isModEnabled[ticker][hook][mod];
+        _removeModFromHookArray(ticker, hook, mod);
+    }
+
+    function _removeModFromHookArray(
+        bytes32 ticker,
+        ITotemTypes.Hook hook,
+        address mod
+    ) internal {
+        address[] storage arr;
+
+        if (hook == ITotemTypes.Hook.Transfer) arr = totemMods[ticker].transfer;
+        else if (hook == ITotemTypes.Hook.Mint) arr = totemMods[ticker].mint;
+        else if (hook == ITotemTypes.Hook.Burn) arr = totemMods[ticker].burn;
+        else if (hook == ITotemTypes.Hook.Created) arr = totemMods[ticker].created;
+        else revert("Invalid hook");
+
+        uint256 length = arr.length;
+        for (uint256 i = 0; i < length; i++) {
+            if (arr[i] == mod) {
+                arr[i] = arr[length - 1];
+                arr.pop();
+                break;
+            }
+        }
+    }
+
+
+}

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@totems/evm",
-  "version": "1.0.5",
+  "version": "1.0.8",
+  "type": "module",
   "description": "Totems EVM smart contracts for building modular token systems",
   "author": "nsjames",
   "license": "MIT & AGPL-3.0",
@@ -26,17 +27,9 @@
     "test/**/*"
   ],
   "exports": {
-    "./test/constants": {
-      "types": "./test/constants.d.ts",
-      "import": "./test/constants.js",
-      "require": "./test/constants.js",
-      "default": "./test/constants.js"
-    },
     "./test/helpers": {
       "types": "./test/helpers.d.ts",
-      "import": "./test/helpers.js",
-      "require": "./test/helpers.js",
-      "default": "./test/helpers.js"
+      "default": "./test/helpers.ts"
     },
     "./contracts/*": "./contracts/*",
     "./interfaces/*": "./interfaces/*",

package/test/helpers.d.ts

@@ -1,5 +1,4 @@
-export { ZERO_ADDRESS, MIN_BASE_FEE, BURNED_FEE, Hook } from "./constants.js";
-export type { HookType } from "./constants.js";
+export declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
 /**
  * Computes the 4-byte selector for a custom error signature
  * @param signature Error signature like "NotLicensed()" or "InsufficientBalance(uint256,uint256)"
@@ -26,6 +25,15 @@ export declare const ErrorSelectors: {
     InsufficientBalance: string;
     CantSetLicense: string;
 };
+export declare const MIN_BASE_FEE = 500000000000000n;
+export declare const BURNED_FEE = 100000000000000n;
+export declare const Hook: {
+    readonly Created: 0;
+    readonly Mint: 1;
+    readonly Burn: 2;
+    readonly Transfer: 3;
+    readonly TransferOwnership: 4;
+};
 export declare const setupTotemsTest: (minBaseFee?: bigint, burnedFee?: bigint) => Promise<{
     viem: any;
     publicClient: any;

package/test/helpers.ts

@@ -0,0 +1,467 @@
+import {network} from "hardhat";
+import { keccak256, toBytes, decodeErrorResult, Abi } from "viem";
+
+export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+
+/**
+ * Computes the 4-byte selector for a custom error signature
+ * @param signature Error signature like "NotLicensed()" or "InsufficientBalance(uint256,uint256)"
+ */
+export function errorSelector(signature: string): string {
+    return keccak256(toBytes(signature)).slice(0, 10); // 0x + 8 hex chars = 4 bytes
+}
+
+/**
+ * Extracts the error selector from a caught error's revert data
+ */
+function getErrorData(error: any): string | null {
+    // Try common paths where revert data might be
+    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;
+}
+
+/**
+ * Asserts that a promise rejects with a specific custom error
+ * @param promise The promise to test
+ * @param expectedSelector The expected error selector (use errorSelector() to compute)
+ * @param errorName Human-readable error name for assertion messages
+ */
+export async function expectCustomError(
+    promise: Promise<any>,
+    expectedSelector: string,
+    errorName: string
+): Promise<void> {
+    try {
+        await promise;
+        throw new Error(`Expected ${errorName} but transaction succeeded`);
+    } catch (e: any) {
+        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}`
+            );
+        }
+    }
+}
+
+/**
+ * Asserts that a promise rejects with a string revert message
+ * Error(string) selector is 0x08c379a0
+ */
+export async function expectRevertMessage(
+    promise: Promise<any>,
+    expectedMessage: string | RegExp
+): Promise<void> {
+    const ERROR_STRING_SELECTOR = "0x08c379a0";
+
+    try {
+        await promise;
+        throw new Error(`Expected revert with "${expectedMessage}" but transaction succeeded`);
+    } catch (e: any) {
+        if (e.message?.startsWith("Expected revert")) throw e;
+
+        const data = getErrorData(e);
+        if (!data) {
+            // Fallback to checking error message directly
+            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) {
+            // Not a string error, check if message is in the raw error
+            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;
+        }
+
+        // Decode the string from the ABI-encoded data
+        // Format: selector (4 bytes) + offset (32 bytes) + length (32 bytes) + string data
+        try {
+            const abi: Abi = [{
+                type: 'error',
+                name: 'Error',
+                inputs: [{ name: 'message', type: 'string' }]
+            }];
+            const decoded = decodeErrorResult({ abi, data: data as `0x${string}` });
+            const message = (decoded.args as string[])[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) {
+            // If decoding fails, fall back to checking error message
+            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}`);
+            }
+        }
+    }
+}
+
+// Pre-computed selectors for common errors
+export const ErrorSelectors = {
+    // TotemMod errors
+    InvalidModEventOrigin: errorSelector("InvalidModEventOrigin()"),
+    NotLicensed: errorSelector("NotLicensed()"),
+
+    // Totems errors
+    Unauthorized: errorSelector("Unauthorized()"),
+    TotemNotFound: errorSelector("TotemNotFound(string)"),
+    TotemNotActive: errorSelector("TotemNotActive()"),
+    InsufficientBalance: errorSelector("InsufficientBalance(uint256,uint256)"),
+    CantSetLicense: errorSelector("CantSetLicense()"),
+};
+
+export const MIN_BASE_FEE = 500000000000000n; // 0.0005 ether
+export const BURNED_FEE = 100000000000000n; // 0.0001 ether
+
+export const Hook = {
+    Created: 0,
+    Mint: 1,
+    Burn: 2,
+    Transfer: 3,
+    TransferOwnership: 4,
+} as const;
+
+export const setupTotemsTest = async (minBaseFee: bigint = MIN_BASE_FEE, burnedFee: bigint = BURNED_FEE) => {
+    const { viem } = await network.connect() as any;
+    const publicClient = await viem.getPublicClient();
+    // @ts-ignore
+    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:any = await viem.deployContract("Totems", [
+        market.address,
+        proxyMod.address,
+        minBaseFee,
+        burnedFee,
+    ]);
+
+
+    // using these to validate the interfaces
+    totems = await viem.getContractAt("ITotems", totems.address);
+    // @ts-ignore
+    market = await viem.getContractAt("IMarket", market.address);
+    // initialize proxy mod
+    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,
+    }
+
+}
+
+
+export const modDetails = (details?:any) => 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 || {});
+
+export const publishMod = async (
+    market:any,
+    seller:string,
+    contract:string,
+    hooks:number[] = [],
+    details = modDetails(),
+    requiredActions:any[] = [],
+    referrer = ZERO_ADDRESS,
+    price = 1_000_000n,
+    fee = undefined
+) => {
+    fee = fee ?? await market.read.getFee([referrer]);
+
+    return market.write.publish([
+        contract,
+        hooks,
+        price,
+        details,
+        requiredActions,
+        referrer,
+    ], { value: fee, account: seller });
+}
+
+export const totemDetails = (ticker:string, decimals:number) => {
+    return {
+        ticker: ticker,
+        decimals: 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',
+    };
+}
+
+export const createTotem = async (
+    totems:any,
+    market:any,
+    creator:string,
+    ticker:string,
+    decimals:number,
+    allocations:any[],
+    mods?:{
+        transfer?:string[],
+        mint?:string[],
+        burn?:string[],
+        created?:string[],
+        transferOwnership?:string[]
+    },
+    referrer:string = ZERO_ADDRESS,
+    details:any = undefined,
+) => {
+    const baseFee = await totems.read.getFee([referrer]);
+
+    const _mods = Object.assign({
+        transfer: [],
+        mint: [],
+        burn: [],
+        created: [],
+        transferOwnership: [],
+    }, mods || {});
+    const uniqueMods = new Set<string>();
+    Object.values(_mods).forEach((modList:any[]) => {
+        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 });
+}
+
+export const transfer = async (
+    totems:any,
+    ticker:string,
+    from:string,
+    to:string,
+    amount:number|bigint,
+    memo:string = "",
+) => {
+    return await totems.write.transfer([
+        ticker,
+        from,
+        to,
+        amount,
+        memo,
+    ], { account: from });
+}
+
+export const mint = async (
+    totems:any,
+    mod:string,
+    minter:string,
+    ticker:string,
+    amount:number|bigint,
+    memo:string = "",
+    payment:number|bigint = 0n,
+) => {
+    return await totems.write.mint([
+        mod,
+        minter,
+        ticker,
+        amount,
+        memo,
+    ], { account: minter, value: payment });
+}
+
+export const burn = async (
+    totems:any,
+    ticker:string,
+    owner:string,
+    amount:number|bigint,
+    memo:string = "",
+) => {
+    return await totems.write.burn([
+        ticker,
+        owner,
+        amount,
+        memo,
+    ], { account: owner });
+}
+
+export const getBalance = async (
+    totems:any,
+    ticker:string,
+    account:string,
+) => {
+    return await totems.read.getBalance([ticker, account]);
+}
+
+export const getTotem = async (
+    totems:any,
+    ticker:string,
+) => {
+    return await totems.read.getTotem([ticker]);
+}
+
+export const getTotems = async (
+    totems:any,
+    tickers:string[],
+) => {
+    return await totems.read.getTotems([tickers]);
+}
+
+export const getStats = async (
+    totems:any,
+    ticker:string,
+) => {
+    return await totems.read.getStats([ticker]);
+}
+
+export const transferOwnership = async (
+    totems:any,
+    ticker:string,
+    currentOwner:string,
+    newOwner:string,
+) => {
+    return await totems.write.transferOwnership([
+        ticker,
+        newOwner,
+    ], { account: currentOwner });
+}
+
+export const getMod = async (
+    market:any,
+    mod:string,
+) => {
+    return await market.read.getMod([mod]);
+}
+
+export const getMods = async (
+    market:any,
+    mods:string[],
+) => {
+    return await market.read.getMods([mods]);
+}
+
+export const getModFee = async (
+    market:any,
+    mod:string,
+) => {
+    return await market.read.getModFee([mod]);
+}
+
+export const getModsFee = async (
+    market:any,
+    mods:string[],
+) => {
+    return await market.read.getModsFee([mods]);
+}
+
+export const isLicensed = async (
+    totems:any,
+    ticker:string,
+    mod:string,
+) => {
+    return await totems.read.isLicensed([ticker, mod]);
+}
+
+export const getRelays = async (
+    totems:any,
+    ticker:string,
+) => {
+    return await totems.read.getRelays([ticker]);
+}
+
+export const getSupportedHooks = async (
+    market:any,
+    mod:string,
+) => {
+    return await market.read.getSupportedHooks([mod]);
+}
+
+export const isUnlimitedMinter = async (
+    market:any,
+    mod:string,
+) => {
+    return await market.read.isUnlimitedMinter([mod]);
+}
+
+export const addMod = async (
+    proxyMod:any,
+    totems:any,
+    market:any,
+    ticker:string,
+    hooks:number[],
+    mod:string,
+    caller:string,
+    referrer:string = 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 });
+}
+
+export const removeMod = async (
+    proxyMod:any,
+    ticker:string,
+    mod:string,
+    caller:string,
+) => {
+    return await proxyMod.write.removeMod([
+        ticker,
+        mod,
+    ], { account: caller });
+}

package/test/constants.d.ts

@@ -1,11 +0,0 @@
-export declare const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-export declare const MIN_BASE_FEE = 500000000000000n;
-export declare const BURNED_FEE = 100000000000000n;
-export declare const Hook: {
-    readonly Created: 0;
-    readonly Mint: 1;
-    readonly Burn: 2;
-    readonly Transfer: 3;
-    readonly TransferOwnership: 4;
-};
-export type HookType = typeof Hook[keyof typeof Hook];

package/test/constants.js

@@ -1,17 +0,0 @@
-// test/constants.ts
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-var MIN_BASE_FEE = 500000000000000n;
-var BURNED_FEE = 100000000000000n;
-var Hook = {
-  Created: 0,
-  Mint: 1,
-  Burn: 2,
-  Transfer: 3,
-  TransferOwnership: 4
-};
-export {
-  ZERO_ADDRESS,
-  MIN_BASE_FEE,
-  Hook,
-  BURNED_FEE
-};

package/test/helpers.js

@@ -1,300 +0,0 @@
-// test/helpers.ts
-import {network} from "hardhat";
-import {keccak256, toBytes, decodeErrorResult} from "viem";
-
-// test/constants.ts
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-var MIN_BASE_FEE = 500000000000000n;
-var BURNED_FEE = 100000000000000n;
-var Hook = {
-  Created: 0,
-  Mint: 1,
-  Burn: 2,
-  Transfer: 3,
-  TransferOwnership: 4
-};
-// test/helpers.ts
-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 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 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
-};