@totems/evm 1.0.2 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totems/evm",
-  "version": "1.0.2",
+  "version": "1.0.5",
   "description": "Totems EVM smart contracts for building modular token systems",
   "author": "nsjames",
   "license": "MIT & AGPL-3.0",
@@ -21,15 +21,29 @@
   ],
   "files": [
     "contracts/**/*.sol",
-    "constants/**/*.sol",
     "interfaces/**/*.sol",
     "mods/**/*.sol",
-    "test/**/*",
-    "LICENSE",
-    "package.json",
-    "README.md"
+    "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"
+    },
+    "./contracts/*": "./contracts/*",
+    "./interfaces/*": "./interfaces/*",
+    "./mods/*": "./mods/*"
+  },
   "peerDependencies": {
-    "@openzeppelin/contracts": "^5.0.0"
+    "hardhat": "^3.1.4",
+    "viem": "^2.44.4"
   }
 }

package/test/constants.d.ts

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,17 @@
+// 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.d.ts

@@ -0,0 +1,73 @@
+export { ZERO_ADDRESS, MIN_BASE_FEE, BURNED_FEE, Hook } from "./constants.js";
+export type { HookType } from "./constants.js";
+/**
+ * Computes the 4-byte selector for a custom error signature
+ * @param signature Error signature like "NotLicensed()" or "InsufficientBalance(uint256,uint256)"
+ */
+export declare function errorSelector(signature: string): string;
+/**
+ * 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 declare function expectCustomError(promise: Promise<any>, expectedSelector: string, errorName: string): Promise<void>;
+/**
+ * Asserts that a promise rejects with a string revert message
+ * Error(string) selector is 0x08c379a0
+ */
+export declare function expectRevertMessage(promise: Promise<any>, expectedMessage: string | RegExp): Promise<void>;
+export declare const ErrorSelectors: {
+    InvalidModEventOrigin: string;
+    NotLicensed: string;
+    Unauthorized: string;
+    TotemNotFound: string;
+    TotemNotActive: string;
+    InsufficientBalance: string;
+    CantSetLicense: string;
+};
+export declare const setupTotemsTest: (minBaseFee?: bigint, burnedFee?: bigint) => Promise<{
+    viem: any;
+    publicClient: any;
+    market: any;
+    totems: any;
+    accounts: any;
+    proxyModSeller: any;
+    proxyMod: any;
+}>;
+export declare const modDetails: (details?: any) => any;
+export declare const publishMod: (market: any, seller: string, contract: string, hooks?: number[], details?: any, requiredActions?: any[], referrer?: string, price?: bigint, fee?: undefined) => Promise<any>;
+export declare const totemDetails: (ticker: string, decimals: number) => {
+    ticker: string;
+    decimals: number;
+    name: string;
+    description: string;
+    image: string;
+    website: string;
+    seed: string;
+};
+export declare const createTotem: (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, details?: any) => Promise<any>;
+export declare const transfer: (totems: any, ticker: string, from: string, to: string, amount: number | bigint, memo?: string) => Promise<any>;
+export declare const mint: (totems: any, mod: string, minter: string, ticker: string, amount: number | bigint, memo?: string, payment?: number | bigint) => Promise<any>;
+export declare const burn: (totems: any, ticker: string, owner: string, amount: number | bigint, memo?: string) => Promise<any>;
+export declare const getBalance: (totems: any, ticker: string, account: string) => Promise<any>;
+export declare const getTotem: (totems: any, ticker: string) => Promise<any>;
+export declare const getTotems: (totems: any, tickers: string[]) => Promise<any>;
+export declare const getStats: (totems: any, ticker: string) => Promise<any>;
+export declare const transferOwnership: (totems: any, ticker: string, currentOwner: string, newOwner: string) => Promise<any>;
+export declare const getMod: (market: any, mod: string) => Promise<any>;
+export declare const getMods: (market: any, mods: string[]) => Promise<any>;
+export declare const getModFee: (market: any, mod: string) => Promise<any>;
+export declare const getModsFee: (market: any, mods: string[]) => Promise<any>;
+export declare const isLicensed: (totems: any, ticker: string, mod: string) => Promise<any>;
+export declare const getRelays: (totems: any, ticker: string) => Promise<any>;
+export declare const getSupportedHooks: (market: any, mod: string) => Promise<any>;
+export declare const isUnlimitedMinter: (market: any, mod: string) => Promise<any>;
+export declare const addMod: (proxyMod: any, totems: any, market: any, ticker: string, hooks: number[], mod: string, caller: string, referrer?: string) => Promise<any>;
+export declare const removeMod: (proxyMod: any, ticker: string, mod: string, caller: string) => Promise<any>;

package/test/helpers.js

@@ -0,0 +1,300 @@
+// 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
+};

package/test/helpers.ts

@@ -1,466 +0,0 @@
-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 enum Hook {
-    Created = 0,
-    Mint = 1,
-    Burn = 2,
-    Transfer = 3,
-    TransferOwnership = 4,
-}
-
-export const setupTotemsTest = async (minBaseFee: bigint = MIN_BASE_FEE, burnedFee: bigint = BURNED_FEE) => {
-    const { viem } = await network.connect();
-    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 });
-}