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

# Maker quickstart

> Deploy a provider on Base Sepolia, fund it, stream a ladder, read it back onchain.

| Requirement               | Note                                                         |
| ------------------------- | ------------------------------------------------------------ |
| Foundry (`forge`, `cast`) |                                                              |
| Node 20+                  | for the streaming client                                     |
| Base Sepolia RPC URL      |                                                              |
| Deployer key              | a little Base Sepolia ETH                                    |
| Signing key               | signs your ladders; can equal the deployer key while testing |

```bash theme={null}
export RPC_URL=<your Base Sepolia RPC>
export EXECUTOR=0x000000fFA5f8Ae192Ab65204f9B7E062CbF4e05D
export VENUE=0x00000035a8a58f704ab0D567D6c67A486428E35a
export WETH=0x8b414aD7005EeFd315aF2A16538885Eae229bab7   # MockWETH, 18 decimals, mintable
export USDC=0xAbbdbbbd6d56593A9c5656c06cB30D61E4a544Df   # MockUSDC, 18 decimals, mintable
export SIGNER=<address of your signing key>
export OWNER=<address that will own the provider>
```

<Steps>
  <Step title="Deploy your provider">
    The provider is the contract that holds your inventory. Use the reference implementation as is: copy [`IMMProvider.sol`](https://github.com/bcnmy/propamm-protocol-docs/blob/main/docs/examples/IMMProvider.sol) to `src/interfaces/IMMProvider.sol` and [`BasicMMProvider.sol`](https://github.com/bcnmy/propamm-protocol-docs/blob/main/docs/examples/BasicMMProvider.sol) to `src/periphery/examples/BasicMMProvider.sol` in a Foundry project, then:

    ```bash theme={null}
    forge install vectorized/solady
    forge create src/periphery/examples/BasicMMProvider.sol:BasicMMProvider \
      --rpc-url $RPC_URL --interactive --broadcast \
      --constructor-args $SIGNER $EXECUTOR $OWNER
    export PROVIDER=<the deployed address>
    ```

    `--interactive` prompts for the deployer key. Details and custom contracts: [Provider contract](/propamm/makers/provider).
  </Step>

  <Step title="Fund it">
    Inventory is the output token of each direction you quote:

    ```bash theme={null}
    cast send $USDC "mint(address,uint256)" $PROVIDER 1000000000000000000000000 --rpc-url $RPC_URL --interactive   # 1,000,000 MockUSDC
    cast send $WETH "mint(address,uint256)" $PROVIDER 1000000000000000000000    --rpc-url $RPC_URL --interactive   # 1,000 MockWETH
    ```
  </Step>

  <Step title="Register">
    Email [support@biconomy.io](mailto:support@biconomy.io):

    | Field      | Example                    |
    | ---------- | -------------------------- |
    | Signer     | `$SIGNER`                  |
    | Provider   | `$PROVIDER`                |
    | Chain      | 84532                      |
    | Directions | WETH to USDC, USDC to WETH |

    Until registration the stream returns `UNREGISTERED_MARKET_MAKER`.
  </Step>

  <Step title="Stream your ladder">
    Connect to `wss://propamm-staging.biconomy.io`, subscribe as your signer, and send a signed `price-ladder` per direction. Both mock tokens have 18 decimals, so 2,000 USDC per WETH is `2000e18` for WETH to USDC and `5e14` for USDC to WETH.

    ```json theme={null}
    { "type": "subscribe", "data": { "type": "price-ledger", "mm": "<SIGNER>" } }
    ```

    ```json theme={null}
    {
      "type": "price-ladder",
      "payload": {
        "mm": "<SIGNER>",
        "provider": "<PROVIDER>",
        "tokenIn": "0x8b414aD7005EeFd315aF2A16538885Eae229bab7",
        "tokenOut": "0xAbbdbbbd6d56593A9c5656c06cB30D61E4a544Df",
        "levels": [
          { "size": "1000000000000000000", "price": "1998000000000000000000" },
          { "size": "3000000000000000000", "price": "1995000000000000000000" }
        ],
        "nonce": "<unix milliseconds>",
        "expiresAt": "<unix seconds, now + 30>",
        "signature": "<EIP-712 signature>",
        "chainId": 84532
      }
    }
    ```

    Each accepted message returns `{ "type": "ack" }`. Send a new ladder with a higher nonce on every price change. Runnable client: [Stream prices](/propamm/makers/streaming).
  </Step>

  <Step title="Read your ladder back">
    After Biconomy commits it, `board()` returns your levels with `remaining` equal to your top size:

    ```bash theme={null}
    cast call $VENUE "board(address,address,address)(uint256[],uint256[],uint256,uint256,uint256)" $SIGNER $WETH $USDC --rpc-url $RPC_URL
    cast call $VENUE "quote(address,address,uint256)(uint256)" $WETH $USDC 1000000000000000000 --rpc-url $RPC_URL
    ```

    <Note>
      Empty arrays and `remaining == 0`: not committed yet, expired, or (Reprice) no live anchor. Check the acks and that `expiresAt` leaves time for the commit.
    </Note>
  </Step>

  <Step title="Watch a fill">
    A fill calls `executeSwap` on your provider and emits `MMFillExecuted` on the executor. `board()` then shows `filled` up and `remaining` down.
  </Step>
</Steps>

## Next

* [Stream prices](/propamm/makers/streaming): Rewrite and Reprice, nonces and expiry, a runnable client.
* [Risk and inventory](/propamm/makers/risk-and-inventory): the four protections, how much a ladder can fill, how to stop.
* Mainnet: change the endpoint to `wss://propamm.biconomy.io`, the `chainId` and the token addresses. Contract addresses are the same, see [Addresses](/propamm/reference/addresses).