Build on Montra

A Montra token has no bonding curve, and nothing migrates. There is no second pool, no liquidity to move and no new address: the Uniswap v4 pool a token launches in is its market for life, and its poolId and PoolKey never change. A graduated token trades as it did before.

Graduation is still there, as a line in the pool: 16.8× the opening price on the menu's rows, about $58.7k of market cap from a $3.5k opening. Passing it moves nothing and changes no fee. It is there so a terminal's usual columns work on Montra as they do anywhere else.

Column

New

Which poolsLess than half way to the line

API stagenew

On chaingraduationProgress under 5,000, PoolConfig.stage 0

About to graduate

Which poolsHalf way or more, not yet graduated

API stagegraduating

On chaingraduationProgress of 5,000 or more, PoolConfig.stage 0 or 1

Graduated

Which poolsPast the line and confirmed, for good

API stagegraduated

On chainPoolConfig.stage 2, 3 or 4

Half way is the cut Montra's own board uses. progressBps runs from 0 to 10,000, so a terminal can draw the column wherever it likes.

• A column. GET /api/tokens?stage=graduating&sort=progress lists the pools closest to the line first. stage takes new, graduating or graduated, and sort=graduated puts the latest graduates first.
• A progress bar. graduation.progressBps on a card, or LaunchLens.graduationProgress(address hook, bytes32 poolId) view returns (uint256) on chain: the quote the seed has collected over the quote it holds at the line, the figure a bonding curve's bar shows.
• The moment it graduates. The hook's Graduated event, or graduation.graduatedAt in the API. There is no migration transaction to watch for: the first swap of a later transaction confirms the line, and nobody has to call anything.
• Past the line, not yet confirmed. graduationProgress reads 10,000 at stage Crossed (1). The next transaction's swap graduates the pool, whichever way it trades, so a pool at Crossed is almost always about to move: keep it at the top of About to graduate until Graduated. A sale can graduate a pool and leave the price back under the line. Only a sale in the transaction that crossed the line steps the pool back, before any read can see it.
• A pool with no line. graduationTicks of zero in PoolRegistered means graduated from birth, with no Graduated event. The API already counts it as graduated.

Find tokens from the factory's TokenLaunched events or from the public API. Accept a pool only if its hook is one the factory announced (ModuleSetPublished, emitted once the factory has checked the hook), which the registry mirrors (hooks(), isKnownHook(hook)): filter by it rather than taking the first pool you find for a token. An indexer pins the factory's proxy, whose address never moves; an app pins the registry and reads every other address from it by name. The addresses themselves are under Contracts.

Trust a token by its code, never by its name: a launch is an EIP-1167 clone of a token master the factory published, with a supply. Anyone can clone a master, but only the factory it names can initialize one, so a clone with a supply is a launch.

MONTRA, the launchpad's own token, is the token the registry names under montra (get("montra"), the name's ASCII right-padded to 32 bytes), and nothing else is, whatever its name or symbol. Until the registry names one, there is no MONTRA.

An indexer starts at the factory proxy's deployment block: no launch comes before it, and the creator's first buy is logged inside the launch's own transaction, before its TokenLaunched.

PoolKey({
  address currency0:   the lower address (native HYPE = 0x0000…0000),
  address currency1:   the higher address,
  uint24  fee:         0x800000,     // dynamic: the LP fee lives in the pool's slot0
  int24   tickSpacing: 200,          // the row's; every row of the menu's
  address hooks:       <launch hook> // one the factory announced; this one's low 14 bits are 0x38EC
})

get(bytes32 key) returns (address) takes the key's ASCII right-padded to 32 bytes (viem's stringToHex(key, { size: 32 }), cast's --format-bytes32-string), and answers zero for a key not set. Every change is announced by AddressSet(key, previous, current); hooks are not keys but a list (hooks(), isKnownHook(hook), HookAdded), from which none is ever removed.

Key

factory

What it namesThe factory's proxy: launches, rows and module sets. Once deployed, its address never moves.

SetAt deployment

router

What it namesLaunchRouter: a quote and an exact-input swap on one pool.

SetAt deployment

lens

What it namesLaunchLens: stateless reads, replaceable, so read it here.

SetAt deployment

quoteRegistry

What it namesThe quote assets a launch can pair with.

SetAt deployment

protocolVault

What it namesProtocolFeeVault: the protocol's share and the launch fees.

SetAt deployment

feeMarket

What it namesFeeMarket: the sales of the protocol's fees.

SetAt deployment

routeFiller

What it namesRouteFiller: fills a sale through pools.

SetAt deployment

buybackFiller

What it namesBuybackFiller: the buyback's only taker.

SetAt deployment

poolManager

What it namesUniswap v4's PoolManager, where every pool lives.

SetAt deployment

custodian

What it namesWhere the venue keeps every pool's balances, which holder rewards leave out: on v4 the PoolManager itself.

SetAt deployment

universalRouter

What it namesUniswap's Universal Router, for exact-output and multi-hop trades through a launch pool. The registry's own address here, or under permit2 or quoter, means withdrawn: none.

SetBy the governor; zero while unset, which is not an error

permit2

What it namesCanonical Permit2, which that router pulls every ERC-20 input with: a sale's token, and the quote of a buy in an ERC-20. Each token needs two approvals: the token's to Permit2, then Permit2's to the router, with an expiry.

SetWith universalRouter; zero while unset

quoter

What it namesUniswap's V4Quoter, for quoting a swap by either side: quoteExactIn quotes exact input alone.

SetBy the governor; zero while unset, which is not an error

gatewayRouter

What it namesThe chain's token bridge router, which Montra's API asks whether a listed quote is the bridge's canonical token. Nothing on chain calls it.

SetBy the governor; zero while unset

The launchpad's own token's key is set by the governor's last call in the batch that launches it, and reads zero until then.

Every Montra contract's ABI, and Uniswap's PoolManager's, is published from the contracts' build: /docs/abis.json, an object of from, the build they came from, and contracts, each contract's ABI by its name; /docs/abis/<Contract>.json, one contract's as a plain array, ready for viem or ethers; and /docs/abis/events.json, every event once, to decode any log an indexer reads. Each contract change refreshes them (npm run pull:abis in the site's repo), and every function, event, error, argument and field these pages name is checked against them.

The Universal Router, the V4Quoter and Permit2 are Uniswap's, and their ABIs are not published here. Take each from Uniswap's own repository (Uniswap/universal-router, Uniswap/v4-periphery, Uniswap/permit2) at the version the address the registry names is running, or from the chain's explorer where that address is verified. The calls these pages use are written out under Trade through the Universal Router.

A script or an AI tool reads the docs' machine files as plain files: these ABIs, /llms.txt, /llms-full.txt and each page's Markdown at /docs/<page>.md.

curl -s https://montramarkets.xyz/docs/abis/LaunchRouter.json

1. 1

   Find the addresses

   An app hard-codes the registry and reads the rest from it. Names are bytes32 strings. In these samples client is a viem public client, wallet a wallet client for account, and registryAbi, lensAbi and routerAbi the registry's, the lens's and the router's ABIs.

   TypeScriptCopyCopiedNot copied

   // get(bytes32 key) view returns (address)
   import { stringToHex, zeroAddress } from "viem";
   
   const registry = "0xF1E2FA75422F889e565F3142bdbf60B28dce2aa7";
   const name = (s: string) => stringToHex(s, { size: 32 });
   const lens = await client.readContract({
     address: registry, abi: registryAbi, functionName: "get", args: [name("lens")],
   });
   const router = await client.readContract({
     address: registry, abi: registryAbi, functionName: "get", args: [name("router")],
   });

2. 2

   Read a token's pool

   One call returns the pool key, its terms (config), the price, what the next trade pays and the pool's progress: a PoolView of 50 words, field by field under Contract reference. Check the hook against the registry. An address that is not a launch token makes it revert with no data, so there is no error to decode.

   TypeScriptCopyCopiedNot copied

   // tokenView(address token) view returns (PoolView)
   const view = await client.readContract({
     address: lens, abi: lensAbi, functionName: "tokenView", args: [token],
   });
   view.key;                     // the pool key to trade with
   view.config.quoteIsCurrency0; // which side the quote asset is
   view.sqrtPriceX96;            // the price now
   view.effectiveTotalFee;       // what the next sale pays all in, in pips
   view.buyEffectiveTotalFee;    // what a buy pays all in now: more inside an anti-snipe window
   await client.readContract({
     address: registry, abi: registryAbi, functionName: "isKnownHook", args: [view.key.hooks],
   }); // true

3. 3

   Quote a trade

   Buying the token spends the quote asset, so a buy swaps from the quote's side. quoteExactIn returns the output after every fee, as any call returns: it runs the swap inside the PoolManager and undoes it, so it changes nothing, but it is not marked view, so make it an eth_call (viem's simulateContract). On a Montra pool its quote is exactly what the trade then pays out. A swap the pool or the hook refuses makes the quote revert UnexpectedRevert, carrying the refusal. The amounts are uint128.

   TypeScriptCopyCopiedNot copied

   // quoteExactIn(PoolKey key, bool zeroForOne, uint128 amountIn) returns (uint256)
   const zeroForOne = view.config.quoteIsCurrency0; // a buy; a sell is the opposite
   const { result: amountOut } = await client.simulateContract({
     address: router, abi: routerAbi, functionName: "quoteExactIn",
     args: [view.key, zeroForOne, amountIn],
   });

4. 4

   Read a refusal

   How a refusal arrives depends on the call, so take each layer only if it is there. quoteExactIn reverts UnexpectedRevert(bytes reason), selector 0xc47bc67c, with the refusal as its reason. The V4Quoter does the same in UnexpectedRevertBytes(bytes revertData), selector 0x6190b2b0. swapExactIn adds no layer: the refusal arrives as it is, as it does through the deployed Universal Router, and another router may wrap it in an error of its own. Under that, a pool manager's own refusal is the error itself. A hook's arrives wrapped, as ERC-7751 has it, in WrappedError(address target, bytes4 selector, bytes reason, bytes details), selector 0x90bfb865: target is the hook, selector the callback that refused, reason the hook's own error and details the selector of HookCallFailed(), 0xa9e35b2f. An exact-output buy for more than the pool can deliver reverts SafeCastOverflow(), selector 0x93dafdf1. UnexpectedRevert is in LaunchRouter.json, the hook's errors in LaunchHook.json, and the rest in PoolManager.json.

   TypeScriptCopyCopiedNot copied

   // quoteExactIn:   UnexpectedRevert(bytes reason)
   // V4Quoter:       UnexpectedRevertBytes(bytes revertData)
   // swapExactIn:    no layer
   //   WrappedError(address target, bytes4 selector, bytes reason, bytes details)
   //     PartialFillRejected()
   import { decodeErrorResult } from "viem";
   
   // revertData: the bytes the call reverted with
   const abi = [...routerAbi, ...poolManagerAbi, ...hookAbi];
   let refusal = decodeErrorResult({ abi, data: revertData });
   if (refusal.errorName === "UnexpectedRevert" || refusal.errorName === "UnexpectedRevertBytes") {
     refusal = decodeErrorResult({ abi, data: refusal.args[0] });
   }
   if (refusal.errorName === "WrappedError") {
     refusal = decodeErrorResult({ abi, data: refusal.args[2] });
   }
   refusal.errorName; // "PartialFillRejected"

5. 5

   Trade

   One exact-input swap with a minimum and a deadline. A native input is sent as value; an ERC-20 input needs an approval for the router first. Reverts Expired, ZeroAddress, InvalidRecipient (the router itself as recipient), IncorrectValue or TooLittleReceived, or with the pool's or the hook's refusal, read as above; emits Swapped.

   TypeScriptCopyCopiedNot copied

   // swapExactIn((PoolKey key, bool zeroForOne, uint128 amountIn, uint128 minAmountOut, address recipient, uint256 deadline) s)
   //   payable returns (uint256 amountOut)
   const input = zeroForOne ? view.key.currency0 : view.key.currency1;
   await wallet.writeContract({
     address: router, abi: routerAbi, functionName: "swapExactIn",
     args: [{
       key: view.key, zeroForOne, amountIn,
       minAmountOut: amountOut * 99n / 100n,   // 1% slippage
       recipient: account.address,
       deadline: BigInt(Math.floor(Date.now() / 1000) + 300),
     }],
     value: input === zeroAddress ? amountIn : 0n,
   });

LaunchRouter makes one exact-input swap on one pool. For exact output, or a route through several pools, use the Universal Router the registry names under universalRouter, and the V4Quoter under quoter to quote it. A trade is one execute call: commands has a byte per command and inputs an entry per command. A V4_SWAP command's input is abi.encode(bytes actions, bytes[] params), with a byte per action in actions and an entry per action in params.

Kind

Command

NameV4_SWAP

Byte0x10

InputIts actions and their params.

Command

NameSWEEP

Byte0x04

Input(address token, address recipient, uint256 amountMinimum). Pays out all the router holds of token, the zero address being the native currency, to recipient, address 1 being the caller.

Action

NameSWAP_EXACT_IN_SINGLE

Byte0x06

InputExactInputSingleParams: one pool, exact input.

Action

NameSWAP_EXACT_IN

Byte0x07

InputExactInputParams: a route, exact input.

Action

NameSWAP_EXACT_OUT_SINGLE

Byte0x08

InputExactOutputSingleParams: one pool, exact output.

Action

NameSWAP_EXACT_OUT

Byte0x09

InputExactOutputParams: a route, exact output.

Action

NameSETTLE_ALL

Byte0x0c

Input(address currency, uint256 maxAmount). Pays what the swap owes, from the caller: through Permit2, or out of the call's value.

Action

NameTAKE_ALL

Byte0x0f

Input(address currency, uint256 minAmount). Delivers what the swap made, to the caller.

• The structs depend on the router's build. The samples below are what the deployed router requires: a uint256 minHopPriceX36 before hookData in a one-pool swap, and a uint256[] minHopPriceX36 after path in a route. The structs in many older samples have neither, and builds of the Universal Router differ, so check the router the registry names before you encode.
• How to check. execute takes bytes, so no ABI shows these structs, but a build's ABI lists its errors: InvalidHopPriceLength is there on a build that takes the field. Confirm it in the router's source.
• The wrong shape does not fail cleanly. Sent to the deployed router, the older struct reverts with no data where currency0 is an ERC-20. Where currency0 is native it goes through, so a test on a native-quoted pool proves nothing.
• What the field does. It is the least a hop may pay, as amountOut × 1e36 / amountIn, and a hop under it reverts V4TooLittleReceivedPerHopSingle or, in a route, V4TooLittleReceivedPerHop; on exact output, V4TooMuchRequestedPerHopSingle or V4TooMuchRequestedPerHop. Zero, or an empty list, turns it off; a list has one entry per pool, or the swap reverts InvalidHopPriceLength. The samples turn it off: amountOutMinimum already holds the whole trade.

1. 1

   Set up the encoders

   In these samples universalRouter, permit2 and quoter are the registry's addresses, read as under Read, quote and trade, and view, zeroForOne and amountIn are as they are there. trade sends one V4_SWAP. With a native input it adds a SWEEP, so nothing the swap did not spend stays behind.

   TypeScriptCopyCopiedNot copied

   // execute(bytes commands, bytes[] inputs, uint256 deadline) payable
   import { encodeAbiParameters, pad, parseAbi, parseAbiParameters, zeroAddress } from "viem";
   
   const poolKey = "(address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) poolKey";
   const pathKeys = "(address intermediateCurrency, uint24 fee, int24 tickSpacing, address hooks, bytes hookData)[] path";
   
   // the swap actions' params, as the deployed router takes them
   const exactInSingle = parseAbiParameters(`(${poolKey}, bool zeroForOne, uint128 amountIn, uint128 amountOutMinimum, uint256 minHopPriceX36, bytes hookData)`);
   const exactIn = parseAbiParameters(`(address currencyIn, ${pathKeys}, uint256[] minHopPriceX36, uint128 amountIn, uint128 amountOutMinimum)`);
   const exactOutSingle = parseAbiParameters(`(${poolKey}, bool zeroForOne, uint128 amountOut, uint128 amountInMaximum, uint256 minHopPriceX36, bytes hookData)`);
   const exactOut = parseAbiParameters(`(address currencyOut, ${pathKeys}, uint256[] minHopPriceX36, uint128 amountOut, uint128 amountInMaximum)`);
   
   // SETTLE_ALL's and TAKE_ALL's params
   const currencyAmount = parseAbiParameters("address, uint256");
   
   // one V4_SWAP command's input: its actions, a byte each, and their params
   const v4Swap = (actions, params) => encodeAbiParameters(parseAbiParameters("bytes, bytes[]"), [actions, params]);
   
   // a SWEEP of the native currency to the caller, which the router reads from address 1
   const sweep = encodeAbiParameters(parseAbiParameters("address, address, uint256"), [zeroAddress, pad("0x01", { size: 20 }), 0n]);
   
   const universalRouterAbi = parseAbi(["function execute(bytes commands, bytes[] inputs, uint256 deadline) payable"]);
   const deadline = BigInt(Math.floor(Date.now() / 1000) + 300);
   
   const trade = (swap, input, value) => wallet.writeContract({
     address: universalRouter, abi: universalRouterAbi, functionName: "execute",
     args: input === zeroAddress ? ["0x1004", [swap, sweep], deadline] : ["0x10", [swap], deadline],
     value: input === zeroAddress ? value : 0n,
   });

2. 2

   Approve an ERC-20 input

   Every ERC-20 the router spends goes through Permit2: the launch token on a sale, and the quote on a buy in an ERC-20. Each token needs two approvals: the token's own approve to Permit2, then Permit2's approve to the router, with an amount and an expiry. Read the second with allowance and renew it in time: an expired one reverts AllowanceExpired, and one too small InsufficientAllowance. An expiry of zero lasts only the block. A native input needs neither.

   TypeScriptCopyCopiedNot copied

   // approve(address token, address spender, uint160 amount, uint48 expiration)
   import { erc20Abi, maxUint256 } from "viem";
   
   const permit2Abi = parseAbi([
     "function approve(address token, address spender, uint160 amount, uint48 expiration)",
     "function allowance(address user, address token, address spender) view returns (uint160 amount, uint48 expiration, uint48 nonce)",
   ]);
   const input = zeroForOne ? view.key.currency0 : view.key.currency1;
   
   // once a token
   await wallet.writeContract({
     address: input, abi: erc20Abi, functionName: "approve", args: [permit2, maxUint256],
   });
   
   // again when it runs out or expires: an hour here
   await wallet.writeContract({
     address: permit2, abi: permit2Abi, functionName: "approve",
     args: [input, universalRouter, amountIn, Math.floor(Date.now() / 1000) + 3600],
   });

3. 3

   Quote with the V4Quoter

   The V4Quoter's structs have no minHopPriceX36. It quotes either side and returns the amount and a gas estimate. It is not marked view, so make it an eth_call. What it answers is what the swap then does, and it reverts as under Read a refusal.

   TypeScriptCopyCopiedNot copied

   // quoteExactInputSingle(params) returns (uint256 amountOut, uint256 gasEstimate)
   const quoterAbi = parseAbi([
     `function quoteExactInputSingle((${poolKey}, bool zeroForOne, uint128 exactAmount, bytes hookData) params) returns (uint256 amountOut, uint256 gasEstimate)`,
     `function quoteExactOutputSingle((${poolKey}, bool zeroForOne, uint128 exactAmount, bytes hookData) params) returns (uint256 amountIn, uint256 gasEstimate)`,
     `function quoteExactInput((address exactCurrency, ${pathKeys}, uint128 exactAmount) params) returns (uint256 amountOut, uint256 gasEstimate)`,
     `function quoteExactOutput((address exactCurrency, ${pathKeys}, uint128 exactAmount) params) returns (uint256 amountIn, uint256 gasEstimate)`,
   ]);
   const { result: [quoted] } = await client.simulateContract({
     address: quoter, abi: quoterAbi, functionName: "quoteExactInputSingle",
     args: [{ poolKey: view.key, zeroForOne, exactAmount: amountIn, hookData: "0x" }],
   });

4. 4

   Swap one pool

   A buy or a sale, as zeroForOne says. SETTLE_ALL pays the input and TAKE_ALL delivers the output, each with its limit. The caller is both the payer and who receives.

   TypeScriptCopyCopiedNot copied

   const input = zeroForOne ? view.key.currency0 : view.key.currency1;
   const output = zeroForOne ? view.key.currency1 : view.key.currency0;
   const minimum = quoted * 99n / 100n; // 1% slippage
   
   const swap = v4Swap("0x060c0f", [ // SWAP_EXACT_IN_SINGLE, SETTLE_ALL, TAKE_ALL
     encodeAbiParameters(exactInSingle, [{
       poolKey: view.key, zeroForOne, amountIn, amountOutMinimum: minimum, minHopPriceX36: 0n, hookData: "0x",
     }]),
     encodeAbiParameters(currencyAmount, [input, amountIn]),
     encodeAbiParameters(currencyAmount, [output, minimum]),
   ]);
   await trade(swap, input, amountIn);

5. 5

   Swap through several pools

   path lists the pools in order, each entry naming the currency its hop ends in. This one buys a token quoted in an ERC-20 with native HYPE: through a plain pool into quote, then through the launch pool into token. A sale runs the same pools the other way: the launch pool's entry first, ending in quote, then the plain pool's, ending in the zero address. The hook's fee is charged once, on the launch pool's hop.

   TypeScriptCopyCopiedNot copied

   const path = [
     { intermediateCurrency: quote, fee: plain.fee, tickSpacing: plain.tickSpacing, hooks: plain.hooks, hookData: "0x" },
     { intermediateCurrency: token, fee: view.key.fee, tickSpacing: view.key.tickSpacing, hooks: view.key.hooks, hookData: "0x" },
   ];
   const { result: [routeQuote] } = await client.simulateContract({
     address: quoter, abi: quoterAbi, functionName: "quoteExactInput",
     args: [{ exactCurrency: zeroAddress, path, exactAmount: amountIn }],
   });
   const minimum = routeQuote * 99n / 100n; // 1% slippage
   
   const swap = v4Swap("0x070c0f", [ // SWAP_EXACT_IN, SETTLE_ALL, TAKE_ALL
     encodeAbiParameters(exactIn, [{ currencyIn: zeroAddress, path, minHopPriceX36: [], amountIn, amountOutMinimum: minimum }]),
     encodeAbiParameters(currencyAmount, [zeroAddress, amountIn]),
     encodeAbiParameters(currencyAmount, [token, minimum]),
   ]);
   await trade(swap, zeroAddress, amountIn);

6. 6

   Exact output

   You name what you receive and cap what you pay. A native input sends the whole cap as the call's value and pays only what the swap costs. Without a SWEEP, the surplus stays in the router, and any caller's SWEEP takes it. An ERC-20 input is pulled for exactly what the swap costs, so it leaves nothing. A route uses SWAP_EXACT_OUT (0x09) and ExactOutputParams, whose path names each hop by the currency it starts from.

   TypeScriptCopyCopiedNot copied

   const input = zeroForOne ? view.key.currency0 : view.key.currency1;
   const output = zeroForOne ? view.key.currency1 : view.key.currency0;
   const { result: [cost] } = await client.simulateContract({
     address: quoter, abi: quoterAbi, functionName: "quoteExactOutputSingle",
     args: [{ poolKey: view.key, zeroForOne, exactAmount: wanted, hookData: "0x" }],
   });
   const maximum = cost * 102n / 100n; // 2% slippage
   
   const swap = v4Swap("0x080c0f", [ // SWAP_EXACT_OUT_SINGLE, SETTLE_ALL, TAKE_ALL
     encodeAbiParameters(exactOutSingle, [{
       poolKey: view.key, zeroForOne, amountOut: wanted, amountInMaximum: maximum, minHopPriceX36: 0n, hookData: "0x",
     }]),
     encodeAbiParameters(currencyAmount, [input, maximum]),
     encodeAbiParameters(currencyAmount, [output, wanted]),
   ]);
   await trade(swap, input, maximum); // a native input sends the cap, and the SWEEP returns the rest

A trade through this router can also revert V4TooLittleReceived, under its minimum; V4TooMuchRequested, over its cap; or TransactionDeadlinePassed. A native input whose value does not cover the swap reverts with no data.

One call to the factory makes the token, its pool, its locked liquidity and the first buy. Whoever calls launch is the creator. A product that sends launches can earn a share of the fees they go on to pay: Builder programme. In these samples factory is the registry's factory, read as above, factoryAbi is LaunchFactory.json, and zeroAddress, zeroHash and parseEventLogs are viem's.

1. 1

   Upload its image and metadata

   A token carries its image in two places, and both are fixed at launch, so set both. metadataURI names a document, the usual place wallets and explorers look; profile.logo keeps the image on the token itself, in the form terminals read through getTokenInfo(). The site shows the document's image, and the token's logo where there is no document or it names none. These two routes are what the site itself uses, and a script calls them the same way, with no key: the image first, as its raw bytes (PNG, JPEG, WebP or GIF, 2 MB at most, 20 an hour per connection), then a document naming it (name, symbol, description, image, and any of website, twitter, telegram, discord; 30 an hour). Upload shortly before you launch: anything no launch has named after about an hour may be cleared, and uploading the same file again gives the same URI, so it is safe to repeat. Once the launch is seen, both are pinned to IPFS. Or host your own: any ipfs:// or https:// URI to a JSON document with those fields works, naming an ipfs:// or https:// image.

   TypeScriptCopyCopiedNot copied

   import { readFileSync } from "node:fs";
   
   const api = "https://api.montramarkets.xyz";
   const posted = async (r) => {
     const body = await r.json();
     if (!r.ok) throw new Error(body.error ?? r.statusText);
     return body;
   };
   
   const image = await fetch(`${api}/api/metadata/image`, {
     method: "POST",
     headers: { "content-type": "image/png" },
     body: readFileSync("logo.png"),
   }).then(posted);
   
   const metadata = await fetch(`${api}/api/metadata`, {
     method: "POST",
     headers: { "content-type": "application/json" },
     body: JSON.stringify({
       name: "Example",
       symbol: "EXMPL",
       description: "What it is.",
       image: image.uri,
       website: "https://example.com",
     }),
   }).then(posted);

2. 2

   Choose a row

   A launch names a row of the factory's menu by configId. Ids count from 0, configCount() says how many there are and getConfig(id) returns a row: one tier for one quote asset, launchable while enabled. Rows are added and switched off, so read them rather than hard-coding an id. The row picks the hook: getModuleSet(row.moduleSetId).hook, not the newest of the registry's hooks(). That list holds every hook ever published and never loses one, so a pool's hook is checked against it, and a launch's is chosen by its row.

   TypeScriptCopyCopiedNot copied

   // ids run from 0 to count - 1: read each, and offer those with row.enabled
   const count = await client.readContract({ address: factory, abi: factoryAbi, functionName: "configCount" });
   const row = await client.readContract({ address: factory, abi: factoryAbi, functionName: "getConfig", args: [configId] });
   
   const { hook } = await client.readContract({
     address: factory, abi: factoryAbi, functionName: "getModuleSet", args: [row.moduleSetId],
   });

3. 3

   Build the launch

   LaunchParams has twelve fields, in the order below; each is in the structs. The launch fee is native and separate: on a native-quoted row value is the fee plus the first buy, and on an ERC-20 row it is the fee alone, with the first buy pulled from the sender, who approves the factory first or passes a permit. firstBuyAmount is the whole first buy, its fee included, and firstBuyMinOut the fewest tokens you accept for it, 0 for any: it lands in the launch's own transaction, so nothing can trade ahead of it. There is no pool to quote yet: to show what it will buy, LaunchLens.seedPreview(factory, configId, supply) gives the pool it opens on.

   TypeScriptCopyCopiedNot copied

   const params = {
     name: "Example",
     symbol: "EXMPL",
     metadataURI: metadata.uri,                // the document, with the image in it
     profile: {
       logo: image.uri,                        // the same image, kept on the token
       description: "What it is.",
       socials: { telegram: "", twitter: "", discord: "", website: "", extra: "" },
     },
     configId,
     supply: 0n,                               // the row's own
     salt: "0x…",                              // any 32 bytes of your own
     feeRecipients: [],                        // the creator's own wallet
     feeShares: [],
     firstBuyAmount,
     firstBuyMinOut,
     permit: { deadline: 0n, v: 0, r: zeroHash, s: zeroHash }, // none
   };
   
   const launchFee = await client.readContract({ address: factory, abi: factoryAbi, functionName: "launchFee" });
   const value = row.quote === zeroAddress ? launchFee + firstBuyAmount : launchFee;

4. 4

   Send it and read it back

   TokenLaunched describes the launch in full. Its firstBuyIn is firstBuyAmount, the swap's fee included, its firstBuyOut the tokens the creator received after that fee, and the launch fee is in neither. A product's builder code goes on as dataSuffix: Attributing a launch.

   TypeScriptCopyCopiedNot copied

   await client.simulateContract({ address: factory, abi: factoryAbi, functionName: "launch", args: [params], account, value });
   const hash = await wallet.writeContract({ address: factory, abi: factoryAbi, functionName: "launch", args: [params], value });
   const receipt = await client.waitForTransactionReceipt({ hash });
   
   const [launched] = parseEventLogs({ abi: factoryAbi, eventName: "TokenLaunched", logs: receipt.logs });
   const { token, poolId, firstBuyIn, firstBuyOut } = launched.args;

A token's page is https://montramarkets.xyz/token/<address>, the address in lowercase; any other spelling redirects there. A wallet's is /wallet/<address>, and an approved builder's /builders/<code>.

Never show Swap.fee or slot0's LP fee, which read zero until the LP line while every trade pays the total, nor the key's 0x800000, which is only the dynamic-fee flag. There is no transfer tax.

No tier of the menu has a whitelist, per-wallet logic or a trading window: a pool trades from its first block, and the hook sees the router as the sender, never the trader. The fee is netted into the swap's deltas, so standard routers and quoters handle it, and quote exactly what the trade pays.

The fee is always in the quote asset and returned as a hook delta (beforeSwapReturnDelta when the quote is the specified currency, afterSwapReturnDelta when it is not), so the caller's delta already includes it. Exact-output swaps gross the fee up, so the rate is the same in both directions. Every shape fills the whole amount it names or reverts (PartialFillRejected).

v4 reads a hook's permissions from the low 14 bits of its address; this hook's are 0x38EC: nothing on removing liquidity and nothing after a donation. A later hook may carry more, so trust a hook because the factory announced it, not by its bits.