> ## Documentation Index
> Fetch the complete documentation index at: https://docs.eco.com/llms.txt
> Use this file to discover all available pages before exploring further.

# sauce pot

> Find the Pot your cooks run in. On an EVM chain, deploy it before funding it from another wallet.

`sauce pot` prints an owner's Pot address and its unsigned deployment, sends the deployment with `--deploy`, and keeps a record of the Pots you deploy.

## Synopsis

```bash theme={null}
sauce pot --chain <slug|id> --owner <address> [--salt <label> | --salt-hex <bytes32>] [--deploy …]
sauce pot <list | import> [options]
sauce pot list [--chain <slug|id>] [--owner <address>] [--pots <dir>] [--json]
sauce pot import --chain <slug|id> --pot <address> [options]
sauce pot import --chain <slug|id> --owner <address> [--salt <label> | --salt-hex <bytes32>] [options]
```

## Description

A [Pot](https://docs.eco.com/sauce/pot.md) is the owner's account that runs programs. Its address is known before it exists: on an EVM chain it is the CREATE2 address the released Kitchen derives from the owner and a salt, and on Solana it is the Kitchen's program-derived address over the same two values. The default salt is zero, the one Pot an owner has by default. `--salt <label>` names another Pot of the same owner, with salt `keccak256(label)`.

A Pot address depends on the Kitchen release the SDK uses.

Deploying a Pot by hand is optional. `sauce run` deploys it when it first needs it, asking first or with `-y`, and `sauce tx` puts the deployment in front of the cook when it reads the chain. On an EVM chain, deploy it before you send it funds from another wallet: an undeployed address is only the Kitchen's prediction ([Funding a Pot](https://docs.eco.com/sauce-sdk/cli/funding.md)).

**Without `--deploy`**, the command prints the Pot's address and the unsigned `Kitchen.deployPot` transaction as JSON. It also reads the chain: whether the released engine and Kitchen are deployed there, the Kitchen's execution fee (in wei and in the chain's native coin), and whether the Pot is deployed and whose it is. Read it before you fund the Pot, simulate or send on a chain: only the released Kitchen deploys the Pot, and a program runs only where the release's engine is deployed. That reading goes to stderr and under `deployment` in the JSON. `--offline` skips it, so it does not show whether the Pot can be deployed.

**With `--deploy`**, it sends the deployment, unless the Pot already has code, and waits until the endpoint shows the code. The owner defaults to the signer. Deploying is permissionless on an EVM chain: with `--owner`, the signer sends and pays for another owner's Pot, which belongs to that owner alone. With a signer and no `--owner`, the Pot is the signer's own; a keystore's address field is read without a password where the file has one, and a wallet's address is read without its password.

**On Solana**, the command prints the Pot and its `create_pot` instruction, and lists the Pot's token account for each registered mint except the tokenized stocks: its address, whether it exists and what it holds. The owner signs `create_pot`, so with `--deploy` the signer is the owner.

**The Pot store.** Every Pot a command deploys (`sauce pot --deploy`, a `sauce run` that deploys its Pot first, `sauce send`) is recorded in the Pot store, `~/.sauce/pots` by default, once the chain shows it deployed. A record holds the chain, owner, salt and kind; the Kitchen and the release the Pot was minted under (the engine, and the compiler whose programs it runs); and the deploying transaction. `sauce tx` sends nothing and records nothing.

* `sauce pot list` reads the store and no chain.
* `sauce pot import` records a Pot deployed from another machine or wallet, after reading it from the chain. With `--pot`, the release is identified from the address: the one whose Kitchen and Pot init-code hash produce that address for the Pot's owner and salt. An address no known release produces is refused. With `--owner`, every release's Pot of that owner and salt that has code is recorded. A Solana Pot is found by `--owner` and its salt.

**Supported chains.** The deployment is printed or sent only on Ethereum, Base, Arc and Solana, and the testnets Arc Testnet, Base Sepolia, Ethereum Sepolia, Solana Devnet and Solana Testnet. On a preview chain the command still prints the address and what it read, and replaces the transaction with a refusal that names the supported chains and how to request a chain. Nothing is signed. The release addresses the command reads are on [Deployments](https://docs.eco.com/sauce-sdk/reference/deployments.md).

## The Pot guard

On an EVM chain, before anything is simulated, built or sent, `sauce pot`, `pot --deploy`, `simulate`, `tx`, `run` and `sign` (signing a cook), and the MCP tools that call them, check the Pot against the chain:

* **A Pot not deployed yet must be where the deployed Kitchen puts it.** The command reads the Kitchen's own `predictPot(owner, salt)` and refuses an address other than the one this SDK derives, naming both: `the Kitchen … puts the Pot of owner … and salt … at <its address>, but this SDK has it at <the SDK's>: this SDK does not match the deployed Kitchen …`. A cook sent to an address with no code succeeds, runs nothing and leaves its value at that address, so the command builds none.
* **A deployed Pot must be of this SDK's release.** Its owner, salt and Kitchen are read from it, and its address must be that Kitchen's CREATE2 address under the Pot init-code hash of a release the SDK records. A Pot of another release is refused, naming the compiler, engine and Kitchen it was minted under and the SDK releases that pair with them. Where the command keeps the Pot store, the refusal lists the owner's other Pots on that chain, each with its release.
* **An owner of zero is refused**, online and offline, before anything is built: `Kitchen.deployPot` reverts for that owner. A Pot with no owner is a Shared Pot, which `Kitchen.deploySharedPot(salt)` deploys.
* **Offline, the address is not checked.** `--offline` derives the address from this SDK's release and reads nothing, and `pot`, `tx` and `sign` say so on stderr ([example](#name-a-second-pot-by-a-label-offline)).
* **`sign --cancel` is not held to these checks.** It builds the owner's `invalidateNonces` transactions, which run no program: offline it builds them for any `--owner`, the zero address included.

The same checks run again before each deployment and cook is sent: by `sauce run`, `sauce pot --deploy`, [`sauce send`](https://docs.eco.com/sauce-sdk/cli/send#refuse-a-batch-before-anything-is-sent) and a wallet's send. A plan with a step they refuse is refused before any of its steps is sent, so a transfer into a Pot does not land ahead of a cook that would be refused. The checks trust the endpoint, as every read the command makes does.

## Options

### sauce pot

| Option | Description |
| - | - |
| `--owner <address>` | The Pot's owner. `cook()` accepts calls only from the owner |
| `--chain <slug\|id>` | The chain the Pot is on |
| `--salt <label>` | Name one of the owner's Pots: the salt is `keccak256(label)` |
| `--salt-hex <bytes32>` | Or give the salt exactly |
| `--deploy` | Send the deployment. Needs an endpoint and a signer |
| `--rpc-url <url>` | Your own RPC endpoint for the chain. Default: a built-in public one |
| `--config <file>` | A file of your own endpoints: `{ "rpcUrls": { "<chain id>": "<url>" } }` |
| `--offline` | Read no chain: no endpoint, built-in ones included |
| `--wallet <name>` | Sign with a wallet from the wallet directory ([`sauce wallet`](https://docs.eco.com/sauce-sdk/cli/wallet)), EVM or Solana |
| `--wallets [<dir>]` | The wallet directory. Default: `~/.sauce/wallets` |
| `--password-env <NAME>` | The password is the environment variable `NAME`; no other variable is read |
| `--password-file <path>` | Or the contents of a file only you can read. Without a source, the password is asked for |
| `--password-command <command>` | Or what this command prints, such as a secret manager's CLI |
| `--pots <dir>` | The Pot store, where deployed Pots are recorded. Default: `~/.sauce/pots` |
| `-y, --yes` | Accepted and ignored: `--deploy` is the approval |
| `--auto-approve` | Accepted and ignored: `--deploy` is the approval |
| `--format <json\|cast>` | `json` (default), or a `cast send` line with placeholders for the endpoint and the key |
| `-h, --help` | Show the help |
| `--no-update-check` | Print no notice of a newer `sauce`, and read no registry for one |

#### EVM chains only

| Option | Description |
| - | - |
| `--keystore <path>` | Sign with a JSON keystore (v3), with a password source |
| `--private-key <hex>` | Or sign with a raw key. It lands in your shell history |

#### Solana only

| Option | Description |
| - | - |
| `--keypair <path>` | Sign with a keypair file: a JSON array of 64 bytes |

### sauce pot list

| Option | Description |
| - | - |
| `--chain <slug\|id>` | Only the Pots on this chain |
| `--owner <address>` | Only this owner's Pots |
| `--pots <dir>` | The Pot store. Default: `~/.sauce/pots` |
| `--json` | Print one JSON object instead of text |
| `-h, --help` | Show the help |
| `--no-update-check` | Print no notice of a newer `sauce`, and read no registry for one |

### sauce pot import

| Option | Description |
| - | - |
| `--chain <slug\|id>` | The chain the Pot is on |
| `--owner <address>` | Or its owner, with the salt (default zero): every release's Pot of that owner on the chain |
| `--salt <label>` | Name one of the owner's Pots: the salt is `keccak256(label)` |
| `--salt-hex <bytes32>` | Or give the salt exactly |
| `--rpc-url <url>` | Your own RPC endpoint for the chain. Default: a built-in public one |
| `--config <file>` | A file of your own endpoints: `{ "rpcUrls": { "<chain id>": "<url>" } }` |
| `--offline` | Read no chain: no endpoint, built-in ones included |
| `--pots <dir>` | The Pot store. Default: `~/.sauce/pots` |
| `--json` | Print one JSON object instead of text |
| `-h, --help` | Show the help |
| `--no-update-check` | Print no notice of a newer `sauce`, and read no registry for one |

#### EVM chains only

| Option | Description |
| - | - |
| `--pot <address>` | The Pot, by address |

## Output

`sauce pot` prints JSON on stdout, or a `cast send` line with `--format cast`. Notes and the chain reading go to stderr.

| Field | Contents |
| - | - |
| `chainId`, `pot`, `owner`, `salt`, `kitchen` | The chain, the Pot's address, its owner and salt, and the Kitchen that derives it |
| `to`, `data`, `value` | The unsigned `Kitchen.deployPot(owner, salt)` transaction (EVM) |
| `instruction` | The `create_pot` instruction: program, accounts with roles, data (Solana) |
| `deployment` | What was read: `engine`, `kitchen` (with `executionFee`) and `pot`, each with `deployed` |
| `tokenAccounts` | Solana: the Pot's token account for each registered mint, with `exists` and `balance` |
| `sendCalls` | The same transaction as a batch, for a wallet that sends a batch |
| `refused` | On a preview chain, in place of the transaction: the reason, the supported chains, and the request for the chain |

Exit codes: `0` when the address is printed, a preview-chain refusal included; `1` when the command fails, such as a `pot import` that finds no Pot, or a Pot the guard refuses; `2` for a usage error, such as `--json`, which `sauce pot` does not take, or an owner of zero.

## Examples

### Print a Pot and its deployment on Base

```bash theme={null}
sauce pot --owner 0x1111111111111111111111111111111111111111 --chain base
```

```text theme={null}
On base: the engine <engine address> is deployed; the Kitchen <kitchen address> is deployed, its execution fee 3744785386350 wei (0.00000374478538635 ETH); the Pot 0x6c9175d272D49e6C8C139A3FE6BC6fDb422eD3Fe is NOT deployed.
This is Kitchen.deployPot on the released Kitchen. Any account may send it: the Pot is 0x1111111111111111111111111111111111111111's either way, and it deploys once.
```

```json theme={null}
{
  "chainId": 8453,
  "pot": "0x6c9175d272D49e6C8C139A3FE6BC6fDb422eD3Fe",
  "owner": "0x1111111111111111111111111111111111111111",
  "salt": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "kitchen": "<kitchen address>",
  "to": "<kitchen address>",
  "data": "0xff9763ac00000000000000000000000011111111111111111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000",
  "value": "0x0",
  "deployment": {
    "engine": { "address": "<engine address>", "deployed": true },
    "kitchen": { "address": "<kitchen address>", "deployed": true, "executionFee": "3744785386350" },
    "pot": { "address": "0x6c9175d272D49e6C8C139A3FE6BC6fDb422eD3Fe", "deployed": false }
  },
  "sendCalls": {
    "chain": "base",
    "calls": [{ "to": "<kitchen address>", "value": "0x0", "data": "0xff9763ac…" }]
  }
}
```

The stderr lines come first. `data` is `deployPot(owner, salt)`.

### Name a second Pot by a label, offline

```bash theme={null}
sauce pot --owner 0x1111111111111111111111111111111111111111 --chain base --salt treasury --offline
```

```text theme={null}
This is Kitchen.deployPot on the released Kitchen. Any account may send it: the Pot is 0x1111111111111111111111111111111111111111's either way, and it deploys once.
The Pot's address is NOT checked against the deployed Kitchen: no RPC endpoint was given. A Kitchen of another release puts the Pot elsewhere, and a cook sent to an address with no code succeeds, runs nothing and keeps its value. Pass an RPC endpoint to check.
```

```json theme={null}
{
  "chainId": 8453,
  "pot": "0x0828c60115616802F1D750E9752f9E0392FCec99",
  "owner": "0x1111111111111111111111111111111111111111",
  "salt": "0xcbd818ad4dd6f1ff9338c2bb62480241424dd9a65f9f3284101a01cd099ad8ac",
  "kitchen": "<kitchen address>",
  …
}
```

The salt is `keccak256("treasury")`. With `--offline`, no `deployment` is read and the address is not checked against the deployed Kitchen. Run the command with an endpoint before you send funds to the address.

### Refuse an owner of zero

```bash theme={null}
sauce pot --owner 0x0000000000000000000000000000000000000000 --chain base --offline
```

```text theme={null}
sauce pot: Kitchen.deployPot reverts for the owner 0x0000000000000000000000000000000000000000: a Pot with no owner is a Shared Pot, which Kitchen.deploySharedPot(salt) deploys. Nothing was simulated, built or sent.
Run `sauce pot --help` for usage.
```

The command exits `2`, offline and online alike. `tx`, `simulate` and `sign` (signing a cook) refuse `--owner` the zero address with the same message. `sauce run` cooks as its signer, so it refuses an `--owner` other than the signer first, the zero address included: `--owner 0x0000000000000000000000000000000000000000 is not the signer, <signer>: cook() is onlyOwner, so the Pot a run cooks on must be the signer's. Leave --owner out to use the signer's own.` The MCP server's `sauce_pot`, `sauce_tx`, `sauce_actions`, `sauce_simulate` and `sauce_signed_cook` refuse `owner` the zero address.

### Print the deployment as a cast command

```bash theme={null}
sauce pot --owner 0x1111111111111111111111111111111111111111 --chain base --offline --format cast
```

```text theme={null}
cast send <kitchen address> 0xff9763ac00000000000000000000000011111111111111111111111111111111111111110000000000000000000000000000000000000000000000000000000000000000 --rpc-url <RPC_URL> --private-key <PRIVATE_KEY>
```

The command never fills in `<RPC_URL>` or `<PRIVATE_KEY>`.

### Read the fee on Arc

On Arc the native coin is USDC, so the fee prints in USDC beside wei:

```bash theme={null}
sauce pot --owner 0x1111111111111111111111111111111111111111 --chain arc
```

```text theme={null}
On arc: the engine <engine address> is deployed; the Kitchen <kitchen address> is deployed, its execution fee 10000000000000000 wei (0.01 USDC); the Pot 0x6c9175d272D49e6C8C139A3FE6BC6fDb422eD3Fe is NOT deployed.
This is Kitchen.deployPot on the released Kitchen. Any account may send it: the Pot is 0x1111111111111111111111111111111111111111's either way, and it deploys once.
On arc a transaction is included only with a maxFeePerGas (or gasPrice) of at least 20 gwei, the chain's minimum base fee: sign each with a fee cap at or above it, or it is never mined.
```

The Pot address is the same on every EVM chain for the same owner and salt.

### Print a Pot on Solana

```bash theme={null}
sauce pot --owner CEJT6RKEqjgbg7rCpnPZwxNCDie1PmdEWKrRZzqJHyCK --chain solana
```

```text theme={null}
…
The Pot's PYUSD account, --account NAME=pot:PYUSD: 3tVooXfQHD6eYXjFUhF4bSoiiN6KsUp8DGghr866Lqj2, not created yet (a wallet's SPL transfer to the Pot creates it)
The Pot's USDC account, --account NAME=pot:USDC: QWXuvZG5Jyu5t1K2e2wSbncK2eAEmpJzK95iDRdU1pq, not created yet (a wallet's SPL transfer to the Pot creates it)
…
```

```json theme={null}
{
  "chain": "solana",
  "pot": "CBbaW8YhkhjyVn7rKLa7a9XNo4gaSffeQzMoo9vbMom4",
  "owner": "CEJT6RKEqjgbg7rCpnPZwxNCDie1PmdEWKrRZzqJHyCK",
  "salt": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "kitchen": "<kitchen program id>",
  "engine": "<engine program id>",
  "instruction": {
    "programAddress": "<kitchen program id>",
    "accounts": [
      { "address": "CEJT6RKEqjgbg7rCpnPZwxNCDie1PmdEWKrRZzqJHyCK", "role": "writable signer" },
      { "address": "<engine program id>", "role": "readonly" },
      { "address": "CBbaW8YhkhjyVn7rKLa7a9XNo4gaSffeQzMoo9vbMom4", "role": "writable" },
      { "address": "11111111111111111111111111111111", "role": "readonly" }
    ],
    "data": "2JVQ8ydRkys32qmdrGGmrxfoEhuxRvKSm7q2gkTodF2bunLDP4XZXAxA5mmHq"
  },
  "deployment": { … },
  "tokenAccounts": [
    {
      "symbol": "PYUSD",
      "mint": "2b1kV6DkPAnxd5ixfnxCpjxmKwqjjaYmCZfHsFu24GXo",
      "decimals": 6,
      "tokenProgram": "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb",
      "account": "3tVooXfQHD6eYXjFUhF4bSoiiN6KsUp8DGghr866Lqj2",
      "exists": false,
      "balance": null
    },
    …
  ]
}
```

### Read a preview-chain refusal

```bash theme={null}
sauce pot --owner 0x1111111111111111111111111111111111111111 --chain optimism
```

```text theme={null}
building the Pot's deployment is refused: it involves optimism (Optimism, chain id 10), a preview chain. The sauce command and its MCP server build and send transactions only on Ethereum, Base, Arc and Solana, and the testnets Arc Testnet, Base Sepolia, Ethereum Sepolia, Solana Devnet and Solana Testnet. On a preview chain they build and send none. A program still compiles there and globals, price, pools and pot's prediction still read; simulate runs wherever the release is deployed on the chain, and says so where it is not.
```

The JSON carries the address and the chain reading, and `refused` in place of `to`, `data` and `value`. Its `supportedChains` lists the nine supported chains, and `previewChains` the request to file for Optimism.

### List and import Pots

```bash theme={null}
sauce pot list --pots ./pots
```

```text theme={null}
No Pots in ./pots.
```

```bash theme={null}
sauce pot import --chain base --owner 0x1111111111111111111111111111111111111111 --pots ./pots
```

```text theme={null}
sauce pot import: 0x1111111111111111111111111111111111111111 has no Pot at salt 0x0000000000000000000000000000000000000000000000000000000000000000 on base under any release this sauce knows
```

The import exits `1`: that owner has no deployed Pot on Base.

## Next steps

* [Pot](https://docs.eco.com/sauce/pot.md): what a Pot is and who may cook on it.
* [Kitchen](https://docs.eco.com/sauce/kitchen.md): the contract that derives and deploys Pots.
* [`sauce tx`](https://docs.eco.com/sauce-sdk/cli/tx): a cook plan that deploys the Pot first.
* [`sauce run`](https://docs.eco.com/sauce-sdk/cli/run): deploys the Pot when it first needs it.
* [Deployments](https://docs.eco.com/sauce-sdk/reference/deployments.md): the release addresses this command reads.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.