@sage-protocol/sdk 0.1.2 → 0.1.7

package/README.md

@@ -68,9 +68,297 @@ Module Overview
 | `treasury` | Reserve/POL snapshot, pending withdrawals, liquidity plans | Treasury analytics, Safe operators |
 | `boost` | Merkle/Direct boost readers + builders | Incentive distribution tooling |
 | `subgraph` | GraphQL helpers for proposals/libraries | Historical analytics |
+| `services` | High-level SubgraphService + IPFSService with retry/caching | Web app, CLI integration |
 | `adapters` | Normalized governance adapters (OZ) | UI layers needing a unified model |
 | `errors` | `SageSDKError` codes | Consistent downstream error handling |
 
+### Service Layer
+
+The SDK provides high-level service classes with built-in retry logic, caching, and error handling for production applications.
+
+**SubgraphService** - GraphQL queries with automatic retry and caching
+
+```js
+import { services, serviceErrors } from '@sage-protocol/sdk';
+
+// Initialize service
+const subgraphService = new services.SubgraphService({
+  url: 'https://api.studio.thegraph.com/query/your-subgraph',
+  timeout: 10000,      // 10s timeout (default)
+  retries: 3,          // 3 retry attempts with exponential backoff (default)
+  cache: {
+    enabled: true,     // Enable caching (default: true)
+    ttl: 30000,        // 30s cache TTL (default)
+    maxSize: 100,      // Max 100 cache entries (default)
+  },
+});
+
+// Fetch SubDAOs with caching
+const subdaos = await subgraphService.getSubDAOs({ limit: 50, skip: 0 });
+
+// Fetch proposals with filters
+const proposals = await subgraphService.getProposals({
+  governor: '0xGovernor',
+  states: ['ACTIVE', 'PENDING'],
+  fromTimestamp: 1640000000,
+  limit: 20,
+  cache: true,  // Use cache (default: true)
+});
+
+// Get single proposal by ID
+const proposal = await subgraphService.getProposalById('0x123...', { cache: true });
+
+// Fetch libraries
+const libraries = await subgraphService.getLibraries({
+  subdao: '0xSubDAO',
+  limit: 50,
+});
+
+// Fetch prompts by tag
+const prompts = await subgraphService.getPromptsByTag({
+  tagsHash: '0xabc123...',
+  registry: '0xRegistry',
+  limit: 50,
+});
+
+// Cache management
+subgraphService.clearCache();
+const stats = subgraphService.getCacheStats();
+// → { enabled: true, size: 12, maxSize: 100 }
+```
+
+**IPFSService** - Parallel gateway fetching with caching
+
+```js
+import { services, serviceErrors } from '@sage-protocol/sdk';
+import { ethers } from 'ethers';
+
+// Initialize service
+const ipfsService = new services.IPFSService({
+  workerBaseUrl: 'https://api.sageprotocol.io',
+  gateway: 'https://ipfs.io',
+  signer: ethers.Wallet.fromPhrase('...'), // Optional: for worker auth
+  timeout: 15000,      // 15s timeout (default)
+  retries: 2,          // 2 retry attempts (default)
+  cache: {
+    enabled: true,     // Enable caching (default: true)
+    ttl: 300000,       // 5min cache TTL for immutable CIDs (default)
+    maxSize: 50,       // Max 50 cache entries (default)
+  },
+});
+
+// Fetch content by CID (parallel gateway race)
+// Tries multiple gateways in parallel, returns first success
+const content = await ipfsService.fetchByCID('QmTest123...', {
+  cache: true,
+  timeout: 5000,       // 5s timeout per gateway
+  extraGateways: ['https://cloudflare-ipfs.com', 'https://gateway.pinata.cloud'],
+});
+
+// Upload content to IPFS worker
+const cid = await ipfsService.upload(
+  { title: 'My Prompt', content: '...' },
+  { name: 'prompt.json', warm: true }
+);
+// → 'QmNewContent123...'
+
+// Pin CIDs to worker
+await ipfsService.pin(['QmTest1...', 'QmTest2...'], { warm: false });
+
+// Warm gateways (prefetch)
+await ipfsService.warm('QmTest123...', {
+  gateways: ['https://ipfs.io', 'https://cloudflare-ipfs.com'],
+});
+
+// Cache management
+ipfsService.clearCache();
+const stats = ipfsService.getCacheStats();
+```
+
+**Error Handling**
+
+```js
+import { services, serviceErrors } from '@sage-protocol/sdk';
+
+try {
+  const subdaos = await subgraphService.getSubDAOs({ limit: 50 });
+} catch (error) {
+  if (error instanceof serviceErrors.SubgraphError) {
+    console.error(`Subgraph error [${error.code}]:`, error.message);
+    console.log('Retryable:', error.retryable);
+    // Codes: TIMEOUT, NETWORK, INVALID_RESPONSE, NOT_FOUND, QUERY_FAILED
+  }
+}
+
+try {
+  const content = await ipfsService.fetchByCID('QmTest...');
+} catch (error) {
+  if (error instanceof serviceErrors.IPFSError) {
+    console.error(`IPFS error [${error.code}]:`, error.message);
+    // Codes: TIMEOUT, PIN_FAILED, INVALID_CID, NOT_FOUND, GATEWAY_FAILED, UPLOAD_FAILED
+  }
+}
+
+// Format user-friendly error messages
+const friendlyMsg = serviceErrors.formatErrorMessage(error);
+```
+
+**Utility Exports**
+
+```js
+import { serviceUtils } from '@sage-protocol/sdk';
+
+// Simple in-memory cache with TTL
+const cache = new serviceUtils.SimpleCache({
+  enabled: true,
+  ttl: 60000,      // 1 minute
+  maxSize: 200,
+});
+cache.set('key', { data: 'value' });
+const val = cache.get('key');
+
+// Exponential backoff retry
+const result = await serviceUtils.retryWithBackoff(
+  async () => {
+    // Your async operation
+    return await fetchData();
+  },
+  {
+    attempts: 3,
+    baseDelay: 1000,   // Start at 1s
+    maxDelay: 10000,   // Cap at 10s
+    onRetry: ({ attempt, totalAttempts, delay, error }) => {
+      console.log(`Retry ${attempt}/${totalAttempts} after ${delay}ms:`, error.message);
+    },
+  }
+);
+```
+
+**Performance Notes**
+
+- **Parallel Gateway Fetching**: IPFSService fetches from multiple IPFS gateways simultaneously (Promise.race pattern), reducing typical fetch times from 7-28s to 1-2s (10-14x improvement)
+- **In-Memory Caching**: Both services cache results in memory with configurable TTL to reduce redundant network calls
+- **Exponential Backoff**: Automatic retry with exponential backoff (1s → 2s → 4s delays) for transient failures
+- **Edge Runtime Compatible**: Uses `fetch()` instead of axios, compatible with Cloudflare Pages and Vercel Edge
+
+**React Integration**
+
+The SDK provides React hooks built on SWR for seamless integration in React applications:
+
+**Prerequisites**:
+```bash
+# Install peer dependencies
+npm install react swr
+# or
+yarn add react swr
+```
+
+**Usage**:
+
+```js
+import { services, hooks } from '@sage-protocol/sdk';
+
+// Initialize services (once, typically in a context provider)
+const subgraphService = new services.SubgraphService({
+  url: 'https://api.studio.thegraph.com/query/your-subgraph',
+});
+
+const ipfsService = new services.IPFSService({
+  workerBaseUrl: 'https://api.sageprotocol.io',
+  gateway: 'https://ipfs.io',
+  signer: yourSigner, // Optional for uploads
+});
+
+// Use hooks in components
+function SubDAOList() {
+  const { data: subdaos, error, isLoading } = hooks.useSubDAOs(subgraphService, {
+    limit: 50,
+  });
+
+  if (isLoading) return <div>Loading...</div>;
+  if (error) return <div>Error: {error.message}</div>;
+
+  return (
+    <ul>
+      {subdaos.map(subdao => (
+        <li key={subdao.id}>{subdao.name}</li>
+      ))}
+    </ul>
+  );
+}
+
+function ProposalList({ governorAddress }) {
+  const { data: proposals } = hooks.useProposals(subgraphService, {
+    governor: governorAddress,
+    states: ['ACTIVE', 'PENDING'],
+    limit: 20,
+    refreshInterval: 30000, // Auto-refresh every 30s
+  });
+
+  return (
+    <ul>
+      {proposals?.map(proposal => (
+        <li key={proposal.id}>{proposal.description}</li>
+      ))}
+    </ul>
+  );
+}
+
+function PromptViewer({ cid }) {
+  const { data: content, isLoading } = hooks.useFetchCID(ipfsService, cid, {
+    extraGateways: ['https://cloudflare-ipfs.com'],
+  });
+
+  if (isLoading) return <div>Loading prompt...</div>;
+
+  return <pre>{JSON.stringify(content, null, 2)}</pre>;
+}
+
+function UploadForm() {
+  const { upload, isUploading, error, data: cid } = hooks.useUpload(ipfsService);
+
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    const content = { title: 'My Prompt', content: '...' };
+    try {
+      const newCid = await upload(content, { name: 'prompt.json' });
+      console.log('Uploaded:', newCid);
+    } catch (err) {
+      console.error('Upload failed:', err);
+    }
+  };
+
+  return (
+    <form onSubmit={handleSubmit}>
+      <button type="submit" disabled={isUploading}>
+        {isUploading ? 'Uploading...' : 'Upload'}
+      </button>
+      {error && <div>Error: {error.message}</div>}
+      {cid && <div>Uploaded to: {cid}</div>}
+    </form>
+  );
+}
+```
+
+**Available Hooks**:
+
+| Hook | Description | Returns |
+|------|-------------|---------|
+| `useSubDAOs(service, options)` | Fetch SubDAOs from subgraph | `{ data, error, isLoading, mutate }` |
+| `useProposals(service, options)` | Fetch proposals from subgraph | `{ data, error, isLoading, mutate }` |
+| `useFetchCID(service, cid, options)` | Fetch IPFS content by CID | `{ data, error, isLoading, mutate }` |
+| `useUpload(service)` | Upload content to IPFS | `{ upload, isUploading, error, data, reset }` |
+
+**Hook Options**:
+
+All data-fetching hooks support SWR options:
+- `refreshInterval` - Auto-refresh interval in ms
+- `revalidateOnFocus` - Revalidate when window focused
+- `revalidateOnReconnect` - Revalidate on network reconnect
+- `cache` - Use service-level caching
+
+**Note**: Hooks are optional and only available when `react` and `swr` peer dependencies are installed.
+
 ### Examples
 
 - [Legacy base mini app hook](examples/base-mini-app/README.md) – React-friendly context mirroring the former in-repo app (now maintained externally).

package/dist/browser/index.mjs

@@ -20,7 +20,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@sage-protocol/sdk",
-      version: "0.1.2",
+      version: "0.1.4",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -56,10 +56,10 @@ var require_package = __commonJS({
       ],
       sideEffects: false,
       browser: {
+        child_process: false,
         fs: false,
-        path: false,
         os: false,
-        child_process: false
+        path: false
       },
       repository: {
         type: "git",
@@ -88,6 +88,18 @@ var require_package = __commonJS({
         sinon: "^17.0.1",
         tsup: "^8.1.0",
         typescript: "^5.4.0"
+      },
+      peerDependencies: {
+        react: "^18.0.0 || ^19.0.0",
+        swr: "^2.0.0"
+      },
+      peerDependenciesMeta: {
+        react: {
+          optional: true
+        },
+        swr: {
+          optional: true
+        }
       }
     };
   }
@@ -1803,7 +1815,7 @@ var require_validation = __commonJS({
 // src/library/index.js
 var require_library = __commonJS({
   "src/library/index.js"(exports, module) {
-    var { Contract, getAddress, keccak256, toUtf8Bytes } = __require("ethers");
+    var { Contract, getAddress, keccak256, toUtf8Bytes, AbiCoder } = __require("ethers");
     var { Interface } = __require("ethers");
     var ABI = require_abi();
     var { SageSDKError, CODES } = require_errors();
@@ -1842,17 +1854,31 @@ var require_library = __commonJS({
         promptCount: Number(promptCount)
       };
     }
+    function _computeLibraryKey(subdao, libraryId) {
+      const coder = AbiCoder.defaultAbiCoder ? AbiCoder.defaultAbiCoder() : new AbiCoder();
+      const encoded = coder.encode(["address", "string"], [getAddress(subdao), String(libraryId)]);
+      return keccak256(encoded);
+    }
     async function getLatestLibrary({ provider, registry, subdao, libraryId = "main" }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(registry, "registry");
       const sub = normalise(subdao, "subdao");
       const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const key = keccak256(toUtf8Bytes(`${sub.toLowerCase()}::${libraryId}`));
+      const key = _computeLibraryKey(sub, libraryId);
       const latestCID = await contract.subdaoLibraryLatest(key).catch(() => "");
       if (!latestCID || latestCID.length === 0) return null;
       const info = await getManifestInfo({ provider, registry: addr, manifestCID: latestCID });
       return info;
     }
+    async function getBeforeAfterForUpdate({ provider, registry, subdao, libraryId = "main", newCid }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      const addr = normalise(registry, "registry");
+      const sub = normalise(subdao, "subdao");
+      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
+      const key = _computeLibraryKey(sub, libraryId);
+      const prev = await contract.subdaoLibraryLatest(key).catch(() => "");
+      return { previousCID: prev || null, newCID: String(newCid), libraryId: String(libraryId) };
+    }
     async function hasScopedOwnership({ provider, registry, subdao, manifestCID }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(registry, "registry");
@@ -1878,6 +1904,8 @@ var require_library = __commonJS({
       getLatestLibrary,
       hasScopedOwnership,
       buildUpdateLibraryForSubDAOTx,
+      _computeLibraryKey,
+      getBeforeAfterForUpdate,
       /** Build an authorizeTimelock(timelock, subdao) call for a LibraryRegistry. */
       buildAuthorizeTimelockTx: function buildAuthorizeTimelockTx({ registry, timelock, subdao }) {
         const to = normalise(registry, "registry");
@@ -2123,6 +2151,62 @@ var require_governance = __commonJS({
       const data = iface.encodeFunctionData("execute(uint256)", [id]);
       return { to: addr, data, value: BigIntZero };
     }
+    async function decodeProposalEffects({ provider, governor, proposalId, fromBlock = 0, toBlock = "latest" }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      const govAddr = normaliseGovernor(governor);
+      const iface = new Interface([ABI.Events.ProposalCreated]);
+      const topic = iface.getEvent("ProposalCreated").topicHash;
+      const id = typeof proposalId === "bigint" ? proposalId : String(proposalId).startsWith("0x") ? BigInt(proposalId) : BigInt(String(proposalId));
+      let parsed = null;
+      let logTxHash = null;
+      const logs = await provider.getLogs({ address: govAddr, fromBlock, toBlock, topics: [topic] });
+      for (const log of logs) {
+        try {
+          const p = iface.parseLog(log);
+          if (BigInt(p.args.id.toString()) === id) {
+            parsed = p;
+            logTxHash = log.transactionHash;
+            break;
+          }
+        } catch (_) {
+        }
+      }
+      if (!parsed) throw new Error("ProposalCreated event not found");
+      const targets = parsed.args.targets.map(getAddress);
+      const calldatas = parsed.args.calldatas.map((d) => typeof d === "string" ? d : "0x" + Buffer.from(d).toString("hex"));
+      const LibraryIface = new Interface(["function updateLibraryForSubDAO(address,string,string,uint256)", "function subdaoLibraryLatest(bytes32) view returns (string)"]);
+      const PromptIface = new Interface(["function updatePromptByGovernance(string,string)"]);
+      const coder = AbiCoder.defaultAbiCoder ? AbiCoder.defaultAbiCoder() : new AbiCoder();
+      const effects = [];
+      for (let i = 0; i < calldatas.length; i++) {
+        const data = calldatas[i];
+        const sel = data.slice(0, 10);
+        try {
+          const decoded = LibraryIface.decodeFunctionData("updateLibraryForSubDAO", data);
+          const [subdao, libraryId, newCid, promptCount] = decoded;
+          let previousCID = null;
+          try {
+            const reg = new Contract(targets[i], ["function subdaoLibraryLatest(bytes32) view returns (string)"], provider);
+            const key = keccak256(coder.encode(["address", "string"], [getAddress(subdao), String(libraryId)]));
+            const prev = await reg.subdaoLibraryLatest(key).catch(() => "");
+            previousCID = prev && prev.length ? String(prev) : null;
+          } catch (_) {
+          }
+          effects.push({ type: "libraryUpdate", index: i, target: targets[i], subdao: getAddress(subdao), libraryId: String(libraryId), previousCid: previousCID, newCid: String(newCid), promptCount: Number(promptCount) });
+          continue;
+        } catch (_) {
+        }
+        try {
+          const decodedP = PromptIface.decodeFunctionData("updatePromptByGovernance", data);
+          const [key, newCid] = decodedP;
+          effects.push({ type: "promptUpdate", index: i, target: targets[i], key: String(key), newCid: String(newCid) });
+          continue;
+        } catch (_) {
+        }
+        effects.push({ type: "unknown", index: i, target: targets[i], selector: sel });
+      }
+      return { governor: govAddr, proposalId: id, tx: logTxHash, actions: { count: calldatas.length }, effects };
+    }
     async function getQuorumAt({ provider, governor, blockTag }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normaliseGovernor(governor);
@@ -2252,6 +2336,7 @@ var require_governance = __commonJS({
       buildExecuteTx,
       buildQueueByIdTx,
       buildExecuteByIdTx,
+      decodeProposalEffects,
       makeProposalDescription,
       stripProposalSalt,
       getQuorumAt,
@@ -4091,7 +4176,7 @@ var require_factory = __commonJS({
 // src/browser/library.js
 var require_library2 = __commonJS({
   "src/browser/library.js"(exports, module) {
-    var { Contract, getAddress, keccak256, toUtf8Bytes, Interface } = __require("ethers");
+    var { Contract, getAddress, keccak256, AbiCoder, Interface } = __require("ethers");
     var ABI = require_abi();
     var { SageSDKError, CODES } = require_errors();
     var { searchRegistry } = require_search();
@@ -4128,12 +4213,17 @@ var require_library2 = __commonJS({
         promptCount: Number(promptCount)
       };
     }
+    function _computeLibraryKey(subdao, libraryId) {
+      const coder = AbiCoder.defaultAbiCoder ? AbiCoder.defaultAbiCoder() : new AbiCoder();
+      const encoded = coder.encode(["address", "string"], [getAddress(subdao), String(libraryId)]);
+      return keccak256(encoded);
+    }
     async function getLatestLibrary({ provider, registry, subdao, libraryId = "main" }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(registry, "registry");
       const sub = normalise(subdao, "subdao");
       const contract = new Contract(addr, ABI.LibraryRegistry, provider);
-      const key = keccak256(toUtf8Bytes(`${sub.toLowerCase()}::${libraryId}`));
+      const key = _computeLibraryKey(sub, libraryId);
       const latestCID = await contract.subdaoLibraryLatest(key).catch(() => "");
       if (!latestCID || latestCID.length === 0) return null;
       const info = await getManifestInfo({ provider, registry: addr, manifestCID: latestCID });
@@ -4158,6 +4248,15 @@ var require_library2 = __commonJS({
       ]);
       return { to, data, value: 0n };
     }
+    async function getBeforeAfterForUpdate({ provider, registry, subdao, libraryId = "main", newCid }) {
+      if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
+      const addr = normalise(registry, "registry");
+      const sub = normalise(subdao, "subdao");
+      const contract = new Contract(addr, ABI.LibraryRegistry, provider);
+      const key = _computeLibraryKey(sub, libraryId);
+      const prev = await contract.subdaoLibraryLatest(key).catch(() => "");
+      return { previousCID: prev || null, newCID: String(newCid), libraryId: String(libraryId) };
+    }
     function buildAuthorizeTimelockTx({ registry, timelock, subdao }) {
       const to = normalise(registry, "registry");
       const iface = new Interface(["function authorizeTimelock(address,address)"]);
@@ -4170,6 +4269,7 @@ var require_library2 = __commonJS({
       getLatestLibrary,
       hasScopedOwnership,
       buildUpdateLibraryForSubDAOTx,
+      getBeforeAfterForUpdate,
       buildAuthorizeTimelockTx,
       searchRegistry
     };
@@ -5779,7 +5879,23 @@ var require_treasury = __commonJS({
       confirmWithdrawal,
       cancelWithdrawal,
       setPriceOverride,
-      clearPriceOverride
+      clearPriceOverride,
+      // TX builders for app usage
+      buildApproveTx: ({ token, spender, amount, decimals = 18 }) => {
+        if (!token || !spender) throw new SageSDKError(CODES.INVALID_ARGS, "token and spender required");
+        const iface = new Interface(["function approve(address,uint256)"]);
+        return { to: getAddress(token), data: iface.encodeFunctionData("approve", [getAddress(spender), BigInt(amount.toString ? amount.toString() : amount)]), value: 0n };
+      },
+      buildTransferTx: ({ token, to, amount, decimals = 18 }) => {
+        if (!token || !to) throw new SageSDKError(CODES.INVALID_ARGS, "token and to required");
+        const iface = new Interface(["function transfer(address,uint256)"]);
+        return { to: getAddress(token), data: iface.encodeFunctionData("transfer", [getAddress(to), BigInt(amount.toString ? amount.toString() : amount)]), value: 0n };
+      },
+      buildWrapEthTx: ({ weth, amountWei }) => {
+        if (!weth) throw new SageSDKError(CODES.INVALID_ARGS, "weth required");
+        const iface = new Interface(["function deposit() payable"]);
+        return { to: getAddress(weth), data: iface.encodeFunctionData("deposit", []), value: BigInt(amountWei.toString ? amountWei.toString() : amountWei) };
+      }
     };
   }
 });
@@ -6120,12 +6236,40 @@ var require_doppler = __commonJS({
       }
       return { auctionAddress, note: "Lens API not available in this doppler-sdk version" };
     }
+    async function listAuctions(sdk, { limit = 10, cursor } = {}) {
+      const lens = sdk.lens;
+      if (lens) {
+        if (typeof lens.listAuctions === "function") {
+          try {
+            return await lens.listAuctions({ limit, cursor });
+          } catch (e) {
+          }
+        }
+        if (typeof lens.getAuctions === "function") {
+          try {
+            return await lens.getAuctions({ limit, cursor });
+          } catch (e) {
+          }
+        }
+      }
+      const fac = sdk.factory;
+      if (fac && typeof fac.listAuctions === "function") {
+        try {
+          return await fac.listAuctions({ limit, cursor });
+        } catch (e) {
+        }
+      }
+      return { ok: false, error: "LIST_UNSUPPORTED", message: "Listing auctions not supported by this doppler-sdk version" };
+    }
     async function buyTokens(sdk, { auctionAddress, numeraireAmount }) {
       const trade = sdk.trade || sdk.swap || sdk.auction;
       if (trade && typeof trade.buy === "function") {
-        return await trade.buy({ auctionAddress, numeraireAmount });
+        try {
+          return await trade.buy({ auctionAddress, numeraireAmount });
+        } catch (e) {
+        }
       }
-      throw new Error("Buy is not supported by the current doppler-sdk version");
+      return { ok: false, error: "BUY_UNSUPPORTED", message: "Buy not supported by this doppler-sdk version. Use executeV3BuyExactIn/urExecute helpers or upgrade doppler-sdk." };
     }
     async function migrate(sdk, asset) {
       if (sdk.airlock && typeof sdk.airlock.migrate === "function") {
@@ -6137,6 +6281,7 @@ var require_doppler = __commonJS({
       initDoppler,
       deployDynamicAuction,
       getAuctionStatus,
+      listAuctions,
       buyTokens,
       migrate
     };