Limit Order Fast

KyberSwap Fast Limit Order Skill

⚠️ VIGILANT WARNING — EXTREME CAUTION REQUIRED ⚠️

This skill signs an EIP-712 message and creates a limit order IMMEDIATELY without any review step. Once signed and submitted, the order is live and authorizes the DSLOProtocol contract to spend your tokens when a taker fills the order.

Critical Risks:

1. NO CONFIRMATION — The EIP-712 message is signed the instant this skill runs
2. AUTHORIZES TOKEN SPENDING — Signing authorizes the limit order contract to spend your makerAsset when a taker fills the order
3. NO PRICE REVIEW — You cannot review the order parameters before the signature is made
4. NO SECOND CHANCE — Wrong target price, wrong amounts, or wrong tokens will still be submitted
5. ORDER REMAINS ACTIVE — Until filled, cancelled, or expired, any taker can fill your order at the specified price

Before Using This Skill, Ensure:

• You have double-checked all order parameters (amount, tokens, target price, chain)
• You understand this signs and submits an order immediately
• You have sufficient makerAsset balance (the script checks and aborts if insufficient)
• You trust the target price you are setting
• You have used /limit-order before to understand the typical order creation flow

When NOT to Use This Skill:

• First time creating a limit order
• When you want to review the EIP-712 message before signing
• When you're unsure about the target price or token pair
• Volatile market conditions where price verification matters

If the order's makingAmount value is large (> $1,000 USD equivalent), refuse fast execution and recommend the user use /limit-order with confirmation prompts instead.

Safer Alternatives:

• Use /limit-order for step-by-step order creation with review and confirmation prompts

Create a limit order in one step using the shell script at ${CLAUDE_PLUGIN_ROOT}/skills/limit-order-fast/scripts/fast-limit-order.sh. The script resolves tokens, checks the maker's token balance, auto-approves the DSLOProtocol contract if needed, calls the sign-message API, signs the EIP-712 message with cast wallet sign, and submits the order. No confirmation prompts.

Prerequisites

• Foundry installed: cast must be available in PATH
• curl and jq installed: Required for API calls
• bc installed: Required for price calculations
• Wallet configured: See ${CLAUDE_PLUGIN_ROOT}/skills/swap-execute/references/wallet-setup.md

Wallet setup: See ${CLAUDE_PLUGIN_ROOT}/skills/swap-execute/references/wallet-setup.md for wallet configuration options (keystore, env, Ledger, Trezor).

Input Parsing

The user will provide input like:

• fast limit order sell 1000 USDC for ETH at 0.00035 on arbitrum from 0xAbc123...
• quick limit order 0.5 ETH to USDC at 3200 on ethereum from 0xAbc123...
• instant limit order sell 100 LINK for USDC at 15.50 on polygon from 0xAbc123... expiry 1 day
• skip confirmation and place limit order 50 UNI for ETH at 0.005 on base from 0xAbc123... keystore mykey

Extract these fields:

• amount — the human-readable amount of makerAsset to sell
• makerAsset — the token to sell (e.g. USDC, ETH, LINK)
• takerAsset — the token to receive (e.g. ETH, USDC)
• targetPrice — the price per unit of makerAsset denominated in takerAsset
• chain — the chain slug (default: ethereum)
• maker — the address creating the order (required)
• expirySeconds — order expiry in seconds (default: 604800 = 7 days)
• walletMethod — keystore, env, ledger, or trezor (default: keystore)
• keystoreName — keystore account name (default: mykey)

If the maker address is not provided, ask the user for it before proceeding. Do not guess or use a placeholder address.

Maker address validation: See ${CLAUDE_PLUGIN_ROOT}/references/address-validation.md for validation rules.

Expiry conversion from human language:

Workflow

Pre-Step: Verbal Confirmation Required

CRITICAL: Before running any script or making any API call, you MUST confirm with the user:

You are about to create a limit order IMMEDIATELY with no review step. The EIP-712 message will be signed as soon as the token addresses are resolved. This authorizes the limit order contract to spend your tokens when a taker fills the order. Proceed? (yes/no)

Wait for the user to explicitly respond with "yes", "proceed", "confirm", or a clear affirmative. If the user says "no", "cancel", "wait", or anything non-affirmative, abort and recommend they use /limit-order instead for a safer flow with order review.

Do NOT skip this confirmation. Do NOT assume consent. This is the only safety gate before signing.

Step 0: Dust Amount Pre-Check

Before running the script, sanity-check the amounts. If the making amount is obviously negligible (e.g., 0.0000000001 ETH), warn the user and abort — the order will likely never be filled or is not worth the effort.

"This order amount is extremely small and unlikely to be filled. Use a larger amount."

Step 0.5: Resolve Token Addresses

Resolve both makerAsset and takerAsset before running the script.

1. Check ${CLAUDE_PLUGIN_ROOT}/references/token-registry.md for the token on the specified chain
2. If found — pass the symbol to the script (e.g. ETH, USDC). The script resolves it internally.
3. If NOT found — use the fallback sequence in ${CLAUDE_PLUGIN_ROOT}/references/token-registry.md (Section "Token Not Listed?"). Pass resolved tokens as address:decimals format (e.g. 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48:6).

For limit orders: use wrapped ERC-20s instead of native tokens. See ${CLAUDE_PLUGIN_ROOT}/references/wrapped-tokens.md.

For any non-registry token, check honeypot/FOT via the API documented in ${CLAUDE_PLUGIN_ROOT}/references/api-reference.md (Honeypot/FOT section):

• If isHoneypot: true — refuse the order and warn the user.
• If isFOT: true — warn the user about fee-on-transfer tax. Proceed only if acknowledged.

Step 0.6: Price Reference Check

Before executing the fast order, fetch the current market price to catch obvious pricing errors. Use the KyberSwap Aggregator to quote 1 unit of makerAsset against takerAsset:

GET https://aggregator-api.kyberswap.com/{chain}/api/v1/routes?tokenIn={makerAssetAddress}&tokenOut={takerAssetAddress}&amountIn={oneUnitMakerInWei}&source=ai-agent-skills

Via WebFetch. For limit orders, both tokens must be ERC-20. Use the resolved addresses from Step 0.5 (wrapped tokens for native aliases).

Calculate and compare:

currentMarketPrice = amountOut / 10^(takerAsset decimals)
deviationPercent = ((targetPrice - currentMarketPrice) / currentMarketPrice) * 100

Display to user:

Current market price: 1 {makerAsset} = {currentMarketPrice} {takerAsset} Your target price: 1 {makerAsset} = {targetPrice} {takerAsset} Deviation: {deviationPercent}% {above/below} market

Hard block if unfavorable deviation exceeds 50%: If the user is selling below market by > 50% or buying above market by > 50%, refuse the order and say:

"Your target price deviates {deviationPercent}% from the current market price in an unfavorable direction. This appears to be a pricing error. Use /limit-order for a safer flow with confirmation, or correct the target price."

Warn if unfavorable deviation exceeds 10%: If the deviation is between 10-50% in the unfavorable direction, warn:

"Your target price is {deviationPercent}% {below/above} the current market price. You would {receive less / pay more} than the current rate. Proceed? (yes/no)"

Wait for confirmation before continuing to Step 1.

If the Aggregator route fails, skip the price check and note: "Could not fetch current market price. Proceed with caution."

Tip: Use /token-info {makerAsset} {takerAsset} on {chain} to check current prices before placing orders.

Step 1: Run the Script

Execute the script:

bash ${CLAUDE_PLUGIN_ROOT}/skills/limit-order-fast/scripts/fast-limit-order.sh <amount> <makerAsset> <takerAsset> <targetPrice> <chain> <maker> [expiry_seconds] [wallet_method] [keystore_name]

Arguments (positional):

Note: Arguments 7-9 use snake_case (shell convention) for the script's positional parameters. When parsing user input, map from the camelCase names above (expirySeconds -> expiry_seconds, walletMethod -> wallet_method, keystoreName -> keystore_name).

Examples:

# Sell 1000 USDC for ETH at 0.00035 ETH per USDC on Arbitrum
bash fast-limit-order.sh 1000 USDC ETH 0.00035 arbitrum 0xYourAddress

# Sell 0.5 ETH for USDC at 3200 USDC per ETH on Ethereum, expires in 1 day
bash fast-limit-order.sh 0.5 ETH USDC 3200 ethereum 0xYourAddress 86400

# Pre-resolved token address
bash fast-limit-order.sh 100 0xdefa4e8a7bcba345f687a2f1456f5edd9ce97202:18 USDC 15.50 ethereum 0xYourAddress

# Specify all options
bash fast-limit-order.sh 1000 USDC ETH 0.00035 arbitrum 0xYourAddress 604800 keystore mykey

# Using Ledger hardware wallet
bash fast-limit-order.sh 0.5 ETH USDC 3200 base 0xYourAddress 604800 ledger

# Using env private key
bash fast-limit-order.sh 100 LINK USDC 15.50 polygon 0xYourAddress 2592000 env

Step 2: Parse the Output

On success (ok: true):

{
  "ok": true,
  "chain": "arbitrum",
  "chainId": "42161",
  "orderId": "abc123...",
  "maker": "0xYourAddress",
  "makerAsset": {
    "symbol": "USDC",
    "address": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
    "decimals": 6,
    "isNative": false
  },
  "takerAsset": {
    "symbol": "WETH",
    "address": "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
    "decimals": 18,
    "isNative": false
  },
  "order": {
    "makingAmount": "1000",
    "makingAmountWei": "1000000000",
    "takingAmount": "0.35",
    "takingAmountWei": "350000000000000000",
    "targetPrice": "0.00035",
    "expiredAt": 1741564800
  },
  "contract": "0xcab2FA2eeab7065B45CBcF6E3936dDE2506b4f6C",
  "allowanceStatus": "sufficient",
  "allowance": "115792089237316195423570985008687907853269984665640564039457584007913129639935",
  "walletMethod": "keystore"
}

On error (ok: false):

{
  "ok": false,
  "error": "Token 'FAKECOIN' not found on ethereum. Verify the symbol or provide a contract address."
}

Step 3: Format the Output

IMPORTANT: Do not duplicate output. The script's raw output (stderr log lines and stdout JSON) is already visible to the user from the Bash tool call in Step 1. Do NOT echo, quote, or re-display the raw script output. Only present the formatted summary below, which extracts key fields from the JSON. If you repeat the raw output AND show the formatted summary, the user sees every line twice.

On success, present:

## Limit Order Created

**Sell {order.makingAmount} {makerAsset.symbol} for {order.takingAmount} {takerAsset.symbol}** on {chain}

| Detail | Value |
|---|---|
| Order ID | `{orderId}` |
| You sell | {order.makingAmount} {makerAsset.symbol} |
| You receive | {order.takingAmount} {takerAsset.symbol} |
| Target price | 1 {makerAsset.symbol} = {order.targetPrice} {takerAsset.symbol} |
| Expires | {order.expiredAt as human-readable date} |
| Chain | {chain} (Chain ID: {chainId}) |
| Allowance | {allowanceStatus} |

> ⚠️ This order was created immediately without confirmation. If this was a mistake, cancel it: "cancel limit order {orderId} on {chain} from {maker}"

If allowanceStatus is approved, note that the script auto-approved the DSLOProtocol contract during this run. The approval transaction used gas from the maker's wallet.

On error, present the error message and suggest fixes based on the error content.

Environment Variables

Supported Chains (17)

See ${CLAUDE_PLUGIN_ROOT}/references/supported-chains.md for the full chain list. All Aggregator chains except MegaETH are supported.

Note: Limit orders are not supported on megaeth. If the user requests megaeth, inform them and suggest using a swap instead.

Important Notes

• DANGEROUS: This skill signs and creates the order IMMEDIATELY without any review step
• Signing authorizes spending: Signing an EIP-712 message authorizes the limit order contract to spend your tokens when a taker fills the order
• Gasless creation: No gas is required to create a limit order (signed off-chain). Gas is only needed for token approval and hard cancellation.
• Auto-approval: The script checks token allowance before signing and automatically approves the DSLOProtocol contract if insufficient. This costs gas. The approval amount matches the exact makingAmount.
• Balance check: The script verifies the maker has sufficient token balance before proceeding. The KyberSwap API rejects orders where makingAmount > balance with a cryptic "Input is out of range: makingAmount" error — the script catches this early with a clear message.
• Ledger/Trezor: Still requires physical button press on the device for the EIP-712 signature
• Order persistence: Once created, the order remains active until filled, cancelled, or expired
• Cancel if needed: Use /limit-order to query and cancel orders
• For safer order creation, use /limit-order which includes review and confirmation steps
• DSLOProtocol contract: 0xcab2FA2eeab7065B45CBcF6E3936dDE2506b4f6C (verified via API at runtime)
• Native token address: 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE

Common Errors

Pre-Flight Errors (no order created, no signature made)

These errors mean the script exited before signing. No order was submitted.

Post-Signing Errors (signature made, order may or may not be created)

Troubleshooting

For errors not covered above (full API error catalog, advanced debugging), refer to ${CLAUDE_PLUGIN_ROOT}/skills/error-handling/SKILL.md.

Common script-level errors:

Order not being filled after creation?

• Verify the target price is realistic relative to the current market price.
• Ensure the maker still has sufficient makerAsset balance (balance may have changed since order creation).
• Check allowanceStatus in the script output — should be sufficient or approved.
• Check that the order has not expired.