gosh-sh

Deposit onto DEXDO on Acki Nacki Shellnet by creating exactly the PrivateNotes the user asks for — any count, of any currency (NACKL / SHELL / USDC) at any nominal (e.g. "3 notes of 10000 NACKL", or one note per currency) — from an ALREADY-DEPLOYED multisig. The multisig is an INPUT, supplied either as a 12-word seed phrase or as a key pair (keys.json file or 64-hex secret key); the skill re-derives the address, funds the wallet with the needed currencies from the public giver, then deploys and funds each PrivateNote (each with its own random key). Load when the user wants to deposit, create one or more PrivateNotes, fund notes, or trade — and already has a multisig (if they don't, run `dexdo-deploy-multisig-shellnet` first).

Read DEX.DO market data and a trader's own orders/stakes, and present it to the user as clean tables. Covers active markets to stake/trade, the order book (depth) for a symbol, the market price (best bid/ask/mid/spread + last trade), the user's open orders, the user's order history (all via the indexer/read REST API), and the user's on-chain stakes per market (via the dexdo SDK CLI). Load when the user asks to see markets, "where can I stake/bet", an order book, a price/quote for a symbol, "my open orders", "my order history", or "my stakes / my bets" on DEX.DO. Read-only — never places or cancels orders or stakes (that's the `dexdo-trading` skill).

Close out a DEX.DO trading PrivateNote completely and sweep all funds back to the multisig wallet. Cancels every resting order, recovers stakes from still-open STAKING markets, merges held outcome tokens back into collateral (and claims resolved/cancelled markets), then withdraws all free collateral from the note to the multisig. Load when the user wants to "exit everything", "close all my positions and withdraw", "cash out", "total withdraw", or wind a note down before a network restart. Spends real funds and is destructive (drains the note) — confirms before the final withdraw.

Place manual trades on DEX.DO prediction markets. Two distinct paths by market phase. STAKING phase — stake on an outcome (a real bet on a side) via the on-chain SDK binary (NOT the REST API, which has no staking endpoint). TRADING phase — order-book actions via the signed REST API: a market/limit order on an outcome, a full split (buyFullSet), and cancel. Load when the user wants to stake/bet on an outcome, "fullsplit", place/cancel an order, or take a position on DEX.DO. Spends real funds, so it confirms parameters before submitting. For read-only views (markets, depth, price, my orders) use the `dexdo-market-data` skill.

Register a deployed-and-funded PrivateNote with the DEX.DO backend to get an API credential (apiKey + apiSecret) for the REST API. This is the bridge between onboarding (deploy/deposit a note on-chain) and using the API (signed reads in dexdo-market-data, REST orders in dexdo-trading). It is a deliberate security step — registering delegates the note's private key to the backend. Load when the user wants to "register my note / account", "get API keys", "connect my note to the API", or before any signed REST call when no creds.json exists yet.

Deploy and fund a single-custodian Multisig wallet on Acki Nacki Shellnet — install tvm-cli, generate a 12-word seed + keypair, fund the precomputed address from the public giver, and deploy the wallet until it is Active. The output (seed phrase + keypair + address) is the INPUT to the deposit skill (`dexdo-deposit-shellnet`). Load when the user wants to create/deploy a multisig wallet on Shellnet, get a Shellnet wallet for DEXDO, or run the multisig deploy flow.

Core reviewer role for Marshall TDD pipeline. Load when reviewing code, writing prompts, managing tester and coder agents, or after context compaction.

Guides a BUYER end-to-end through buying model inference on the dexdo market (real shellnet) -- install the client, deploy a wallet-funded private note, prepare the note key, receive the deal address from the seller (market.json or token_contract), read the real price with `dexdo market`/`dexdo quote`, fill the required failure policy (`dexdo policy init --role buyer`), run `dexdo buyer --local-listen` (places the buy and brings up a local OpenAI-compatible endpoint), use the purchased model from any OpenAI client (curl / OPENAI_BASE_URL), and check by-fact accounting (`dexdo status`/`dexdo history`) -- how much SHELL was paid, how many ticks were received, and what is locked. Load this when the user wants to BUY a model, connect to a seller, use someone else's model locally, or check what they paid for. For the seller side, use the `dexdo-sell-model` skill.

Install and verify the dexdo CLI so an agent (or a fresh machine) is ready to sell or buy model inference on the dexdo market (real Acki Nacki shellnet). Covers the one-line installer (or a source build), putting `dexdo` on PATH, fetching the deployed-contracts manifest, verifying with `dexdo --version` / `dexdo doctor`, and the prerequisites (a funded multisig wallet + seed, a model access key, `dexdo policy init`) needed before running the seller or buyer. Load this to get `dexdo` installed and green from scratch; then use the `dexdo-sell-model` skill to sell or `dexdo-buy-model` to buy.

Guides a SELLER end-to-end through selling model inference on the dexdo market (real shellnet) -- install the client, deploy a wallet-funded private note, configure the model access key and models.json, read the current price with `dexdo market`, provision a per-deal market (`dexdo provision` -> market.json), fill the required failure policy (`dexdo policy init --role seller`), run the `dexdo seller` gateway (posts the offer, forces the model, proxies the real upstream, streams tick by tick), hand the deal address to the buyer, and check by-fact accounting (`dexdo status`/`dexdo monitor`) -- how many ticks were delivered and how much SHELL was received. Load this when the user wants to SELL access to their model, stand up a seller gateway, serve buyers, or check revenue and delivered tokens. For the buyer side, use the `dexdo-buy-model` skill.