liquid-sdk 1.5.7 → 1.6.0

package/llms.txt

@@ -121,7 +121,7 @@ Every token gets 100 billion supply (18 decimals), a Uniswap V4 pool, and locked
 | tickSpacing | 200 |
 | tickIfToken0IsLiquid | -230400 (~10 ETH market cap) |
 | positions | 5-position Liquid layout: 10%/50%/15%/20%/5% |
-| mevModule | Sniper Auction V2 (80%→40% over 32s) |
+| mevModule | Sniper Auction V2 (80%→40% over 20s) |
 | rewardRecipients | [deployer] at 100% |
 | context | {"interface":"SDK"} |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "liquid-sdk",
-  "version": "1.5.7",
+  "version": "1.6.0",
   "description": "TypeScript SDK to deploy ERC-20 tokens with Uniswap V4 liquidity on Base — zero API keys, one dependency (viem)",
   "author": "Liquid Protocol",
   "homepage": "https://github.com/craigbots/liquid-sdk#readme",

package/skills/bid-in-auction.md

@@ -6,7 +6,7 @@ You are an AI agent that participates in Liquid Protocol's sniper auction system
 
 When a new token is deployed on Liquid Protocol, a **sniper auction** activates to price early trading activity and capture MEV. Here's the mechanism:
 
-1. **Fee decay**: The auction starts with an **80% fee** on swaps and decays linearly to **40% over 32 seconds**
+1. **Fee decay**: The auction starts with an **80% fee** on swaps and decays linearly to **40% over 20 seconds**
 2. **Gas price bidding**: Bidders compete by setting their transaction gas price **above the pool's gas peg**. The difference between your gas price and the gas peg determines your bid amount
 3. **Rounds**: The auction runs in discrete rounds every 2 blocks (5 rounds max). Each round is valid for exactly **one block** (`nextAuctionBlock`)
 4. **Winner takes the swap**: The highest gas-price transaction in the auction block wins the right to swap at the current fee rate
@@ -286,7 +286,7 @@ interface BidInAuctionResult {
 | Payment per gas unit | 0.0001 ETH (1e14 wei) | Converts gas delta to bid ETH |
 | Starting fee | 800,000 (80%) | Fee at auction start |
 | Ending fee | 400,000 (40%) | Fee floor after decay |
-| Decay period | 32 seconds | Time for fee to decay from start to end |
+| Decay period | 20 seconds | Time for fee to decay from start to end |
 | Gas peg | ~6.3M wei (dynamic) | Set at pool creation, equals Base baseFee |
 
 ## Timing Strategy
@@ -294,7 +294,7 @@ interface BidInAuctionResult {
 The auction fee **decays over time**, so there's a tradeoff:
 
 - **Bid early** (high fee): You pay up to 80% of the swap as a fee, but you get the tokens before others. Useful if you expect rapid price appreciation.
-- **Bid late** (lower fee): The fee decays to 40% over 32 seconds. You pay less in fees but risk being outbid or missing the auction window.
+- **Bid late** (lower fee): The fee decays to 40% over 20 seconds. You pay less in fees but risk being outbid or missing the auction window.
 - **Wait for auction to end**: After all 5 rounds complete, trading is at normal pool fees (typically 1%). No auction mechanics apply.
 
 ```typescript

package/skills/deploy-token.md

@@ -172,7 +172,7 @@ const result = await sdk.deployToken({
 | `positionBps` | `number[]` | 5-tranche Liquid default | Supply % per position (sum = 10000) |
 | `lockerData` | `Hex` | auto-encoded | Locker init data |
 | `mevModule` | `Address` | Sniper Auction V2 | MEV protection module |
-| `mevModuleData` | `Hex` | 80%→40% over 32s | Encoded auction config |
+| `mevModuleData` | `Hex` | 80%→40% over 20s | Encoded auction config |
 | `extensions` | `ExtensionConfig[]` | `[]` | Additional extensions |
 | `devBuy` | `DevBuyParams` | none | Buy tokens at launch |
 
@@ -204,7 +204,7 @@ When `deployToken()` executes, a single transaction:
 2. **Initializes a Uniswap V4 pool** paired with WETH
 3. **Locks all LP** in the LP Locker (non-ruggable)
 4. **Configures reward splits** for fee distribution
-5. **Activates MEV protection** (sniper auction: 80%→40% fee decay over 32 seconds)
+5. **Activates MEV protection** (sniper auction: 80%→40% fee decay over 20 seconds)
 6. **Executes dev buy** if specified (swaps ETH→tokens in same tx)
 7. **Emits `TokenCreated` event** with all deployment data
 

package/skills/sdk-overview.md

@@ -0,0 +1,332 @@
+# Skill: Liquid SDK Overview
+
+You are an AI agent working with the `liquid-sdk` package. This file gives you a complete picture of what the SDK can do, the data schemas it uses, and how all the pieces fit together. Load a specific skill file (`deploy-token.md`, `bid-in-auction.md`, `index-tokens.md`) when you need step-by-step instructions for a task.
+
+## What Liquid Protocol Does
+
+Liquid Protocol deploys ERC-20 tokens on Base (chain ID 8453) with:
+- **Uniswap V4 pools** created and funded automatically
+- **Permanently locked LP** — liquidity cannot be rugged
+- **Configurable fee splits** — reward recipients earn LP fees in ETH
+- **MEV protection** — sniper auction prices early trading activity
+- **Extensions** — dev buy, vault lockup/vesting, merkle airdrops
+
+Every token gets 100 billion supply (18 decimals), a Uniswap V4 pool paired with WETH, and locked liquidity.
+
+## Install
+
+```bash
+npm install liquid-sdk viem
+```
+
+## SDK Capabilities at a Glance
+
+| Category | What you can do |
+|----------|----------------|
+| **Deploy** | Launch tokens with custom fees, positions, reward splits, dev buys |
+| **Snipe** | Bid in MEV auctions for early access to new tokens |
+| **Index** | Discover all tokens, query by deployer, paginate by block range |
+| **Fees** | Check and claim accumulated LP fees (converted to ETH) |
+| **Rewards** | Collect LP rewards, update reward recipients |
+| **Vault** | Check vesting schedules, claim unlocked tokens |
+| **Airdrop** | Check allocations, claim with merkle proofs |
+| **Pool reads** | Fee config, fee state, creation time, token sort order |
+| **MEV reads** | Auction state, fee decay, gas peg, block delay |
+| **Metadata** | Update token image and metadata on-chain (admin only) |
+
+## Data Schemas
+
+### Token Identity (set at deployment)
+
+These fields define how the token appears in wallets, aggregators, and explorers:
+
+```typescript
+const result = await sdk.deployToken({
+  name: "My Project Token",                    // Token name (required)
+  symbol: "MPT",                               // Token symbol (required)
+  image: "https://example.com/logo.png",       // Logo URL (shown in wallets)
+  metadata: buildMetadata({                    // Rich metadata (JSON, on-chain)
+    description: "A community token for builders on Base",
+    socialMediaUrls: [
+      { platform: "Website", url: "https://myproject.xyz" },
+      { platform: "Twitter", url: "https://x.com/myproject" },
+      { platform: "Discord", url: "https://discord.gg/myproject" },
+      { platform: "Telegram", url: "https://t.me/myproject" },
+      { platform: "GitHub", url: "https://github.com/myproject" },
+    ],
+    auditUrls: [
+      "https://audits.example.com/myproject-audit.pdf",
+    ],
+  }),
+  context: buildContext({                      // Deployment provenance
+    interface: "My App",
+    platform: "Farcaster",
+  }),
+});
+```
+
+**After deployment, you can update image and metadata (admin only):**
+```typescript
+await sdk.updateImage(tokenAddress, "https://new-logo.example.com/v2.png");
+await sdk.updateMetadata(tokenAddress, buildMetadata({
+  description: "Updated description",
+  socialMediaUrls: [
+    { platform: "Website", url: "https://myproject.xyz" },
+    { platform: "Twitter", url: "https://x.com/myproject_new" },
+  ],
+}));
+```
+
+### Token Metadata Schema
+
+Stored in the `tokenMetadata` field of the `TokenCreated` event. Wallets (Rainbow, Coinbase Wallet) and aggregators (Matcha, 0x) read this.
+
+```typescript
+import { buildMetadata, parseMetadata } from "liquid-sdk";
+
+// Build
+const metadata = buildMetadata({
+  description: "A community token for builders on Base",
+  socialMediaUrls: [
+    { platform: "Twitter", url: "https://x.com/myproject" },
+    { platform: "Discord", url: "https://discord.gg/myproject" },
+    { platform: "Telegram", url: "https://t.me/myproject" },
+    { platform: "Website", url: "https://myproject.xyz" },
+  ],
+  auditUrls: [
+    "https://audits.example.com/myproject-audit.pdf",
+  ],
+});
+
+// Parse (from on-chain event data)
+const parsed = parseMetadata(tokenEvent.tokenMetadata);
+// parsed.description     — string
+// parsed.socialMediaUrls — { platform: string, url: string }[]
+// parsed.auditUrls       — string[]
+```
+
+**Schema:**
+```typescript
+interface LiquidMetadata {
+  description?: string;              // Token/project description
+  socialMediaUrls?: SocialMediaUrl[];// Links shown by wallets & aggregators
+  auditUrls?: string[];              // Audit report URLs
+}
+
+interface SocialMediaUrl {
+  platform: string;  // "Website", "Twitter", "Discord", "Telegram", "GitHub", etc.
+  url: string;       // Full URL
+}
+```
+
+**Common platform values:** `"Website"`, `"Twitter"`, `"Discord"`, `"Telegram"`, `"GitHub"`, `"Farcaster"`, `"Instagram"`, `"YouTube"`
+
+### Token Context (deployment provenance)
+
+Stored in the `tokenContext` field. Tracks where/how the token was launched.
+
+```typescript
+import { buildContext, parseContext } from "liquid-sdk";
+
+// Build
+const context = buildContext({
+  interface: "My Agent",        // what system deployed it
+  platform: "Farcaster",        // social platform (optional)
+  messageId: "0xabc123",        // cast/post ID (optional)
+  id: "user-12345",             // user ID on platform (optional)
+});
+
+// Parse
+const parsed = parseContext(tokenEvent.tokenContext);
+// parsed.interface  — "My Agent"
+// parsed.platform   — "Farcaster"
+// parsed.messageId  — "0xabc123"
+```
+
+**Schema:**
+```typescript
+interface LiquidContext {
+  interface: string;    // Required. System that deployed ("SDK", "Rainbow Wallet", etc.)
+  platform?: string;    // Social platform origin
+  messageId?: string;   // Social post/message ID
+  id?: string;          // User ID on platform
+}
+```
+
+### Reward Configuration
+
+Set at deployment. Controls who receives LP fees and in what proportion.
+
+```typescript
+// Deploy with custom reward splits
+const result = await sdk.deployToken({
+  name: "Split Token",
+  symbol: "SPLIT",
+  rewardAdmins: [walletA, walletB, treasury],
+  rewardRecipients: [walletA, walletB, treasury],
+  rewardBps: [5000, 3000, 2000],  // 50% / 30% / 20%
+});
+
+// Read reward config for any token
+const rewards = await sdk.getTokenRewards(tokenAddress);
+rewards.rewardRecipients  // Address[] — who gets paid
+rewards.rewardBps         // number[]  — basis points per recipient (sum = 10000)
+rewards.rewardAdmins      // Address[] — who can update each recipient
+rewards.poolKey           // PoolKey   — the Uniswap V4 pool
+rewards.positionId        // bigint    — LP position NFT ID
+rewards.numPositions      // bigint    — number of LP positions
+
+// Update a recipient (only the admin at that index can do this)
+await sdk.updateRewardRecipient(tokenAddress, 0n, newWalletAddress);
+
+// Collect rewards (distributes to all recipients per their bps)
+await sdk.collectRewards(tokenAddress);
+```
+
+**Rules:**
+- `rewardRecipients`, `rewardAdmins`, and `rewardBps` arrays must be the same length
+- `rewardBps` must sum to 10000 (100%)
+- BPS splits are **immutable** after deployment — only recipient addresses can change
+- Each admin can only update the recipient at their own index
+- All fees are converted to ETH before distribution (default `FeePreference.Paired`)
+
+### Dev Buy (buy tokens at launch)
+
+Buys tokens with ETH in the same transaction as deployment. The ETH is swapped through the Uniswap V4 pool atomically.
+
+```typescript
+const result = await sdk.deployToken({
+  name: "My Token",
+  symbol: "MTK",
+  devBuy: {
+    ethAmount: parseEther("0.01"),  // ETH to spend buying tokens
+    recipient: account.address,      // who receives the purchased tokens
+  },
+});
+```
+
+**Schema:**
+```typescript
+interface DevBuyParams {
+  ethAmount: bigint;    // ETH to swap for tokens (sent as msg.value)
+  recipient: Address;   // Address that receives the purchased tokens
+}
+```
+
+### Vault (token lockup + vesting)
+
+Lock tokens with a lockup period followed by linear vesting.
+
+```typescript
+// Read vault state
+const vault = await sdk.getVaultAllocation(tokenAddress);
+vault.amountTotal     // bigint — total tokens locked
+vault.amountClaimed   // bigint — already claimed
+vault.lockupEndTime   // bigint — unix timestamp when lockup ends
+vault.vestingEndTime  // bigint — unix timestamp when fully vested
+vault.admin           // Address — who can claim
+vault.token           // Address — the token
+
+// Check claimable now
+const claimable = await sdk.getVaultClaimable(tokenAddress);
+
+// Claim
+if (claimable > 0n) {
+  await sdk.claimVault(tokenAddress);
+}
+```
+
+### Airdrop (merkle distribution)
+
+Distribute tokens to a list of recipients via merkle proof claims.
+
+```typescript
+// Read airdrop state
+const info = await sdk.getAirdropInfo(tokenAddress);
+info.merkleRoot     // Hex — merkle root
+info.totalSupply    // bigint — total airdrop supply
+info.totalClaimed   // bigint — already claimed
+info.lockupEndTime  // bigint — when claims begin
+info.vestingEndTime // bigint — when vesting completes
+info.admin          // Address — airdrop admin
+
+// Check claimable for a recipient
+const claimable = await sdk.getAirdropClaimable(tokenAddress, recipientAddress, allocatedAmount);
+
+// Claim (proof must be generated off-chain from the merkle tree)
+await sdk.claimAirdrop(tokenAddress, recipientAddress, allocatedAmount, merkleProof);
+```
+
+### Fee Claims
+
+LP fees accrue from trading activity. The LP Locker Fee Conversion contract converts all fees to ETH before distributing.
+
+```typescript
+// Check fees
+const available = await sdk.getAvailableFees(ownerAddress, tokenAddress);  // total unlocked
+const claimable = await sdk.getFeesToClaim(ownerAddress, tokenAddress);    // ready to claim
+
+// Claim
+if (claimable > 0n) {
+  await sdk.claimFees(ownerAddress, tokenAddress);
+}
+```
+
+### Token Metadata Updates (post-deploy)
+
+Only the token admin can update image and metadata after deployment.
+
+```typescript
+// Update image
+await sdk.updateImage(tokenAddress, "https://new-image.example.com/logo.png");
+
+// Update metadata
+await sdk.updateMetadata(tokenAddress, buildMetadata({
+  description: "Updated description",
+  socialMediaUrls: [
+    { platform: "Twitter", url: "https://twitter.com/updated" },
+  ],
+}));
+```
+
+## Default Configuration
+
+| Parameter | Default | Notes |
+|-----------|---------|-------|
+| Fee | 1% buy + 1% sell | Static, hook-controlled via `0x800000` flag |
+| Fee conversion | All → ETH | `FeePreference.Paired` per recipient |
+| Positions | 5-position Liquid layout | 10%/50%/15%/20%/5% from ~$20K to ~$1.2B |
+| MEV module | Sniper Auction V2 | 80%→40% over 20s, 5 rounds, 2-block interval |
+| Tick spacing | 200 | |
+| Starting tick | -230400 | ~10 ETH / ~$20K market cap |
+| Token supply | 100 billion (18 decimals) | Fixed for all tokens |
+| Reward split | 100% to deployer | Customizable at deploy |
+| Context | `{"interface":"SDK"}` | Auto-set, customizable |
+
+## Skill Files
+
+For step-by-step instructions, load the relevant skill:
+
+| Task | Skill file |
+|------|-----------|
+| Deploy a token | `skills/deploy-token.md` |
+| Bid in a sniper auction | `skills/bid-in-auction.md` |
+| Index/discover tokens | `skills/index-tokens.md` |
+
+## Exported Constants
+
+```typescript
+import { ADDRESSES, EXTERNAL, FEE, TOKEN, DEFAULTS, POOL_POSITIONS } from "liquid-sdk";
+
+// Key addresses
+ADDRESSES.FACTORY                    // Token factory
+ADDRESSES.HOOK_STATIC_FEE_V2        // Default hook (1% both ways)
+ADDRESSES.LP_LOCKER_FEE_CONVERSION  // Default locker (fees → ETH)
+ADDRESSES.SNIPER_AUCTION_V2         // Default MEV module
+
+// Fee constants
+FEE.DENOMINATOR    // 1,000,000
+FEE.BPS            // 10,000
+TOKEN.SUPPLY       // 100B * 10^18
+TOKEN.DECIMALS     // 18
+```