started CREATE2 work and abandoned it

.gitignore

@@ -1,14 +1,14 @@
-cache/
-out/
+/cache/
+/out/
 
-chain.json
+/log/
+/.env
+/.env-*
+/.idea/
+package-lock.json
+/broadcast
 
-docs/
-log/
-.env
-.idea
+*secret*
 
-# Ignores development broadcast logs
-!/broadcast
-/broadcast/*/31337/
-/broadcast/**/dry-run/
+# This file is only used by DeployMock
+/liqp-deployments.json

LICENSE.txt

@@ -0,0 +1,3 @@
+Copyright ©2025 Dexorder LLC. All rights reserved.
+
+No license is provided. This source code is viewable for verification purposes only.

README.md

@@ -0,0 +1,96 @@
+# Introduction
+
+[Liquidity Party](https://liquidity.party) is a new game-theoretic multi-asset AMM based on this research paper:
+
+[Logarithmic Market Scoring Rules for Modular Combinatorial Information Aggregation](https://mason.gmu.edu/~rhanson/mktscore.pdf) (R. Hanson, 2002)
+
+Our formulation and implementation is described in the [Liquidity Party whitepaper.](doc/whitepaper.md)
+
+A Logarithmic Market Scoring Rule (LMSR) is a pricing formula for AMM's that know only their current asset inventories
+and no other information, naturally supporting multi-asset pools.
+
+Compared to Constant Product markets, LMSR offers:
+
+1. Less slippage than Constant Product for small and medium trade sizes
+2. N-asset pools for trading long-tail pairs in a single hop
+3. Lower fees (smaller spread)
+
+
+## Deeper Liquidity
+
+According to game theory, the initial price slope of a Constant Product AMM is too steep, overcharging takers
+with too much slippage at small and medium trade sizes. LMSR pools offer less slippage and cheaper
+liquidity for the small and medium trade sizes used by real traders.
+
+
+## Multi-asset
+
+Naturally multi-asset, Liquidity Party altcoin pools provide direct, one-hop swaps on otherwise illiquid multi-hop pairs. Pools will quote any pair combination available in the pool:
+
+| Assets | Pairs | Swap Gas |  Mint Gas |
+|-------:|------:|---------:|----------:|
+|      2 |     1 |  131,000 |   143,000 |
+|     2* |     1 |  118,000 |   143,000 |
+|     10 |    45 |  142,000 |   412,000 |
+|     20 |   190 |  157,000 |   749,000 |
+|     50 |  1225 |  199,000 | 1,760,000 |
+|    100 |  4950 |  269,000 | 2,684,000 |
+
+\* Stablecoin pair pool optimization
+
+Liquidity Party aggregates scarce, low market cap assets into a single pool, providing one-hop liquidity for exotic pairs without fragmenting LP assets. CP pools would need 190x the LP assets to provide the same pairwise liquidity as a single 20-asset Liquidity Party pool, due to asset fragmentation.
+
+## Lower Fees
+
+Since market makers offer the option to take either side of the market, they must receive a subsidy or charge a fee (spread) to compensate for adverse selection (impermanent loss). By protecting LP's against common value-extraction scenarios, LMSR pools have a reduced risk premium resulting in lower fees for takers.
+
+### Minimized Impermanent Loss
+All AMM's suffer from Impermanent Loss (IL), also known as adverse selection or toxic order flow. Liquidity
+Party uses game theory to minimize IL for LPs, by charging lower fees to small legitimate traders and
+higher fees to large adversarial traders during market dislocations. This means a higher effective rate
+for LP's and cheaper swaps for legitimate small traders.
+
+Liquidity Party swaps guarantee a bounded maximum loss to LP's of `κ\*S\*ln(N)` where `κ` is
+the pool's liquidity parameter, `S` is the total size of the pool, and `N` is the
+number of assets in the pool.
+
+### No Intra-Pool Arbitrage
+Other multi-asset systems can provide inconsistent price quotes, allowing arbitragers to
+extract value from LP's by _trading assets inside the same pool against each other._ With Liquidity
+Party, no intra-pool arbitrage is possible, because the mathematics guarantee fully consistent price
+quotes on all pairs in the pool.
+
+# Installation
+
+1. Install [Foundry](https://getfoundry.sh/) development framework.
+2. Update dependencies with `forge install`
+3. Run `bin/mock` to launch a test environment running under `anvil` on `localhost:8545`. The mock environment will create several example pools along with mock ERC20 tokens that can be minted by anyone in any amount.
+
+# Integration
+
+Deployment addresses for each chain may be found in `deployment/liqp-deployments.json`, and the `solc` output including ABI information is stored under `deployment/{chain_id}/v1/...`
+
+The primary entrypoint for all Liquidity Party actions is the [PartyPlanner](src/IPartyPlanner.sol) contract, which is a singleton per chain. The `PartyPlanner` contract not only deploys new pools but also indexes the pools and their tokens for easy metadata discovery. After a pool is created or discovered using the `PartyPlanner`, it can be used to perform swaps, minting, and other actions according to the [IPartyPool](src/IPartyPlanner.sol) interface. Due to contract size limitations, most view methods for prices and swaps are available from a separate singleton contract, [PartyInfo](src/IPartyInfo.sol).
+
+
+# Implementation Notes
+
+## Non-upgradable Proxy
+Due to contract size constraints, the `PartyPool` contract uses `DELEGATECALL` to invoke implementations on the singleton [PartyPoolSwapImpl](src/PartyPoolSwapImpl.sol) and [PartyPoolMintImpl](src/PartyPoolMintImpl.sol) contracts. This proxy pattern is NOT upgradable and the implementation contract addresses used by the pool are immutable. Views implemented in `PartyInfo` have no delegation but simply accept the target pool as an argument, calculating prices etc. from public getters.
+
+## Admin-Only Deployment
+`PartyPlanner` allows only the admin to deploy new pools. This decision was made because Liquidity Party is a new protocol that does not support non-standard tokens such as fee-on-transfer tokens or rebasing tokens, and the selection of the `kappa` liquidity parameter is not straightforward for an average user. We hope to offer a version of Liquidity Party in the future that allows regular users to create their pools.
+
+## Killable Contracts
+PartyPools may be "killed" by their admin, in which case all swaps and mints are disabled, and the only modifying function allowed to be called is `burn()` to allow LP's to safely withdraw their funds. Killing is irreversible and intended to be used as a last-ditch safety measure in case a critical vulnerablility is discovered.
+
+## Fee Mechanisms
+Each asset in the pool has a fee associated with it, which is paid when that asset is involved in a swap.
+
+The fee for a swap is the input asset fee plus the output asset fee, but this total fee percentage is taken only from the input amount, prior to the LMSR calculation. This results in more of the input asset being collected by the pool compared to the value of the output asset removed. In this way, the LP holders accumulate fee value implicitly in their prorata share of the pool's total assets.
+
+For a swap-mint operation, only the input asset fee is charged on the input token. For a burn-swap, only the output asset fee is charged on the output token.
+
+Flash loans are charged a single fee, the flash fee, no matter what asset is loaned.
+
+Protocol fees are taken as a fraction of any LP fees earned, rounding down in favor of the LP stakers. Protocol fees accumulate in a separate account in the pool until the admin sends a collection transaction to sweep the fees. While protocol fees are waiting to be collected, those funds do not participate in liquidity operations or earn fees.

bin/mock

@@ -1,28 +1,32 @@
 #!/bin/bash
-CODE_SIZE_LIMIT=65000
 # Dev account #0
 #PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
 # Dev account #4
 PRIVATE_KEY=0x47e179ec197488593b187f80a00eb0da91f1b9d0b13f8733639f19c30a34926a
 
+set -euo pipefail
+
 # Function to cleanup processes
 cleanup() {
-    kill $ANVIL_PID 2>/dev/null
+    if [[ -n "${ANVIL_PID:-}" ]] && kill -0 "$ANVIL_PID" 2>/dev/null; then
+        kill "$ANVIL_PID" 2>/dev/null || true
+        sleep 0.2
+        kill -9 "$ANVIL_PID" 2>/dev/null || true
+    fi
 }
 
-err() {
-  cleanup
-  exit $1
-}
-
-# Set up trap to handle script exit
+# Ensure cleanup on any exit
 trap cleanup EXIT
+# On Ctrl-C or TERM: exit immediately (will trigger EXIT trap -> cleanup)
+trap 'exit 130' INT
+trap 'exit 143' TERM
 
 # Create log directory if it doesn't exist
 mkdir -p log
 
 # Run anvil in background and redirect output to log file
-anvil --code-size-limit ${CODE_SIZE_LIMIT} | tee log/anvil.txt &
+# shellcheck disable=SC2086
+anvil --disable-block-gas-limit | tee log/anvil.txt &
 ANVIL_PID=$!
 
 # Function to check if string exists in file
@@ -43,9 +47,13 @@ while ! check_string "Listening on" "log/anvil.txt"; do
     fi
 done
 
-forge script --code-size-limit ${CODE_SIZE_LIMIT} --private-key ${PRIVATE_KEY} DeployMock --fork-url http://localhost:8545 --broadcast "$@"  || err 1
+forge script  --private-key ${PRIVATE_KEY} DeployMock --fork-url http://localhost:8545 --broadcast "$@" || exit 1
+
+if [ "${1:-}" = "slow" ]; then
+    echo "SLOW MODE: Setting mining mode to 12-second intervals."
+    cast rpc evm_setIntervalMining 12
+fi
 
 echo "Press Ctrl+C to exit..."
-while true; do
-    sleep 1
-done
+# Wait for the anvil process; Ctrl-C will interrupt 'wait' and trigger cleanup via traps
+wait "$ANVIL_PID"

bin/sepolia-deploy

@@ -0,0 +1,145 @@
+#!/bin/bash
+
+CHAINID=11155111
+DEPLOY_SCRIPT=DeploySepolia
+
+if [ -f ".env-secret" ]; then
+  echo "Reading environment from .env-secret"
+  set -a
+  source .env-secret
+  set +a
+fi
+
+if [ -z "$SEPOLIA_RPC_URL" ]; then
+  echo "Usage: SEPOLIA_RPC_URL environment variable must be set"
+  exit 1
+fi
+RPC=${SEPOLIA_RPC_URL}
+
+if [ -z "$PRIVATE_KEY" ]; then
+  echo "Usage: PRIVATE_KEY environment variable must be set"
+  exit 1
+fi
+
+if [ -z "$ETHERSCAN_API_KEY" ]; then
+  echo "Usage: ETHERSCAN_API_KEY environment variable must be set"
+  exit 1
+fi
+
+if [ "$1" == "broadcast" ]; then
+  # BROADCAST=(--broadcast --verify --etherscan-api-key "$ETHERSCAN_API_KEY")
+  # use --slow to avoid triggering rate limits
+  BROADCAST=(--slow --broadcast --verify --etherscan-api-key "$ETHERSCAN_API_KEY")
+else
+  BROADCAST=()
+fi
+
+
+if [ "$1" != "record" ]; then
+  forge clean
+  forge script --fork-url "$RPC" --private-key "$PRIVATE_KEY" "${BROADCAST[@]}" script/DeploySepolia.sol || exit 1
+fi
+
+# Update the liqp-deployments.json file if the contracts were broadcast or record was requested
+
+if [ "$1" == "broadcast" ] || [ "$1" == "record" ]; then
+  METADATA_FILE=deployment/liqp-deployments.json
+else
+  METADATA_FILE=./liqp-deployments.json
+fi
+
+address() {
+  if [ -z "$1" ]; then
+    echo ""
+  else
+    cast --to-checksum-address "$1"
+  fi
+}
+
+contract() {
+  address "$(jq -r ".transactions[] | select(.contractName == \"$1\" and .transactionType == \"CREATE\") | .contractAddress" broadcast/${DEPLOY_SCRIPT}.sol/${CHAINID}/run-latest.json)"
+}
+
+token() {
+  address "$(jq -r ".transactions[] | select(.contractName == \"MockERC20\" and .transactionType == \"CREATE\" and (.arguments | contains([\"$1\"]))) | .contractAddress" broadcast/${DEPLOY_SCRIPT}.sol/${CHAINID}/run-latest.json)"
+}
+
+PARTY_PLANNER=$(contract PartyPlanner)
+PARTY_INFO=$(contract PartyInfo)
+PARTY_POOL_MINT_IMPL=$(contract PartyPoolMintImpl)
+PARTY_POOL_SWAP_IMPL=$(contract PartyPoolSwapImpl)
+PARTY_POOL_DEPLOYER=$(contract PartyPoolDeployer)
+PARTY_POOL_BP_DEPLOYER=$(contract PartyPoolBalancedPairDeployer)
+
+USXD=$(token USXD)
+FUSD=$(token FUSD)
+DIVE=$(token DIVE)
+BUTC=$(token BUTC)
+WTETH=$(token WTETH)
+
+OUT=deployment/$CHAINID/v1
+mkdir -p $OUT
+cp -r out $OUT/
+
+# Build and insert the JSON object directly in jq
+jq -n \
+  --arg chainId "$CHAINID" \
+  --arg partyPlanner "$PARTY_PLANNER" \
+  --arg partyInfo "$PARTY_INFO" \
+  --arg partyPoolMintImpl "$PARTY_POOL_MINT_IMPL" \
+  --arg partyPoolSwapImpl "$PARTY_POOL_SWAP_IMPL" \
+  --arg partyPoolDeployer "$PARTY_POOL_DEPLOYER" \
+  --arg partyPoolBPDeployer "$PARTY_POOL_BP_DEPLOYER" \
+  --arg usxd "$USXD" \
+  --arg fusd "$FUSD" \
+  --arg dive "$DIVE" \
+  --arg butc "$BUTC" \
+  --arg wteth "$WTETH" \
+  '
+  {
+    v1: {
+      PartyPlanner: $partyPlanner,
+      PartyInfo: $partyInfo,
+      PartyPoolMintImpl: $partyPoolMintImpl,
+      PartyPoolSwapImpl: $partyPoolSwapImpl,
+      PartyPoolDeployer: $partyPoolDeployer,
+      PartyPoolBalancedPairDeployer: $partyPoolBPDeployer,
+      USXD: $usxd,
+      FUSD: $fusd,
+      DIVE: $dive,
+      BUTC: $butc,
+      WTETH: $wteth
+    }
+  } as $entry |
+  (try (input | . + {($chainId): $entry}) catch {($chainId): $entry})
+  ' "$METADATA_FILE" 2>/dev/null > "${METADATA_FILE}.tmp" && mv "${METADATA_FILE}.tmp" "$METADATA_FILE" || \
+  jq -n \
+    --arg chainId "$CHAINID" \
+    --arg partyPlanner "$PARTY_PLANNER" \
+    --arg partyInfo "$PARTY_INFO" \
+    --arg partyPoolMintImpl "$PARTY_POOL_MINT_IMPL" \
+    --arg partyPoolSwapImpl "$PARTY_POOL_SWAP_IMPL" \
+    --arg partyPoolDeployer "$PARTY_POOL_DEPLOYER" \
+    --arg partyPoolBPDeployer "$PARTY_POOL_BP_DEPLOYER" \
+    --arg usxd "$USXD" \
+    --arg fusd "$FUSD" \
+    --arg dive "$DIVE" \
+    --arg butc "$BUTC" \
+    --arg wteth "$WTETH" \
+    '{($chainId): {
+      v1: {
+        PartyPlanner: $partyPlanner,
+        PartyInfo.sol: $partyInfo,
+        PartyPoolMintImpl: $partyPoolMintImpl,
+        PartyPoolSwapImpl: $partyPoolSwapImpl,
+        PartyPoolDeployer: $partyPoolDeployer,
+        PartyPoolBalancedPairDeployer: $partyPoolBPDeployer,
+        USXD: $usxd,
+        FUSD: $fusd,
+        DIVE: $dive,
+        BUTC: $butc,
+        WTETH: $wteth
+      }
+    }}' > "$METADATA_FILE"
+
+echo "Wrote $METADATA_FILE"

bin/signature-upload

@@ -0,0 +1,2 @@
+#!/bin/bash
+forge selectors upload --all

deployment/11155111/v1/out/ABDKMath64x64.sol/ABDKMath64x64.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea264697066735822122057dfc406d135bbbd662b6329b3654145fbb6deac545bf953b3306cd6af0898d864736f6c634300081e0033","sourceMap":"666:24871:0:-:0;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x5f80fdfea264697066735822122057dfc406d135bbbd662b6329b3654145fbb6deac545bf953b3306cd6af0898d864736f6c634300081e0033","sourceMap":"666:24871:0:-:0;;","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"notice\":\"Smart contract library of mathematical functions operating with signed 64.64-bit fixed point numbers.  Signed 64.64-bit fixed point number is basically a simple fraction whose numerator is signed 128-bit integer and denominator is 2^64.  As long as denominator is always the same, there is no need to store it, thus in Solidity signed 64.64-bit fixed point numbers are represented by int128 type holding only the numerator.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/abdk-libraries-solidity/ABDKMath64x64.sol\":\"ABDKMath64x64\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/abdk-libraries-solidity/ABDKMath64x64.sol\":{\"keccak256\":\"0x1364fdc24192b982f647c7fc68dcb2f6fc1b5e201843e773144bd23a76cb3b97\",\"license\":\"BSD-4-Clause\",\"urls\":[\"bzz-raw://490712cc07db32f274899b17aade9c975f06010848c21500b8a5ead6898e09c7\",\"dweb:/ipfs/QmZMPKjDgwCFSGdLWJW6g5E7hDLByA9hNjXzAwJ4GKTZvN\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/abdk-libraries-solidity/ABDKMath64x64.sol":"ABDKMath64x64"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/abdk-libraries-solidity/ABDKMath64x64.sol":{"keccak256":"0x1364fdc24192b982f647c7fc68dcb2f6fc1b5e201843e773144bd23a76cb3b97","urls":["bzz-raw://490712cc07db32f274899b17aade9c975f06010848c21500b8a5ead6898e09c7","dweb:/ipfs/QmZMPKjDgwCFSGdLWJW6g5E7hDLByA9hNjXzAwJ4GKTZvN"],"license":"BSD-4-Clause"}},"version":1},"id":0}

deployment/11155111/v1/out/Address.sol/Address.json

@@ -0,0 +1 @@
+{"abi":[{"type":"error","name":"AddressEmptyCode","inputs":[{"name":"target","type":"address","internalType":"address"}]}],"bytecode":{"object":"0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220eb0570070fec78251db3fa24b17454c9bec7df5e60c2499d03d66c5c28208ff764736f6c634300081e0033","sourceMap":"282:6520:27:-:0;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x5f80fdfea2646970667358221220eb0570070fec78251db3fa24b17454c9bec7df5e60c2499d03d66c5c28208ff764736f6c634300081e0033","sourceMap":"282:6520:27:-:0;;","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"AddressEmptyCode\",\"type\":\"error\"}],\"devdoc\":{\"details\":\"Collection of functions related to the address type\",\"errors\":{\"AddressEmptyCode(address)\":[{\"details\":\"There's no code at `target` (it is not a contract).\"}]},\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/openzeppelin-contracts/contracts/utils/Address.sol\":\"Address\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/openzeppelin-contracts/contracts/utils/Address.sol\":{\"keccak256\":\"0xd274645d15bb7e4fcb9c833e401b2c5837404f90057f11a49118f25e0af7c76f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://d38e0b997bb7aebae26d190b03d0991feb0d204c45f945e60014e1ca9175de69\",\"dweb:/ipfs/QmWzsUHHAZcjMyF8uMDEtNpMTkYZdQrfvdKPobXvwVHKo6\"]},\"lib/openzeppelin-contracts/contracts/utils/Errors.sol\":{\"keccak256\":\"0x6afa713bfd42cf0f7656efa91201007ac465e42049d7de1d50753a373648c123\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ba1d02f4847670a1b83dec9f7d37f0b0418d6043447b69f3a29a5f9efc547fcf\",\"dweb:/ipfs/QmQ7iH2keLNUKgq2xSWcRmuBE5eZ3F5whYAkAGzCNNoEWB\"]},\"lib/openzeppelin-contracts/contracts/utils/LowLevelCall.sol\":{\"keccak256\":\"0x50e81a8b089e3f382b6c915aa0166773de64ea4756e8f9479d9943a5f956ddf5\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://bfeb96a150537222e2191c03887127499a4f21dfb5f9a7211da4d81749b52848\",\"dweb:/ipfs/QmYR75ECbsBuxSiXmGvGfNKJRLoK5MdLUZL1bd8SixzxL4\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"target","type":"address"}],"type":"error","name":"AddressEmptyCode"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/openzeppelin-contracts/contracts/utils/Address.sol":"Address"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/openzeppelin-contracts/contracts/utils/Address.sol":{"keccak256":"0xd274645d15bb7e4fcb9c833e401b2c5837404f90057f11a49118f25e0af7c76f","urls":["bzz-raw://d38e0b997bb7aebae26d190b03d0991feb0d204c45f945e60014e1ca9175de69","dweb:/ipfs/QmWzsUHHAZcjMyF8uMDEtNpMTkYZdQrfvdKPobXvwVHKo6"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/Errors.sol":{"keccak256":"0x6afa713bfd42cf0f7656efa91201007ac465e42049d7de1d50753a373648c123","urls":["bzz-raw://ba1d02f4847670a1b83dec9f7d37f0b0418d6043447b69f3a29a5f9efc547fcf","dweb:/ipfs/QmQ7iH2keLNUKgq2xSWcRmuBE5eZ3F5whYAkAGzCNNoEWB"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/LowLevelCall.sol":{"keccak256":"0x50e81a8b089e3f382b6c915aa0166773de64ea4756e8f9479d9943a5f956ddf5","urls":["bzz-raw://bfeb96a150537222e2191c03887127499a4f21dfb5f9a7211da4d81749b52848","dweb:/ipfs/QmYR75ECbsBuxSiXmGvGfNKJRLoK5MdLUZL1bd8SixzxL4"],"license":"MIT"}},"version":1},"id":27}

deployment/11155111/v1/out/Base.sol/CommonBase.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"deployedBytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"stateVariables\":{\"CONSOLE\":{\"details\":\"console.sol and console2.sol work by executing a staticcall to this address. Calculated as `address(uint160(uint88(bytes11(\\\"console.log\\\"))))`.\"},\"CREATE2_FACTORY\":{\"details\":\"Used when deploying with create2. Taken from https://github.com/Arachnid/deterministic-deployment-proxy.\"},\"DEFAULT_SENDER\":{\"details\":\"The default address for tx.origin and msg.sender. Calculated as `address(uint160(uint256(keccak256(\\\"foundry default caller\\\"))))`.\"},\"DEFAULT_TEST_CONTRACT\":{\"details\":\"The address of the first contract `CREATE`d by a running test contract. When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1. Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.\"},\"MULTICALL3_ADDRESS\":{\"details\":\"Deterministic deployment address of the Multicall3 contract. Taken from https://www.multicall3.com.\"},\"SECP256K1_ORDER\":{\"details\":\"The order of the secp256k1 curve.\"},\"VM_ADDRESS\":{\"details\":\"Cheat code address. Calculated as `address(uint160(uint256(keccak256(\\\"hevm cheat code\\\"))))`.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/forge-std/src/Base.sol\":\"CommonBase\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/forge-std/src/Base.sol\":{\"keccak256\":\"0x4b2a5a85e045dcf6a082700c7252e43854c2eed88f860aaa18ec1e85218ae2bf\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://98d060ed5be569a92d908fc358149039dc8f833d61973aa1b9d1d8235676bf6d\",\"dweb:/ipfs/QmaWQpn5dJmbMS5skwmPPMeUWZG35BLkignPpcA3zyagEs\"]},\"lib/forge-std/src/StdStorage.sol\":{\"keccak256\":\"0x04102de0a79398e4bdea57b7a4818655b4cc66d6f81d1cff08bf428cd0b384cd\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://53edc6c8f7f67cafc0129f039637c77d979880f7f1947defea31e8f0c05095bc\",\"dweb:/ipfs/QmUKXJd1vFCkxxrkXNLURdXrx2apoyWQFrFb5UqNkjdHVi\"]},\"lib/forge-std/src/Vm.sol\":{\"keccak256\":\"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f\",\"license\":\"MIT OR Apache-2.0\",\"urls\":[\"bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f\",\"dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/forge-std/src/Base.sol":"CommonBase"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/forge-std/src/Base.sol":{"keccak256":"0x4b2a5a85e045dcf6a082700c7252e43854c2eed88f860aaa18ec1e85218ae2bf","urls":["bzz-raw://98d060ed5be569a92d908fc358149039dc8f833d61973aa1b9d1d8235676bf6d","dweb:/ipfs/QmaWQpn5dJmbMS5skwmPPMeUWZG35BLkignPpcA3zyagEs"],"license":"MIT"},"lib/forge-std/src/StdStorage.sol":{"keccak256":"0x04102de0a79398e4bdea57b7a4818655b4cc66d6f81d1cff08bf428cd0b384cd","urls":["bzz-raw://53edc6c8f7f67cafc0129f039637c77d979880f7f1947defea31e8f0c05095bc","dweb:/ipfs/QmUKXJd1vFCkxxrkXNLURdXrx2apoyWQFrFb5UqNkjdHVi"],"license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f","urls":["bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f","dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL"],"license":"MIT OR Apache-2.0"}},"version":1},"id":1}

deployment/11155111/v1/out/Base.sol/ScriptBase.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"deployedBytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/forge-std/src/Base.sol\":\"ScriptBase\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/forge-std/src/Base.sol\":{\"keccak256\":\"0x4b2a5a85e045dcf6a082700c7252e43854c2eed88f860aaa18ec1e85218ae2bf\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://98d060ed5be569a92d908fc358149039dc8f833d61973aa1b9d1d8235676bf6d\",\"dweb:/ipfs/QmaWQpn5dJmbMS5skwmPPMeUWZG35BLkignPpcA3zyagEs\"]},\"lib/forge-std/src/StdStorage.sol\":{\"keccak256\":\"0x04102de0a79398e4bdea57b7a4818655b4cc66d6f81d1cff08bf428cd0b384cd\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://53edc6c8f7f67cafc0129f039637c77d979880f7f1947defea31e8f0c05095bc\",\"dweb:/ipfs/QmUKXJd1vFCkxxrkXNLURdXrx2apoyWQFrFb5UqNkjdHVi\"]},\"lib/forge-std/src/Vm.sol\":{\"keccak256\":\"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f\",\"license\":\"MIT OR Apache-2.0\",\"urls\":[\"bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f\",\"dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/forge-std/src/Base.sol":"ScriptBase"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/forge-std/src/Base.sol":{"keccak256":"0x4b2a5a85e045dcf6a082700c7252e43854c2eed88f860aaa18ec1e85218ae2bf","urls":["bzz-raw://98d060ed5be569a92d908fc358149039dc8f833d61973aa1b9d1d8235676bf6d","dweb:/ipfs/QmaWQpn5dJmbMS5skwmPPMeUWZG35BLkignPpcA3zyagEs"],"license":"MIT"},"lib/forge-std/src/StdStorage.sol":{"keccak256":"0x04102de0a79398e4bdea57b7a4818655b4cc66d6f81d1cff08bf428cd0b384cd","urls":["bzz-raw://53edc6c8f7f67cafc0129f039637c77d979880f7f1947defea31e8f0c05095bc","dweb:/ipfs/QmUKXJd1vFCkxxrkXNLURdXrx2apoyWQFrFb5UqNkjdHVi"],"license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f","urls":["bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f","dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL"],"license":"MIT OR Apache-2.0"}},"version":1},"id":1}

deployment/11155111/v1/out/Base.sol/TestBase.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"deployedBytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/forge-std/src/Base.sol\":\"TestBase\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/forge-std/src/Base.sol\":{\"keccak256\":\"0x4b2a5a85e045dcf6a082700c7252e43854c2eed88f860aaa18ec1e85218ae2bf\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://98d060ed5be569a92d908fc358149039dc8f833d61973aa1b9d1d8235676bf6d\",\"dweb:/ipfs/QmaWQpn5dJmbMS5skwmPPMeUWZG35BLkignPpcA3zyagEs\"]},\"lib/forge-std/src/StdStorage.sol\":{\"keccak256\":\"0x04102de0a79398e4bdea57b7a4818655b4cc66d6f81d1cff08bf428cd0b384cd\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://53edc6c8f7f67cafc0129f039637c77d979880f7f1947defea31e8f0c05095bc\",\"dweb:/ipfs/QmUKXJd1vFCkxxrkXNLURdXrx2apoyWQFrFb5UqNkjdHVi\"]},\"lib/forge-std/src/Vm.sol\":{\"keccak256\":\"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f\",\"license\":\"MIT OR Apache-2.0\",\"urls\":[\"bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f\",\"dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/forge-std/src/Base.sol":"TestBase"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/forge-std/src/Base.sol":{"keccak256":"0x4b2a5a85e045dcf6a082700c7252e43854c2eed88f860aaa18ec1e85218ae2bf","urls":["bzz-raw://98d060ed5be569a92d908fc358149039dc8f833d61973aa1b9d1d8235676bf6d","dweb:/ipfs/QmaWQpn5dJmbMS5skwmPPMeUWZG35BLkignPpcA3zyagEs"],"license":"MIT"},"lib/forge-std/src/StdStorage.sol":{"keccak256":"0x04102de0a79398e4bdea57b7a4818655b4cc66d6f81d1cff08bf428cd0b384cd","urls":["bzz-raw://53edc6c8f7f67cafc0129f039637c77d979880f7f1947defea31e8f0c05095bc","dweb:/ipfs/QmUKXJd1vFCkxxrkXNLURdXrx2apoyWQFrFb5UqNkjdHVi"],"license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f","urls":["bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f","dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL"],"license":"MIT OR Apache-2.0"}},"version":1},"id":1}

deployment/11155111/v1/out/Context.sol/Context.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"deployedBytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"details\":\"Provides information about the current execution context, including the sender of the transaction and its data. While these are generally available via msg.sender and msg.data, they should not be accessed in such a direct manner, since when dealing with meta-transactions the account sending and paying for execution may not be the actual sender (as far as an application is concerned). This contract is only required for intermediate, library-like contracts.\",\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/openzeppelin-contracts/contracts/utils/Context.sol\":\"Context\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/openzeppelin-contracts/contracts/utils/Context.sol\":{\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12\",\"dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/openzeppelin-contracts/contracts/utils/Context.sol":"Context"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"keccak256":"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2","urls":["bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12","dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF"],"license":"MIT"}},"version":1},"id":28}

deployment/11155111/v1/out/Errors.sol/Errors.json

@@ -0,0 +1 @@
+{"abi":[{"type":"error","name":"FailedCall","inputs":[]},{"type":"error","name":"FailedDeployment","inputs":[]},{"type":"error","name":"InsufficientBalance","inputs":[{"name":"balance","type":"uint256","internalType":"uint256"},{"name":"needed","type":"uint256","internalType":"uint256"}]},{"type":"error","name":"MissingPrecompile","inputs":[{"name":"","type":"address","internalType":"address"}]}],"bytecode":{"object":"0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220c9655ed21113d5fdaf6c566485d35a2aaf2bf242b1c753a1cac998424bd77b5d64736f6c634300081e0033","sourceMap":"411:484:29:-:0;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x5f80fdfea2646970667358221220c9655ed21113d5fdaf6c566485d35a2aaf2bf242b1c753a1cac998424bd77b5d64736f6c634300081e0033","sourceMap":"411:484:29:-:0;;","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"FailedCall\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"FailedDeployment\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"balance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"needed\",\"type\":\"uint256\"}],\"name\":\"InsufficientBalance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"MissingPrecompile\",\"type\":\"error\"}],\"devdoc\":{\"details\":\"Collection of common custom errors used in multiple contracts IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library. It is recommended to avoid relying on the error API for critical functionality. _Available since v5.1._\",\"errors\":{\"FailedCall()\":[{\"details\":\"A call to an address target failed. The target may have reverted.\"}],\"FailedDeployment()\":[{\"details\":\"The deployment failed.\"}],\"InsufficientBalance(uint256,uint256)\":[{\"details\":\"The ETH balance of the account is not enough to perform the operation.\"}],\"MissingPrecompile(address)\":[{\"details\":\"A necessary precompile is missing.\"}]},\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/openzeppelin-contracts/contracts/utils/Errors.sol\":\"Errors\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/openzeppelin-contracts/contracts/utils/Errors.sol\":{\"keccak256\":\"0x6afa713bfd42cf0f7656efa91201007ac465e42049d7de1d50753a373648c123\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ba1d02f4847670a1b83dec9f7d37f0b0418d6043447b69f3a29a5f9efc547fcf\",\"dweb:/ipfs/QmQ7iH2keLNUKgq2xSWcRmuBE5eZ3F5whYAkAGzCNNoEWB\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[{"inputs":[],"type":"error","name":"FailedCall"},{"inputs":[],"type":"error","name":"FailedDeployment"},{"inputs":[{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"type":"error","name":"InsufficientBalance"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"type":"error","name":"MissingPrecompile"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/openzeppelin-contracts/contracts/utils/Errors.sol":"Errors"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/openzeppelin-contracts/contracts/utils/Errors.sol":{"keccak256":"0x6afa713bfd42cf0f7656efa91201007ac465e42049d7de1d50753a373648c123","urls":["bzz-raw://ba1d02f4847670a1b83dec9f7d37f0b0418d6043447b69f3a29a5f9efc547fcf","dweb:/ipfs/QmQ7iH2keLNUKgq2xSWcRmuBE5eZ3F5whYAkAGzCNNoEWB"],"license":"MIT"}},"version":1},"id":29}

deployment/11155111/v1/out/IERC165.sol/IERC165.json

@@ -0,0 +1 @@
+{"abi":[{"type":"function","name":"supportsInterface","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"}],"bytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"deployedBytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"methodIdentifiers":{"supportsInterface(bytes4)":"01ffc9a7"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"Interface of the ERC-165 standard, as defined in the https://eips.ethereum.org/EIPS/eip-165[ERC]. Implementers can declare support of contract interfaces, which can then be queried by others ({ERC165Checker}). For an implementation, see {ERC165}.\",\"kind\":\"dev\",\"methods\":{\"supportsInterface(bytes4)\":{\"details\":\"Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] to learn more about how these ids are created. This function call must use less than 30 000 gas.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol\":\"IERC165\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://971f954442df5c2ef5b5ebf1eb245d7105d9fbacc7386ee5c796df1d45b21617\",\"dweb:/ipfs/QmadRjHbkicwqwwh61raUEapaVEtaLMcYbQZWs9gUkgj3u\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"stateMutability":"view","type":"function","name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}]}],"devdoc":{"kind":"dev","methods":{"supportsInterface(bytes4)":{"details":"Returns true if this contract implements the interface defined by `interfaceId`. See the corresponding https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] to learn more about how these ids are created. This function call must use less than 30 000 gas."}},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":"IERC165"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"keccak256":"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c","urls":["bzz-raw://971f954442df5c2ef5b5ebf1eb245d7105d9fbacc7386ee5c796df1d45b21617","dweb:/ipfs/QmadRjHbkicwqwwh61raUEapaVEtaLMcYbQZWs9gUkgj3u"],"license":"MIT"}},"version":1},"id":33}

deployment/11155111/v1/out/IPartyFlashCallback.sol/IPartyFlashCallback.json

@@ -0,0 +1 @@
+{"abi":[{"type":"function","name":"partyFlashCallback","inputs":[{"name":"loanAmounts","type":"uint256[]","internalType":"uint256[]"},{"name":"repaymentAmounts","type":"uint256[]","internalType":"uint256[]"},{"name":"data","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"}],"bytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"deployedBytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"methodIdentifiers":{"partyFlashCallback(uint256[],uint256[],bytes)":"f6c10706"},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"uint256[]\",\"name\":\"loanAmounts\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"repaymentAmounts\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"partyFlashCallback\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/IPartyFlashCallback.sol\":\"IPartyFlashCallback\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"src/IPartyFlashCallback.sol\":{\"keccak256\":\"0xff1d473d27c4dc75441a5f0db2d761916cce4a702f660e998467791efd1d9b2e\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://3220d69c62ed8c8106762c92857f24011284e8ddcfa5db4210e506b112fa1870\",\"dweb:/ipfs/QmYoZiGsVwoJvyPMcsSste4tq93wVBgDqCZkwPY7dvyLBJ\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"uint256[]","name":"loanAmounts","type":"uint256[]"},{"internalType":"uint256[]","name":"repaymentAmounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"stateMutability":"nonpayable","type":"function","name":"partyFlashCallback"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/IPartyFlashCallback.sol":"IPartyFlashCallback"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"src/IPartyFlashCallback.sol":{"keccak256":"0xff1d473d27c4dc75441a5f0db2d761916cce4a702f660e998467791efd1d9b2e","urls":["bzz-raw://3220d69c62ed8c8106762c92857f24011284e8ddcfa5db4210e506b112fa1870","dweb:/ipfs/QmYoZiGsVwoJvyPMcsSste4tq93wVBgDqCZkwPY7dvyLBJ"],"license":"UNLICENSED"}},"version":1},"id":38}

deployment/11155111/v1/out/LMSRStabilized.sol/LMSRStabilized.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220b3e7e7d176c75fd687d50408cdd3f2f0c44423e17a0f674e797ffbe7fae0105564736f6c634300081e0033","sourceMap":"552:41522:42:-:0;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x5f80fdfea2646970667358221220b3e7e7d176c75fd687d50408cdd3f2f0c44423e17a0f674e797ffbe7fae0105564736f6c634300081e0033","sourceMap":"552:41522:42:-:0;;","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"notice\":\"Stabilized LMSR library with incremental exp(z) caching for gas efficiency. - Stores b (64.64), M (shift), Z = sum exp(z_i), z[i] = (q_i / b) - M - Caches e[i] = exp(z[i]) so we avoid recomputing exp() for every asset on each trade. - Provides closed-form \\u0394C on deposit, amount-out for asset->asset,   and incremental applyDeposit/applyWithdraw that update e[i] and Z in O(1).\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/LMSRStabilized.sol\":\"LMSRStabilized\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/abdk-libraries-solidity/ABDKMath64x64.sol\":{\"keccak256\":\"0x1364fdc24192b982f647c7fc68dcb2f6fc1b5e201843e773144bd23a76cb3b97\",\"license\":\"BSD-4-Clause\",\"urls\":[\"bzz-raw://490712cc07db32f274899b17aade9c975f06010848c21500b8a5ead6898e09c7\",\"dweb:/ipfs/QmZMPKjDgwCFSGdLWJW6g5E7hDLByA9hNjXzAwJ4GKTZvN\"]},\"src/LMSRStabilized.sol\":{\"keccak256\":\"0xb3df5a014bbb48a1aea62faee4ef9c7a830fcb0209cf1304bdca4fa68126a3f3\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://b05b0c09bb8883fed3c03509bf6f5f9991435ae6648530662b4fd01f667ab955\",\"dweb:/ipfs/QmeYVgnoXn3uiZdUsW2TYigfRPuHBR7AV1fpRm6uT9Z1gZ\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/LMSRStabilized.sol":"LMSRStabilized"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/abdk-libraries-solidity/ABDKMath64x64.sol":{"keccak256":"0x1364fdc24192b982f647c7fc68dcb2f6fc1b5e201843e773144bd23a76cb3b97","urls":["bzz-raw://490712cc07db32f274899b17aade9c975f06010848c21500b8a5ead6898e09c7","dweb:/ipfs/QmZMPKjDgwCFSGdLWJW6g5E7hDLByA9hNjXzAwJ4GKTZvN"],"license":"BSD-4-Clause"},"src/LMSRStabilized.sol":{"keccak256":"0xb3df5a014bbb48a1aea62faee4ef9c7a830fcb0209cf1304bdca4fa68126a3f3","urls":["bzz-raw://b05b0c09bb8883fed3c03509bf6f5f9991435ae6648530662b4fd01f667ab955","dweb:/ipfs/QmeYVgnoXn3uiZdUsW2TYigfRPuHBR7AV1fpRm6uT9Z1gZ"],"license":"UNLICENSED"}},"version":1},"id":42}

deployment/11155111/v1/out/LMSRStabilizedBalancedPair.sol/LMSRStabilizedBalancedPair.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea26469706673582212203b495f7bb157deb0060a295e9dac267b9d7e9e99d58b6b261eb376f830bcfe5864736f6c634300081e0033","sourceMap":"265:8588:43:-:0;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x5f80fdfea26469706673582212203b495f7bb157deb0060a295e9dac267b9d7e9e99d58b6b261eb376f830bcfe5864736f6c634300081e0033","sourceMap":"265:8588:43:-:0;;","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"notice\":\"Specialized functions for the 2-asset stablecoin case\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/LMSRStabilizedBalancedPair.sol\":\"LMSRStabilizedBalancedPair\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/abdk-libraries-solidity/ABDKMath64x64.sol\":{\"keccak256\":\"0x1364fdc24192b982f647c7fc68dcb2f6fc1b5e201843e773144bd23a76cb3b97\",\"license\":\"BSD-4-Clause\",\"urls\":[\"bzz-raw://490712cc07db32f274899b17aade9c975f06010848c21500b8a5ead6898e09c7\",\"dweb:/ipfs/QmZMPKjDgwCFSGdLWJW6g5E7hDLByA9hNjXzAwJ4GKTZvN\"]},\"src/LMSRStabilized.sol\":{\"keccak256\":\"0xb3df5a014bbb48a1aea62faee4ef9c7a830fcb0209cf1304bdca4fa68126a3f3\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://b05b0c09bb8883fed3c03509bf6f5f9991435ae6648530662b4fd01f667ab955\",\"dweb:/ipfs/QmeYVgnoXn3uiZdUsW2TYigfRPuHBR7AV1fpRm6uT9Z1gZ\"]},\"src/LMSRStabilizedBalancedPair.sol\":{\"keccak256\":\"0x782f3baf92f74152c0b93b95199abbb3a36c75c921454260c8b0237f91d7c59d\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://04d463c4fdcb6c8e2ebf9aed649ff21cca759ba73a4c93659e30c7df25e26c81\",\"dweb:/ipfs/QmUxmWytiw5VYJRUrFbSGm1oWmDPQ4q23pnkmK1q9P4apN\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/LMSRStabilizedBalancedPair.sol":"LMSRStabilizedBalancedPair"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/abdk-libraries-solidity/ABDKMath64x64.sol":{"keccak256":"0x1364fdc24192b982f647c7fc68dcb2f6fc1b5e201843e773144bd23a76cb3b97","urls":["bzz-raw://490712cc07db32f274899b17aade9c975f06010848c21500b8a5ead6898e09c7","dweb:/ipfs/QmZMPKjDgwCFSGdLWJW6g5E7hDLByA9hNjXzAwJ4GKTZvN"],"license":"BSD-4-Clause"},"src/LMSRStabilized.sol":{"keccak256":"0xb3df5a014bbb48a1aea62faee4ef9c7a830fcb0209cf1304bdca4fa68126a3f3","urls":["bzz-raw://b05b0c09bb8883fed3c03509bf6f5f9991435ae6648530662b4fd01f667ab955","dweb:/ipfs/QmeYVgnoXn3uiZdUsW2TYigfRPuHBR7AV1fpRm6uT9Z1gZ"],"license":"UNLICENSED"},"src/LMSRStabilizedBalancedPair.sol":{"keccak256":"0x782f3baf92f74152c0b93b95199abbb3a36c75c921454260c8b0237f91d7c59d","urls":["bzz-raw://04d463c4fdcb6c8e2ebf9aed649ff21cca759ba73a4c93659e30c7df25e26c81","dweb:/ipfs/QmUxmWytiw5VYJRUrFbSGm1oWmDPQ4q23pnkmK1q9P4apN"],"license":"UNLICENSED"}},"version":1},"id":43}

deployment/11155111/v1/out/LowLevelCall.sol/LowLevelCall.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220ff1724fa31d9e324ea702ba224919eb915aeafa31fa3c696ca265c0e46de134064736f6c634300081e0033","sourceMap":"348:5083:30:-:0;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x5f80fdfea2646970667358221220ff1724fa31d9e324ea702ba224919eb915aeafa31fa3c696ca265c0e46de134064736f6c634300081e0033","sourceMap":"348:5083:30:-:0;;","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"details\":\"Library of low level call functions that implement different calling strategies to deal with the return data. WARNING: Using this library requires an advanced understanding of Solidity and how the EVM works. It is recommended to use the {Address} library instead.\",\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/openzeppelin-contracts/contracts/utils/LowLevelCall.sol\":\"LowLevelCall\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/openzeppelin-contracts/contracts/utils/LowLevelCall.sol\":{\"keccak256\":\"0x50e81a8b089e3f382b6c915aa0166773de64ea4756e8f9479d9943a5f956ddf5\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://bfeb96a150537222e2191c03887127499a4f21dfb5f9a7211da4d81749b52848\",\"dweb:/ipfs/QmYR75ECbsBuxSiXmGvGfNKJRLoK5MdLUZL1bd8SixzxL4\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/openzeppelin-contracts/contracts/utils/LowLevelCall.sol":"LowLevelCall"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/openzeppelin-contracts/contracts/utils/LowLevelCall.sol":{"keccak256":"0x50e81a8b089e3f382b6c915aa0166773de64ea4756e8f9479d9943a5f956ddf5","urls":["bzz-raw://bfeb96a150537222e2191c03887127499a4f21dfb5f9a7211da4d81749b52848","dweb:/ipfs/QmYR75ECbsBuxSiXmGvGfNKJRLoK5MdLUZL1bd8SixzxL4"],"license":"MIT"}},"version":1},"id":30}

deployment/11155111/v1/out/OwnableInternal.sol/OwnableInternal.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"deployedBytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"details\":\"OpenZeppelin's Ownable contract, split into internal and external parts.\",\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/OwnableInternal.sol\":\"OwnableInternal\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/openzeppelin-contracts/contracts/utils/Context.sol\":{\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12\",\"dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF\"]},\"src/IOwnable.sol\":{\"keccak256\":\"0x7462267790c0d2312be1cbce077e5565aa86dac0789718c87ad0948174ecb990\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://7eca10ffa6a7985d11eb476a351b1c09701056b0bdf8146612173bb19764e3f1\",\"dweb:/ipfs/QmTPF85yFSL3jDt2atZDLT4RV3zs8ch8P3G7YzCUiU8gR9\"]},\"src/OwnableInternal.sol\":{\"keccak256\":\"0x4dd94a81962a9708a07fdeba0f2b63bb5e17ef22f3b7a4d1e6afc5e589f95581\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://efecf80e2ef5afc06fb1f201270a41e15bed831275650d0e47c0d933e7b192ca\",\"dweb:/ipfs/QmNo4q3htXm758T8tKruR671mrDL2K1kkzRJjSKr7BTuiE\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/OwnableInternal.sol":"OwnableInternal"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"keccak256":"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2","urls":["bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12","dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF"],"license":"MIT"},"src/IOwnable.sol":{"keccak256":"0x7462267790c0d2312be1cbce077e5565aa86dac0789718c87ad0948174ecb990","urls":["bzz-raw://7eca10ffa6a7985d11eb476a351b1c09701056b0bdf8146612173bb19764e3f1","dweb:/ipfs/QmTPF85yFSL3jDt2atZDLT4RV3zs8ch8P3G7YzCUiU8gR9"],"license":"MIT"},"src/OwnableInternal.sol":{"keccak256":"0x4dd94a81962a9708a07fdeba0f2b63bb5e17ef22f3b7a4d1e6afc5e589f95581","urls":["bzz-raw://efecf80e2ef5afc06fb1f201270a41e15bed831275650d0e47c0d933e7b192ca","dweb:/ipfs/QmNo4q3htXm758T8tKruR671mrDL2K1kkzRJjSKr7BTuiE"],"license":"MIT"}},"version":1},"id":46}

deployment/11155111/v1/out/PartyPoolHelpers.sol/PartyPoolHelpers.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"deployedBytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/PartyPoolHelpers.sol\":\"PartyPoolHelpers\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/abdk-libraries-solidity/ABDKMath64x64.sol\":{\"keccak256\":\"0x1364fdc24192b982f647c7fc68dcb2f6fc1b5e201843e773144bd23a76cb3b97\",\"license\":\"BSD-4-Clause\",\"urls\":[\"bzz-raw://490712cc07db32f274899b17aade9c975f06010848c21500b8a5ead6898e09c7\",\"dweb:/ipfs/QmZMPKjDgwCFSGdLWJW6g5E7hDLByA9hNjXzAwJ4GKTZvN\"]},\"src/PartyPoolHelpers.sol\":{\"keccak256\":\"0xd43b635d12b6684ae38a685eea4bc5783cebb3696514d8aafe3f4ce34f5e759c\",\"license\":\"UNLICENSED\",\"urls\":[\"bzz-raw://832046b365d443c4c1c715f98fe3de224e3ba82c67960053d51e6a79847c4af5\",\"dweb:/ipfs/QmZ4nWMwyYQzaBGF7rBE73GYTs4z3DRNYL1ZrGAsxN6RfP\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"src/PartyPoolHelpers.sol":"PartyPoolHelpers"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/abdk-libraries-solidity/ABDKMath64x64.sol":{"keccak256":"0x1364fdc24192b982f647c7fc68dcb2f6fc1b5e201843e773144bd23a76cb3b97","urls":["bzz-raw://490712cc07db32f274899b17aade9c975f06010848c21500b8a5ead6898e09c7","dweb:/ipfs/QmZMPKjDgwCFSGdLWJW6g5E7hDLByA9hNjXzAwJ4GKTZvN"],"license":"BSD-4-Clause"},"src/PartyPoolHelpers.sol":{"keccak256":"0xd43b635d12b6684ae38a685eea4bc5783cebb3696514d8aafe3f4ce34f5e759c","urls":["bzz-raw://832046b365d443c4c1c715f98fe3de224e3ba82c67960053d51e6a79847c4af5","dweb:/ipfs/QmZ4nWMwyYQzaBGF7rBE73GYTs4z3DRNYL1ZrGAsxN6RfP"],"license":"UNLICENSED"}},"version":1},"id":52}

deployment/11155111/v1/out/Proxy.sol/Proxy.json

@@ -0,0 +1 @@
+{"abi":[{"type":"fallback","stateMutability":"payable"}],"bytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"deployedBytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"stateMutability\":\"payable\",\"type\":\"fallback\"}],\"devdoc\":{\"details\":\"This abstract contract provides a fallback function that delegates all calls to another contract using the EVM instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to be specified by overriding the virtual {_implementation} function. Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a different contract through the {_delegate} function. The success and return data of the delegated call will be returned back to the caller of the proxy.\",\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/openzeppelin-contracts/contracts/proxy/Proxy.sol\":\"Proxy\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/openzeppelin-contracts/contracts/proxy/Proxy.sol\":{\"keccak256\":\"0x25f9b099413f805b4c4bbad8cc179326c10be237aec00349caf91524f8db0bbc\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://dcfb75af07ad33b1f8e966f793db3df8fbcfb14103ed3644c0c634658a8fd099\",\"dweb:/ipfs/QmPWamdkbcKwG3ah2G9TZtKHzQmjnunsWoPWr5KKfbrKNb\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"payable","type":"fallback"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/openzeppelin-contracts/contracts/proxy/Proxy.sol":"Proxy"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/openzeppelin-contracts/contracts/proxy/Proxy.sol":{"keccak256":"0x25f9b099413f805b4c4bbad8cc179326c10be237aec00349caf91524f8db0bbc","urls":["bzz-raw://dcfb75af07ad33b1f8e966f793db3df8fbcfb14103ed3644c0c634658a8fd099","dweb:/ipfs/QmPWamdkbcKwG3ah2G9TZtKHzQmjnunsWoPWr5KKfbrKNb"],"license":"MIT"}},"version":1},"id":22}

deployment/11155111/v1/out/ReentrancyGuard.sol/ReentrancyGuard.json

@@ -0,0 +1 @@
+{"abi":[{"type":"error","name":"ReentrancyGuardReentrantCall","inputs":[]}],"bytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"deployedBytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"ReentrancyGuardReentrantCall\",\"type\":\"error\"}],\"devdoc\":{\"custom:stateless\":\"\",\"details\":\"Contract module that helps prevent reentrant calls to a function. Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier available, which can be applied to functions to make sure there are no nested (reentrant) calls to them. Note that because there is a single `nonReentrant` guard, functions marked as `nonReentrant` may not call one another. This can be worked around by making those functions `private`, and then adding `external` `nonReentrant` entry points to them. TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at, consider using {ReentrancyGuardTransient} instead. TIP: If you would like to learn more about reentrancy and alternative ways to protect against it, check out our blog post https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. IMPORTANT: Deprecated. This storage-based reentrancy guard will be removed and replaced by the {ReentrancyGuardTransient} variant in v6.0.\",\"errors\":{\"ReentrancyGuardReentrantCall()\":[{\"details\":\"Unauthorized reentrant call.\"}]},\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol\":\"ReentrancyGuard\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol\":{\"keccak256\":\"0x6f9ed073e3dab12233a79cd85153f72c9e0f99c1f5512f6d5b1ef09fb46abbb0\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://093d2a804b792a0000883c2215585963ed98ec4341b45bc4224844623387d161\",\"dweb:/ipfs/QmR5shjVosAoxdmY3EfkUWgFNV4CVUcbRNS7tkvbipssPX\"]},\"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol\":{\"keccak256\":\"0xcf74f855663ce2ae00ed8352666b7935f6cddea2932fdf2c3ecd30a9b1cd0e97\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://9f660b1f351b757dfe01438e59888f31f33ded3afcf5cb5b0d9bf9aa6f320a8b\",\"dweb:/ipfs/QmarDJ5hZEgBtCmmrVzEZWjub9769eD686jmzb2XpSU1cM\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[{"inputs":[],"type":"error","name":"ReentrancyGuardReentrantCall"}],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol":"ReentrancyGuard"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol":{"keccak256":"0x6f9ed073e3dab12233a79cd85153f72c9e0f99c1f5512f6d5b1ef09fb46abbb0","urls":["bzz-raw://093d2a804b792a0000883c2215585963ed98ec4341b45bc4224844623387d161","dweb:/ipfs/QmR5shjVosAoxdmY3EfkUWgFNV4CVUcbRNS7tkvbipssPX"],"license":"MIT"},"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":{"keccak256":"0xcf74f855663ce2ae00ed8352666b7935f6cddea2932fdf2c3ecd30a9b1cd0e97","urls":["bzz-raw://9f660b1f351b757dfe01438e59888f31f33ded3afcf5cb5b0d9bf9aa6f320a8b","dweb:/ipfs/QmarDJ5hZEgBtCmmrVzEZWjub9769eD686jmzb2XpSU1cM"],"license":"MIT"}},"version":1},"id":31}

deployment/11155111/v1/out/StdChains.sol/StdChains.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"deployedBytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"notice\":\"StdChains provides information about EVM compatible chains that can be used in scripts/tests. For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the alias used in this contract, which can be found as the first argument to the `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function. There are two main ways to use this contract:   1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or      `setChain(string memory chainAlias, Chain memory chain)`   2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`. The first time either of those are used, chains are initialized with the default set of RPC URLs. This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in `defaultRpcUrls`. The `setChain` function is straightforward, and it simply saves off the given chain data. The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say we want to retrieve the RPC URL for `mainnet`:   - If you have specified data with `setChain`, it will return that.   - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it     is valid (e.g. a URL is specified, or an environment variable is given and exists).   - If neither of the above conditions is met, the default data is returned. Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/forge-std/src/StdChains.sol\":\"StdChains\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/forge-std/src/StdChains.sol\":{\"keccak256\":\"0xb2cbca1a6ffa19926c31bad47393a070305c809fe5d88c52214d5c51ce0733c6\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://cf20975cfd9733910305fc8e746c7631c2ab210289aab036cec32f3c530335c7\",\"dweb:/ipfs/QmYYvVzvAN1uCt8XtDmWo5x2inSVJBYajFexe92rVWEuMf\"]},\"lib/forge-std/src/Vm.sol\":{\"keccak256\":\"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f\",\"license\":\"MIT OR Apache-2.0\",\"urls\":[\"bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f\",\"dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/forge-std/src/StdChains.sol":"StdChains"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/forge-std/src/StdChains.sol":{"keccak256":"0xb2cbca1a6ffa19926c31bad47393a070305c809fe5d88c52214d5c51ce0733c6","urls":["bzz-raw://cf20975cfd9733910305fc8e746c7631c2ab210289aab036cec32f3c530335c7","dweb:/ipfs/QmYYvVzvAN1uCt8XtDmWo5x2inSVJBYajFexe92rVWEuMf"],"license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f","urls":["bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f","dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL"],"license":"MIT OR Apache-2.0"}},"version":1},"id":3}

deployment/11155111/v1/out/StdCheats.sol/StdCheats.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"deployedBytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/forge-std/src/StdCheats.sol\":\"StdCheats\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/forge-std/src/StdCheats.sol\":{\"keccak256\":\"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://cd84e2ca9c1eaed6b76768cc12bb8c1af8289170ea8b7706f58d516460d79c41\",\"dweb:/ipfs/QmQ7BK7co6DE4eWUqMyv11s5eHYkS1tyx8tDSZGZVtf2aK\"]},\"lib/forge-std/src/StdStorage.sol\":{\"keccak256\":\"0x04102de0a79398e4bdea57b7a4818655b4cc66d6f81d1cff08bf428cd0b384cd\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://53edc6c8f7f67cafc0129f039637c77d979880f7f1947defea31e8f0c05095bc\",\"dweb:/ipfs/QmUKXJd1vFCkxxrkXNLURdXrx2apoyWQFrFb5UqNkjdHVi\"]},\"lib/forge-std/src/Vm.sol\":{\"keccak256\":\"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f\",\"license\":\"MIT OR Apache-2.0\",\"urls\":[\"bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f\",\"dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL\"]},\"lib/forge-std/src/console.sol\":{\"keccak256\":\"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://af9e3a7c3d82fb5b10b57ca4d1a82f2acbef80c077f6f6ef0cc0187c7bfd9f57\",\"dweb:/ipfs/QmR9VzmnBDJpgiDP6CHT6truehukF9HpYvuP6kRiJbDwPP\"]},\"lib/forge-std/src/console2.sol\":{\"keccak256\":\"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://61de63af08803549299e68b6e6e88d40f3c5afac450e4ee0a228c66a61ba003d\",\"dweb:/ipfs/QmWVoQ5rrVxnczD4ZZoPbD4PC9Z3uExJtzjD4awTqd14MZ\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/forge-std/src/StdCheats.sol":"StdCheats"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/forge-std/src/StdCheats.sol":{"keccak256":"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746","urls":["bzz-raw://cd84e2ca9c1eaed6b76768cc12bb8c1af8289170ea8b7706f58d516460d79c41","dweb:/ipfs/QmQ7BK7co6DE4eWUqMyv11s5eHYkS1tyx8tDSZGZVtf2aK"],"license":"MIT"},"lib/forge-std/src/StdStorage.sol":{"keccak256":"0x04102de0a79398e4bdea57b7a4818655b4cc66d6f81d1cff08bf428cd0b384cd","urls":["bzz-raw://53edc6c8f7f67cafc0129f039637c77d979880f7f1947defea31e8f0c05095bc","dweb:/ipfs/QmUKXJd1vFCkxxrkXNLURdXrx2apoyWQFrFb5UqNkjdHVi"],"license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f","urls":["bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f","dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL"],"license":"MIT OR Apache-2.0"},"lib/forge-std/src/console.sol":{"keccak256":"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5","urls":["bzz-raw://af9e3a7c3d82fb5b10b57ca4d1a82f2acbef80c077f6f6ef0cc0187c7bfd9f57","dweb:/ipfs/QmR9VzmnBDJpgiDP6CHT6truehukF9HpYvuP6kRiJbDwPP"],"license":"MIT"},"lib/forge-std/src/console2.sol":{"keccak256":"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f","urls":["bzz-raw://61de63af08803549299e68b6e6e88d40f3c5afac450e4ee0a228c66a61ba003d","dweb:/ipfs/QmWVoQ5rrVxnczD4ZZoPbD4PC9Z3uExJtzjD4awTqd14MZ"],"license":"MIT"}},"version":1},"id":4}

deployment/11155111/v1/out/StdCheats.sol/StdCheatsSafe.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"deployedBytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/forge-std/src/StdCheats.sol\":\"StdCheatsSafe\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/forge-std/src/StdCheats.sol\":{\"keccak256\":\"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://cd84e2ca9c1eaed6b76768cc12bb8c1af8289170ea8b7706f58d516460d79c41\",\"dweb:/ipfs/QmQ7BK7co6DE4eWUqMyv11s5eHYkS1tyx8tDSZGZVtf2aK\"]},\"lib/forge-std/src/StdStorage.sol\":{\"keccak256\":\"0x04102de0a79398e4bdea57b7a4818655b4cc66d6f81d1cff08bf428cd0b384cd\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://53edc6c8f7f67cafc0129f039637c77d979880f7f1947defea31e8f0c05095bc\",\"dweb:/ipfs/QmUKXJd1vFCkxxrkXNLURdXrx2apoyWQFrFb5UqNkjdHVi\"]},\"lib/forge-std/src/Vm.sol\":{\"keccak256\":\"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f\",\"license\":\"MIT OR Apache-2.0\",\"urls\":[\"bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f\",\"dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL\"]},\"lib/forge-std/src/console.sol\":{\"keccak256\":\"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://af9e3a7c3d82fb5b10b57ca4d1a82f2acbef80c077f6f6ef0cc0187c7bfd9f57\",\"dweb:/ipfs/QmR9VzmnBDJpgiDP6CHT6truehukF9HpYvuP6kRiJbDwPP\"]},\"lib/forge-std/src/console2.sol\":{\"keccak256\":\"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://61de63af08803549299e68b6e6e88d40f3c5afac450e4ee0a228c66a61ba003d\",\"dweb:/ipfs/QmWVoQ5rrVxnczD4ZZoPbD4PC9Z3uExJtzjD4awTqd14MZ\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/forge-std/src/StdCheats.sol":"StdCheatsSafe"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/forge-std/src/StdCheats.sol":{"keccak256":"0x0fa6ec03602648b62cce41aab2096e6b7e052f2846075d967b6958dd586db746","urls":["bzz-raw://cd84e2ca9c1eaed6b76768cc12bb8c1af8289170ea8b7706f58d516460d79c41","dweb:/ipfs/QmQ7BK7co6DE4eWUqMyv11s5eHYkS1tyx8tDSZGZVtf2aK"],"license":"MIT"},"lib/forge-std/src/StdStorage.sol":{"keccak256":"0x04102de0a79398e4bdea57b7a4818655b4cc66d6f81d1cff08bf428cd0b384cd","urls":["bzz-raw://53edc6c8f7f67cafc0129f039637c77d979880f7f1947defea31e8f0c05095bc","dweb:/ipfs/QmUKXJd1vFCkxxrkXNLURdXrx2apoyWQFrFb5UqNkjdHVi"],"license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f","urls":["bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f","dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL"],"license":"MIT OR Apache-2.0"},"lib/forge-std/src/console.sol":{"keccak256":"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5","urls":["bzz-raw://af9e3a7c3d82fb5b10b57ca4d1a82f2acbef80c077f6f6ef0cc0187c7bfd9f57","dweb:/ipfs/QmR9VzmnBDJpgiDP6CHT6truehukF9HpYvuP6kRiJbDwPP"],"license":"MIT"},"lib/forge-std/src/console2.sol":{"keccak256":"0x3b8fe79f48f065a4e4d35362171304a33784c3a90febae5f2787805a438de12f","urls":["bzz-raw://61de63af08803549299e68b6e6e88d40f3c5afac450e4ee0a228c66a61ba003d","dweb:/ipfs/QmWVoQ5rrVxnczD4ZZoPbD4PC9Z3uExJtzjD4awTqd14MZ"],"license":"MIT"}},"version":1},"id":4}

deployment/11155111/v1/out/StdJson.sol/stdJson.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220f305db5938071a82ff12d5cca101765d7bc698c9c34558487d9c37f2ce06498864736f6c634300081e0033","sourceMap":"610:9092:6:-:0;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x5f80fdfea2646970667358221220f305db5938071a82ff12d5cca101765d7bc698c9c34558487d9c37f2ce06498864736f6c634300081e0033","sourceMap":"610:9092:6:-:0;;","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/forge-std/src/StdJson.sol\":\"stdJson\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/forge-std/src/StdJson.sol\":{\"keccak256\":\"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://eb6fab37dc73c219cfbb7b4f4998bcf7677ca5397a867e850f40232192073974\",\"dweb:/ipfs/QmUHsbVdp9SKmgek7ZfPcLTKrpZFXpqaqt4sVejzxGEQL3\"]},\"lib/forge-std/src/Vm.sol\":{\"keccak256\":\"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f\",\"license\":\"MIT OR Apache-2.0\",\"urls\":[\"bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f\",\"dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/forge-std/src/StdJson.sol":"stdJson"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/forge-std/src/StdJson.sol":{"keccak256":"0xbc0132abe1c2accc2867c0f03667afffdf92f3e95a581bb03c9557eaa38ea500","urls":["bzz-raw://eb6fab37dc73c219cfbb7b4f4998bcf7677ca5397a867e850f40232192073974","dweb:/ipfs/QmUHsbVdp9SKmgek7ZfPcLTKrpZFXpqaqt4sVejzxGEQL3"],"license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f","urls":["bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f","dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL"],"license":"MIT OR Apache-2.0"}},"version":1},"id":6}

deployment/11155111/v1/out/StdMath.sol/stdMath.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220adcf8debe9b04ab23be8899f7649898efd38d0c0661f99c6186f371e6c71255d64736f6c634300081e0033","sourceMap":"65:1533:7:-:0;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x5f80fdfea2646970667358221220adcf8debe9b04ab23be8899f7649898efd38d0c0661f99c6186f371e6c71255d64736f6c634300081e0033","sourceMap":"65:1533:7:-:0;;","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/forge-std/src/StdMath.sol\":\"stdMath\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/forge-std/src/StdMath.sol\":{\"keccak256\":\"0xcb876f5421e5aae334f9a6c5d549131c18ad347f1035d2a1e920f2623f346c85\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://28076e06b01be4095f860fa9b142c284bac34c0813948e0a52d11acc15502db6\",\"dweb:/ipfs/QmVR6XFTmBatJAVvYgkZxN21R5zvYTU4ard4Aow8TmXjy9\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/forge-std/src/StdMath.sol":"stdMath"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/forge-std/src/StdMath.sol":{"keccak256":"0xcb876f5421e5aae334f9a6c5d549131c18ad347f1035d2a1e920f2623f346c85","urls":["bzz-raw://28076e06b01be4095f860fa9b142c284bac34c0813948e0a52d11acc15502db6","dweb:/ipfs/QmVR6XFTmBatJAVvYgkZxN21R5zvYTU4ard4Aow8TmXjy9"],"license":"MIT"}},"version":1},"id":7}

deployment/11155111/v1/out/StdStorage.sol/stdStorage.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea26469706673582212205da5662f9d842c8ded410a0b709c832567faa4171dcdb71541befdbf20e9a73964736f6c634300081e0033","sourceMap":"12755:5081:8:-:0;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x5f80fdfea26469706673582212205da5662f9d842c8ded410a0b709c832567faa4171dcdb71541befdbf20e9a73964736f6c634300081e0033","sourceMap":"12755:5081:8:-:0;;","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/forge-std/src/StdStorage.sol\":\"stdStorage\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/forge-std/src/StdStorage.sol\":{\"keccak256\":\"0x04102de0a79398e4bdea57b7a4818655b4cc66d6f81d1cff08bf428cd0b384cd\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://53edc6c8f7f67cafc0129f039637c77d979880f7f1947defea31e8f0c05095bc\",\"dweb:/ipfs/QmUKXJd1vFCkxxrkXNLURdXrx2apoyWQFrFb5UqNkjdHVi\"]},\"lib/forge-std/src/Vm.sol\":{\"keccak256\":\"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f\",\"license\":\"MIT OR Apache-2.0\",\"urls\":[\"bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f\",\"dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/forge-std/src/StdStorage.sol":"stdStorage"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/forge-std/src/StdStorage.sol":{"keccak256":"0x04102de0a79398e4bdea57b7a4818655b4cc66d6f81d1cff08bf428cd0b384cd","urls":["bzz-raw://53edc6c8f7f67cafc0129f039637c77d979880f7f1947defea31e8f0c05095bc","dweb:/ipfs/QmUKXJd1vFCkxxrkXNLURdXrx2apoyWQFrFb5UqNkjdHVi"],"license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f","urls":["bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f","dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL"],"license":"MIT OR Apache-2.0"}},"version":1},"id":8}

deployment/11155111/v1/out/StdStyle.sol/StdStyle.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea26469706673582212200129420999a12c7d2a0dfd6cc82ba6ee0da34a58e359b77d477502f6d9c20a6964736f6c634300081e0033","sourceMap":"100:10361:9:-:0;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x5f80fdfea26469706673582212200129420999a12c7d2a0dfd6cc82ba6ee0da34a58e359b77d477502f6d9c20a6964736f6c634300081e0033","sourceMap":"100:10361:9:-:0;;","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/forge-std/src/StdStyle.sol\":\"StdStyle\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/forge-std/src/StdStyle.sol\":{\"keccak256\":\"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://51363ca97404cf4128e1141428949768c31929e75e014b02c85e887fbbb4f1b8\",\"dweb:/ipfs/QmVhtbQc2fU4rRmbcfBtz34mAgG4BAZBsbna1Ca4SkoPsK\"]},\"lib/forge-std/src/Vm.sol\":{\"keccak256\":\"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f\",\"license\":\"MIT OR Apache-2.0\",\"urls\":[\"bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f\",\"dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/forge-std/src/StdStyle.sol":"StdStyle"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/forge-std/src/StdStyle.sol":{"keccak256":"0x43e2a8a9b9c2574dabe74f11adf6f782df218f463540e3b5b563609fe108597d","urls":["bzz-raw://51363ca97404cf4128e1141428949768c31929e75e014b02c85e887fbbb4f1b8","dweb:/ipfs/QmVhtbQc2fU4rRmbcfBtz34mAgG4BAZBsbna1Ca4SkoPsK"],"license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f","urls":["bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f","dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL"],"license":"MIT OR Apache-2.0"}},"version":1},"id":9}

deployment/11155111/v1/out/StdToml.sol/stdToml.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea26469706673582212209381f67b910e65daaccbeddb8a817e5755fa86dbd21b14e6400fd7efd30ad9fa64736f6c634300081e0033","sourceMap":"610:9092:13:-:0;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x5f80fdfea26469706673582212209381f67b910e65daaccbeddb8a817e5755fa86dbd21b14e6400fd7efd30ad9fa64736f6c634300081e0033","sourceMap":"610:9092:13:-:0;;","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/forge-std/src/StdToml.sol\":\"stdToml\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/forge-std/src/StdToml.sol\":{\"keccak256\":\"0x58a72c765ed3f7ff6b105509689658795b8a3739b8931772a497155878381861\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b4a3746f4fabaeb980bd77d9e091d3904ee38a6c0e191bfa8ba6874c6f8558a3\",\"dweb:/ipfs/QmUfFDMEn461FgGEXt5HicyGD54sc28sLaQ9JRWDMBKed8\"]},\"lib/forge-std/src/Vm.sol\":{\"keccak256\":\"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f\",\"license\":\"MIT OR Apache-2.0\",\"urls\":[\"bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f\",\"dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/forge-std/src/StdToml.sol":"stdToml"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/forge-std/src/StdToml.sol":{"keccak256":"0x58a72c765ed3f7ff6b105509689658795b8a3739b8931772a497155878381861","urls":["bzz-raw://b4a3746f4fabaeb980bd77d9e091d3904ee38a6c0e191bfa8ba6874c6f8558a3","dweb:/ipfs/QmUfFDMEn461FgGEXt5HicyGD54sc28sLaQ9JRWDMBKed8"],"license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f","urls":["bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f","dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL"],"license":"MIT OR Apache-2.0"}},"version":1},"id":13}

deployment/11155111/v1/out/StdUtils.sol/StdUtils.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"deployedBytecode":{"object":"0x","sourceMap":"","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/forge-std/src/StdUtils.sol\":\"StdUtils\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/forge-std/src/StdUtils.sol\":{\"keccak256\":\"0xb2469a902a326074034c4f7081d868113db0edbb7cf48b86528af2d6b07295f8\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1430a81c4978be875e2a3b31a8bfa4e1438fecd327f23771b690d64db63c020a\",\"dweb:/ipfs/QmW6aB2u1LNaRgGQFwjV7L7UbxsRg63iJ7AuujPouEa4cT\"]},\"lib/forge-std/src/Vm.sol\":{\"keccak256\":\"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f\",\"license\":\"MIT OR Apache-2.0\",\"urls\":[\"bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f\",\"dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL\"]},\"lib/forge-std/src/interfaces/IMulticall3.sol\":{\"keccak256\":\"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://d95ebb7c7c463e08ebc12dab639945752fb2480acfc6e86da32f72732a7fd0c0\",\"dweb:/ipfs/QmNXK8P8oPWwajsQHvAHw3JPyQidPLCGQN3hWu1Lk6PBL2\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/forge-std/src/StdUtils.sol":"StdUtils"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/forge-std/src/StdUtils.sol":{"keccak256":"0xb2469a902a326074034c4f7081d868113db0edbb7cf48b86528af2d6b07295f8","urls":["bzz-raw://1430a81c4978be875e2a3b31a8bfa4e1438fecd327f23771b690d64db63c020a","dweb:/ipfs/QmW6aB2u1LNaRgGQFwjV7L7UbxsRg63iJ7AuujPouEa4cT"],"license":"MIT"},"lib/forge-std/src/Vm.sol":{"keccak256":"0x9b4df44a3b748593a58be7ba64fa5f420e5dcd7927bfa5173186228bfe61782f","urls":["bzz-raw://b89fcf92ee1d14237cfb0dd949341053389d5b6a043ad77349b65bef80b1d59f","dweb:/ipfs/QmPkia3aNHrqvE4tqxG2AyrdB4W91jTAvcbchgs2wAo6NL"],"license":"MIT OR Apache-2.0"},"lib/forge-std/src/interfaces/IMulticall3.sol":{"keccak256":"0x7aac1389150499a922d1f9ef5749c908cef127cb2075b92fa17e9cb611263d0a","urls":["bzz-raw://d95ebb7c7c463e08ebc12dab639945752fb2480acfc6e86da32f72732a7fd0c0","dweb:/ipfs/QmNXK8P8oPWwajsQHvAHw3JPyQidPLCGQN3hWu1Lk6PBL2"],"license":"MIT"}},"version":1},"id":10}

deployment/11155111/v1/out/StorageSlot.sol/StorageSlot.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220ea5a41e6dbc6ca08b6521f0969fc2f079cea68e510c192f94e81f843a5e6d3b264736f6c634300081e0033","sourceMap":"1407:2774:32:-:0;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x5f80fdfea2646970667358221220ea5a41e6dbc6ca08b6521f0969fc2f079cea68e510c192f94e81f843a5e6d3b264736f6c634300081e0033","sourceMap":"1407:2774:32:-:0;;","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"details\":\"Library for reading and writing primitive types to specific storage slots. Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. This library helps with reading and writing to such slots without the need for inline assembly. The functions in this library return Slot structs that contain a `value` member that can be used to read or write. Example usage to set ERC-1967 implementation slot: ```solidity contract ERC1967 {     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;     function _getImplementation() internal view returns (address) {         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;     }     function _setImplementation(address newImplementation) internal {         require(newImplementation.code.length > 0);         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;     } } ``` TIP: Consider using this library along with {SlotDerivation}.\",\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol\":\"StorageSlot\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol\":{\"keccak256\":\"0xcf74f855663ce2ae00ed8352666b7935f6cddea2932fdf2c3ecd30a9b1cd0e97\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://9f660b1f351b757dfe01438e59888f31f33ded3afcf5cb5b0d9bf9aa6f320a8b\",\"dweb:/ipfs/QmarDJ5hZEgBtCmmrVzEZWjub9769eD686jmzb2XpSU1cM\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":"StorageSlot"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":{"keccak256":"0xcf74f855663ce2ae00ed8352666b7935f6cddea2932fdf2c3ecd30a9b1cd0e97","urls":["bzz-raw://9f660b1f351b757dfe01438e59888f31f33ded3afcf5cb5b0d9bf9aa6f320a8b","dweb:/ipfs/QmarDJ5hZEgBtCmmrVzEZWjub9769eD686jmzb2XpSU1cM"],"license":"MIT"}},"version":1},"id":32}

deployment/11155111/v1/out/build-info/425098d9ecb6b837.json

@@ -0,0 +1 @@
+{"id":"425098d9ecb6b837","source_id_to_path":{"0":"lib/abdk-libraries-solidity/ABDKMath64x64.sol","1":"lib/forge-std/src/Base.sol","2":"lib/forge-std/src/Script.sol","3":"lib/forge-std/src/StdChains.sol","4":"lib/forge-std/src/StdCheats.sol","5":"lib/forge-std/src/StdConstants.sol","6":"lib/forge-std/src/StdJson.sol","7":"lib/forge-std/src/StdMath.sol","8":"lib/forge-std/src/StdStorage.sol","9":"lib/forge-std/src/StdStyle.sol","10":"lib/forge-std/src/StdUtils.sol","11":"lib/forge-std/src/Vm.sol","12":"lib/forge-std/src/console.sol","13":"lib/forge-std/src/console2.sol","14":"lib/forge-std/src/interfaces/IMulticall3.sol","15":"lib/forge-std/src/safeconsole.sol","16":"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol","17":"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol","18":"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol","19":"lib/openzeppelin-contracts/contracts/interfaces/IERC3156FlashBorrower.sol","20":"lib/openzeppelin-contracts/contracts/interfaces/IERC3156FlashLender.sol","21":"lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol","22":"lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","23":"lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol","24":"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol","25":"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol","26":"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol","27":"lib/openzeppelin-contracts/contracts/utils/Address.sol","28":"lib/openzeppelin-contracts/contracts/utils/Context.sol","29":"lib/openzeppelin-contracts/contracts/utils/Errors.sol","30":"lib/openzeppelin-contracts/contracts/utils/LowLevelCall.sol","31":"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol","32":"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol","33":"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol","34":"script/DeploySepolia.sol","35":"src/ERC20External.sol","36":"src/ERC20Internal.sol","37":"src/IOwnable.sol","38":"src/IPartyFlashCallback.sol","39":"src/IPartyPlanner.sol","40":"src/IPartyPool.sol","41":"src/IPartyPoolViewer.sol","42":"src/LMSRStabilized.sol","43":"src/LMSRStabilizedBalancedPair.sol","44":"src/NativeWrapper.sol","45":"src/OwnableExternal.sol","46":"src/OwnableInternal.sol","47":"src/PartyPlanner.sol","48":"src/PartyPool.sol","49":"src/PartyPoolBalancedPair.sol","50":"src/PartyPoolBase.sol","51":"src/PartyPoolDeployer.sol","52":"src/PartyPoolHelpers.sol","53":"src/PartyPoolMintImpl.sol","54":"src/PartyPoolSwapImpl.sol","55":"src/PartyPoolViewer.sol","56":"test/Deploy.sol","57":"test/MockERC20.sol","58":"test/WETH9.sol"},"language":"Solidity"}

deployment/11155111/v1/out/build-info/94d187b8ff52264a.json

@@ -0,0 +1 @@
+{"id":"94d187b8ff52264a","source_id_to_path":{"0":"lib/abdk-libraries-solidity/ABDKMath64x64.sol","1":"lib/forge-std/src/Base.sol","2":"lib/forge-std/src/Script.sol","3":"lib/forge-std/src/StdChains.sol","4":"lib/forge-std/src/StdCheats.sol","5":"lib/forge-std/src/StdConstants.sol","6":"lib/forge-std/src/StdJson.sol","7":"lib/forge-std/src/StdMath.sol","8":"lib/forge-std/src/StdStorage.sol","9":"lib/forge-std/src/StdStyle.sol","10":"lib/forge-std/src/StdUtils.sol","11":"lib/forge-std/src/Vm.sol","12":"lib/forge-std/src/console.sol","13":"lib/forge-std/src/console2.sol","14":"lib/forge-std/src/interfaces/IMulticall3.sol","15":"lib/forge-std/src/safeconsole.sol","16":"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol","17":"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol","18":"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol","19":"lib/openzeppelin-contracts/contracts/interfaces/IERC3156FlashBorrower.sol","20":"lib/openzeppelin-contracts/contracts/interfaces/IERC3156FlashLender.sol","21":"lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol","22":"lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","23":"lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol","24":"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol","25":"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol","26":"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol","27":"lib/openzeppelin-contracts/contracts/utils/Address.sol","28":"lib/openzeppelin-contracts/contracts/utils/Context.sol","29":"lib/openzeppelin-contracts/contracts/utils/Errors.sol","30":"lib/openzeppelin-contracts/contracts/utils/LowLevelCall.sol","31":"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol","32":"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol","33":"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol","34":"script/DeploySepolia.sol","35":"src/ERC20External.sol","36":"src/ERC20Internal.sol","37":"src/IPartyFlashCallback.sol","38":"src/IPartyPlanner.sol","39":"src/IPartyPool.sol","40":"src/IPartyPoolViewer.sol","41":"src/LMSRStabilized.sol","42":"src/LMSRStabilizedBalancedPair.sol","43":"src/NativeWrapper.sol","44":"src/PartyPlanner.sol","45":"src/PartyPool.sol","46":"src/PartyPoolBalancedPair.sol","47":"src/PartyPoolBase.sol","48":"src/PartyPoolDeployer.sol","49":"src/PartyPoolHelpers.sol","50":"src/PartyPoolMintImpl.sol","51":"src/PartyPoolSwapImpl.sol","52":"src/PartyPoolViewer.sol","53":"test/Deploy.sol","54":"test/MockERC20.sol","55":"test/WETH9.sol"},"language":"Solidity"}

deployment/11155111/v1/out/build-info/bc3908669ec8c50f.json

@@ -0,0 +1 @@
+{"id":"bc3908669ec8c50f","source_id_to_path":{"0":"lib/abdk-libraries-solidity/ABDKMath64x64.sol","1":"lib/forge-std/src/Base.sol","2":"lib/forge-std/src/Script.sol","3":"lib/forge-std/src/StdAssertions.sol","4":"lib/forge-std/src/StdChains.sol","5":"lib/forge-std/src/StdCheats.sol","6":"lib/forge-std/src/StdConstants.sol","7":"lib/forge-std/src/StdError.sol","8":"lib/forge-std/src/StdInvariant.sol","9":"lib/forge-std/src/StdJson.sol","10":"lib/forge-std/src/StdMath.sol","11":"lib/forge-std/src/StdStorage.sol","12":"lib/forge-std/src/StdStyle.sol","13":"lib/forge-std/src/StdToml.sol","14":"lib/forge-std/src/StdUtils.sol","15":"lib/forge-std/src/Test.sol","16":"lib/forge-std/src/Vm.sol","17":"lib/forge-std/src/console.sol","18":"lib/forge-std/src/console2.sol","19":"lib/forge-std/src/interfaces/IMulticall3.sol","20":"lib/forge-std/src/safeconsole.sol","21":"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol","22":"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol","23":"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol","24":"lib/openzeppelin-contracts/contracts/interfaces/IERC20Metadata.sol","25":"lib/openzeppelin-contracts/contracts/interfaces/IERC3156FlashBorrower.sol","26":"lib/openzeppelin-contracts/contracts/interfaces/IERC3156FlashLender.sol","27":"lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol","28":"lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","29":"lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol","30":"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol","31":"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol","32":"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol","33":"lib/openzeppelin-contracts/contracts/utils/Address.sol","34":"lib/openzeppelin-contracts/contracts/utils/Context.sol","35":"lib/openzeppelin-contracts/contracts/utils/Errors.sol","36":"lib/openzeppelin-contracts/contracts/utils/LowLevelCall.sol","37":"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol","38":"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol","39":"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol","40":"script/DeployMock.sol","41":"script/DeploySepolia.sol","42":"src/ERC20External.sol","43":"src/ERC20Internal.sol","44":"src/IOwnable.sol","45":"src/IPartyFlashCallback.sol","46":"src/IPartyPlanner.sol","47":"src/IPartyPool.sol","48":"src/IPartyPoolViewer.sol","49":"src/LMSRStabilized.sol","50":"src/LMSRStabilizedBalancedPair.sol","51":"src/NativeWrapper.sol","52":"src/OwnableExternal.sol","53":"src/OwnableInternal.sol","54":"src/PartyPlanner.sol","55":"src/PartyPool.sol","56":"src/PartyPoolBalancedPair.sol","57":"src/PartyPoolBase.sol","58":"src/PartyPoolDeployer.sol","59":"src/PartyPoolHelpers.sol","60":"src/PartyPoolMintImpl.sol","61":"src/PartyPoolSwapImpl.sol","62":"src/PartyPoolViewer.sol","63":"test/Deploy.sol","64":"test/GasTest.sol","65":"test/LMSRStabilized.t.sol","66":"test/MockERC20.sol","67":"test/NativeTest.t.sol","68":"test/PartyPlanner.t.sol","69":"test/PartyPool.t.sol","70":"test/WETH9.sol"},"language":"Solidity"}

deployment/11155111/v1/out/build-info/c5529240b2dab858.json

@@ -0,0 +1 @@
+{"id":"c5529240b2dab858","source_id_to_path":{"0":"lib/abdk-libraries-solidity/ABDKMath64x64.sol","1":"lib/forge-std/src/Base.sol","2":"lib/forge-std/src/Script.sol","3":"lib/forge-std/src/StdAssertions.sol","4":"lib/forge-std/src/StdChains.sol","5":"lib/forge-std/src/StdCheats.sol","6":"lib/forge-std/src/StdConstants.sol","7":"lib/forge-std/src/StdError.sol","8":"lib/forge-std/src/StdInvariant.sol","9":"lib/forge-std/src/StdJson.sol","10":"lib/forge-std/src/StdMath.sol","11":"lib/forge-std/src/StdStorage.sol","12":"lib/forge-std/src/StdStyle.sol","13":"lib/forge-std/src/StdToml.sol","14":"lib/forge-std/src/StdUtils.sol","15":"lib/forge-std/src/Test.sol","16":"lib/forge-std/src/Vm.sol","17":"lib/forge-std/src/console.sol","18":"lib/forge-std/src/console2.sol","19":"lib/forge-std/src/interfaces/IMulticall3.sol","20":"lib/forge-std/src/safeconsole.sol","21":"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol","22":"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol","23":"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol","24":"lib/openzeppelin-contracts/contracts/interfaces/IERC3156FlashBorrower.sol","25":"lib/openzeppelin-contracts/contracts/interfaces/IERC3156FlashLender.sol","26":"lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol","27":"lib/openzeppelin-contracts/contracts/proxy/Proxy.sol","28":"lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol","29":"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol","30":"lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol","31":"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol","32":"lib/openzeppelin-contracts/contracts/utils/Address.sol","33":"lib/openzeppelin-contracts/contracts/utils/Context.sol","34":"lib/openzeppelin-contracts/contracts/utils/Errors.sol","35":"lib/openzeppelin-contracts/contracts/utils/LowLevelCall.sol","36":"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol","37":"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol","38":"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol","39":"script/DeployMock.sol","40":"script/DeploySepolia.sol","41":"src/ERC20External.sol","42":"src/ERC20Internal.sol","43":"src/IOwnable.sol","44":"src/IPartyFlashCallback.sol","45":"src/IPartyPlanner.sol","46":"src/IPartyPool.sol","47":"src/IPartyPoolViewer.sol","48":"src/LMSRStabilized.sol","49":"src/LMSRStabilizedBalancedPair.sol","50":"src/NativeWrapper.sol","51":"src/OwnableExternal.sol","52":"src/OwnableInternal.sol","53":"src/PartyPlanner.sol","54":"src/PartyPool.sol","55":"src/PartyPoolBalancedPair.sol","56":"src/PartyPoolBase.sol","57":"src/PartyPoolDeployer.sol","58":"src/PartyPoolHelpers.sol","59":"src/PartyPoolMintImpl.sol","60":"src/PartyPoolSwapImpl.sol","61":"src/PartyPoolViewer.sol","62":"test/Deploy.sol","63":"test/GasTest.sol","64":"test/MockERC20.sol","65":"test/NativeTest.t.sol","66":"test/PartyPlanner.t.sol","67":"test/PartyPool.t.sol","68":"test/WETH9.sol"},"language":"Solidity"}

deployment/11155111/v1/out/console.sol/console.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220afc188cd5160e43f0d46902109404da8f6c8b1df4eb40d16374d9645b8ecd8c964736f6c634300081e0033","sourceMap":"66:69203:12:-:0;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x5f80fdfea2646970667358221220afc188cd5160e43f0d46902109404da8f6c8b1df4eb40d16374d9645b8ecd8c964736f6c634300081e0033","sourceMap":"66:69203:12:-:0;;","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/forge-std/src/console.sol\":\"console\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/forge-std/src/console.sol\":{\"keccak256\":\"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://af9e3a7c3d82fb5b10b57ca4d1a82f2acbef80c077f6f6ef0cc0187c7bfd9f57\",\"dweb:/ipfs/QmR9VzmnBDJpgiDP6CHT6truehukF9HpYvuP6kRiJbDwPP\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/forge-std/src/console.sol":"console"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/forge-std/src/console.sol":{"keccak256":"0x4bbf47eb762cef93729d6ef15e78789957147039b113e5d4df48e3d3fd16d0f5","urls":["bzz-raw://af9e3a7c3d82fb5b10b57ca4d1a82f2acbef80c077f6f6ef0cc0187c7bfd9f57","dweb:/ipfs/QmR9VzmnBDJpgiDP6CHT6truehukF9HpYvuP6kRiJbDwPP"],"license":"MIT"}},"version":1},"id":12}

deployment/11155111/v1/out/safeconsole.sol/safeconsole.json

@@ -0,0 +1 @@
+{"abi":[],"bytecode":{"object":"0x6080806040523460175760399081601c823930815050f35b5f80fdfe5f80fdfea2646970667358221220709c8134992b5fef4e2bf94b521207862a1126f22dcc0c41899199d76b8ca7c164736f6c634300081e0033","sourceMap":"163:427371:15:-:0;;;;;;;;;;;;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"0x5f80fdfea2646970667358221220709c8134992b5fef4e2bf94b521207862a1126f22dcc0c41899199d76b8ca7c164736f6c634300081e0033","sourceMap":"163:427371:15:-:0;;","linkReferences":{}},"methodIdentifiers":{},"rawMetadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[],\"devdoc\":{\"author\":\"philogy <https://github.com/philogy>\",\"details\":\"Code generated automatically by script.\",\"kind\":\"dev\",\"methods\":{},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"lib/forge-std/src/safeconsole.sol\":\"safeconsole\"},\"evmVersion\":\"prague\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100000000},\"remappings\":[\":@abdk/=lib/abdk-libraries-solidity/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":abdk-libraries-solidity/=lib/abdk-libraries-solidity/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\"],\"viaIR\":true},\"sources\":{\"lib/forge-std/src/safeconsole.sol\":{\"keccak256\":\"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3bafd2b0b2d28068d329f95ea8a1fbce3719c257fcb863fc01abcbafd8d531ab\",\"dweb:/ipfs/QmUeaFjKWTVDBsHVfSob4mwt6A5hTnKDz22HaUXeZhypa3\"]}},\"version\":1}","metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[],"devdoc":{"kind":"dev","methods":{},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"remappings":["@abdk/=lib/abdk-libraries-solidity/","@openzeppelin/=lib/openzeppelin-contracts/","abdk-libraries-solidity/=lib/abdk-libraries-solidity/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/"],"optimizer":{"enabled":true,"runs":100000000},"metadata":{"bytecodeHash":"ipfs"},"compilationTarget":{"lib/forge-std/src/safeconsole.sol":"safeconsole"},"evmVersion":"prague","libraries":{},"viaIR":true},"sources":{"lib/forge-std/src/safeconsole.sol":{"keccak256":"0xbef9786cb49d3eade757bad87568c49c8c8f35721f0193c95ffb055d9e466e11","urls":["bzz-raw://3bafd2b0b2d28068d329f95ea8a1fbce3719c257fcb863fc01abcbafd8d531ab","dweb:/ipfs/QmUeaFjKWTVDBsHVfSob4mwt6A5hTnKDz22HaUXeZhypa3"],"license":"MIT"}},"version":1},"id":15}

deployment/liqp-deployments.json

@@ -0,0 +1,17 @@
+{
+  "11155111": {
+    "v1": {
+      "PartyPlanner": "0x2954911231c44E49938b2FBd1e0cD2787FdF69AD",
+      "PartyPoolViewer": "0x71b04a353a77405a3217EAF3A24BA619B86cD5E9",
+      "PartyPoolMintImpl": "0x705272c50F905204187B3126701BeDEd82Dc2F9a",
+      "PartyPoolSwapImpl": "0xC9608aAaF772c1cAce83C863e88EC4FF54017CeB",
+      "PartyPoolDeployer": "0x6811C56804321F811eAFa3f7694b026d738Ba7a1",
+      "PartyPoolBalancedPairDeployer": "0xc321406Fc8e174Bb0D006C145D515b858b1b883d",
+      "USXD": "0x8E4D16886b8946dfE463fA172129eaBf4825fb09",
+      "FUSD": "0xdc225280216822CA956738390f589c794129bd53",
+      "DIVE": "0x7ba123e4e7395A361284d069bD0D545F3f820641",
+      "BUTC": "0x88125947BBF1A6dd0FeD4B257BB3f9E1FBdCb3Cc",
+      "WTETH": "0xC8dB65C0B9f4cf59097d4C5Bcb9e8E92B9e4e15F"
+    }
+  }
+}

doc/introduction.md

@@ -1,44 +0,0 @@
-# Introduction
-
-[Liquidity Party](https://liquidity.party) is a new game-theoretic multi-asset AMM based on this paper:
-
-[Logarithmic Market Scoring Rules for Modular Combinatorial Information Aggregation](https://mason.gmu.edu/~rhanson/mktscore.pdf) (R. Hanson, 2002)
-
-A Logarithmic Market Scoring Rule (LMSR) is a pricing formula for AMM's that know only their current asset inventories and no other information, naturally supporting multi-asset
-
-Compared to Constant Product (CP) markets, LMSR offers:
-
-1. Less slippage than CP for small and medium trade sizes
-2. N-asset pools for trading long-tail pairs in a single hop
-3. Lower fees (smaller spread)
-
-
-## Deeper Liquidity
-
-According to game theory, CP's slope at the current marginal price is too steep, overcharging takers with too much slippage at small and medium trade sizes. LMSR pools offer less slippage and cheaper liquidity for the small and medium trade sizes common for arbitrageurs and aggregators.
-
-
-## Multi-asset
-
-Naturally multi-asset, Liquidity Party altcoin pools provide direct, one-hop swaps on otherwise illiquid multi-hop pairs. Pools will quote any pair combination available in the pool:
-
-| Assets | Pairs | Swap Gas |  Mint Gas |
-|-------:|------:|---------:|----------:|
-|      2 |     1 |  146,000 |   149,000 |
-|     10 |    45 |  157,000 |   426,000 |
-|     20 |   190 |  171,000 |   772,000 |
-|     50 |  1225 |  213,000 | 1,810,000 |
-|    100 |  4950 |  283,000 | 3,542,000 |
-
-Liquidity Party aggregates scarce, low market cap assets into a single pool, providing one-hop liquidity for exotic pairs without fragmenting LP assets. CP pools would need 190x the LP assets to provide the same pairwise liquidity as a single 20-asset Liquidity Party pool, due to asset fragmentation.
-
-## Lower Fees
-
-Since market makers offer the option to take either side of the market, they must receive a subsidy or charge a fee (spread) to compensate for adverse selection (impermanent loss). By protecting LP's against common value-extraction scenarios, LMSR pools have a reduced risk premium resulting in lower fees for takers.
-
-### Minimized Impermanent Loss
-
-### No Intra-Pool Arbitrage
-
-LMSR 
-This leads to LP's of CP pools demanding higher fees than theoretically necessary. By minimizing impermanent loss for LP's, LMSR pools reduce the risk premium, providing lower fees and higher liquidity for takers.

doc/launch_list.md

@@ -0,0 +1,24 @@
+| Symbol          | Address                                      |
+|-----------------|----------------------------------------------|
+| **Stablecoins** |                                              |
+| USDT            | `0xdAC17F958D2ee523a2206206994597C13D831ec7` |
+| USDC            | `0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48` |
+| USDe            | `0x4c9EDD5852cd905f086C759E8383e09bff1E68B3` |
+| DAI             | `0x6B175474E89094C44Da98b954EedeAC495271d0F` |
+| **Chain Coins** |                                              |
+| WETH            | `0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2` |
+| WBTC            | `0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599` |
+| WSOL            | `0xd1D82d3Ab815E0B47e38EC2d666c5b8AA05Ae501` |
+| BNB             | `0xB8c77482e45F1F44dE1745F52C74426C631bDD52` |
+| TRX             | `0x50327c6c5a14DCaDE707ABad2E27eB517df87AB5` |
+| POL             | `0x455e53CBB86018Ac2B8092FdCd39d8444aFFC3F6` |
+| DOT             | `0x21c2c96Dbfa137E23946143c71AC8330F9B44001` |
+| NEAR            | `0x85F17Cf997934a597031b2E18a9aB6ebD4B9f6a4` |
+| **Others**      |                                              |
+| WBETH           | `0xa2E3356610840701BDf5611a53974510Ae27E2e1` |
+| ARB             | `0xB50721BCf8d664c30412Cfbc6cf7a15145234ad1` |
+| UNI             | `0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984` |
+| LINK            | `0x514910771AF9Ca656af840dff83E8264EcF986CA` |
+| AAVE            | `0x7Fc66500c84A76Ad7e9c93437bFc5Ac33E2DDaE9` |
+| PEPE            | `0x6982508145454Ce325dDbE47a25d4ec3d2311933` |
+| SHIB            | `0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE` |

doc/whitepaper.md

@@ -1,551 +1,253 @@
 # LMSR-based Multi-Asset AMM
 
-Abstract
-We propose a multi-asset automated market maker (AMM) whose pricing kernel is the Logarithmic Market Scoring Rule (LMSR) (Hanson, 2002.) The AMM maintains a convex potential $C(\mathbf{q}) = b(\mathbf{q}) \log\!\big(\sum_i e^{q_i / b(\mathbf{q})}\big)$ over normalized inventories $\mathbf{q}$ and sets the effective liquidity parameter proportional to pool size, $b(\mathbf{q}) = \kappa \, S(\mathbf{q})$ with $S(\mathbf{q}) = \sum_i q_i$ and fixed $\kappa>0$. This choice preserves scale-invariant responsiveness while retaining LMSR’s softmax pricing structure under a quasi-static-$b$ view. We derive closed-form expressions for asset-to-asset swaps in the induced two-asset subspace, including exact-in, exact-out, limit-hitting (swap-to-limit), and capped-output variants. We discuss numerical stability techniques (e.g., log-sum-exp reformulations, guarded domains) and a balanced two-asset specialization that enables polynomial approximations with provable error bounds. The protocol is parameter-fixed at deployment (no governance over $\kappa$ or fees), yielding reproducible behavior and transparent depth calibration. Analytical and numerical evidence suggest that this LMSR AMM combines desirable theoretical properties (convexity, path-independent cost differences at constant $b$, multi-asset support) with practical robustness (monotonicity preservation and conservative fallbacks). We outline liquidity operations (proportional and single-asset joins/exits), fee accrual to LPs via state appreciation, and risk considerations.
-
-Keywords
-AMM; LMSR; cost-function market maker; multi-asset liquidity; bounded loss; convex optimization; fixed-point arithmetic; numerical stability.
-
-2) Executive Summary
-
-Motivation and problem
-- Multi-asset liquidity often faces a trade-off between simplicity (CFMM invariants) and expressivity (risk sharing across many assets). We pursue an AMM that natively supports many assets while delivering predictable depth and strong theoretical guarantees.
-
-Mechanism overview
-- The AMM’s kernel is the LMSR cost function
-  $$C(\mathbf{q}) = b(\mathbf{q}) \log\!\left(\sum_i e^{q_i / b(\mathbf{q})}\right),\qquad b(\mathbf{q})=\kappa\,S(\mathbf{q}),\;\; S(\mathbf{q})=\sum_i q_i.$$
-- Instantaneous marginal price ratios follow the softmax structure under quasi-static $b$:
-  $$P(\text{base}\to\text{quote}\mid \mathbf{q})=\exp\!\left(\frac{q_{\text{quote}}-q_{\text{base}}}{b(\mathbf{q})}\right).$$
-
-Key properties
-- Convex potential and softmax gradient (at constant $b$), multi-asset support via a single potential.
-- Path independence of cost differences under constant $b$; pairwise price ratios preserved under $b=\kappa S$ via a common additive gradient term.
-- Bounded-loss intuition from LMSR extends proportionally with $b$; scale invariance via $b=\kappa S$.
-- Closed forms for two-asset reductions enable exact-in/exact-out and limit-hitting swaps with monotonicity.
-
-Main contributions
-- Fixed-parameter LMSR AMM: $b=\kappa S$ with immutable $\kappa$ and fees post-deployment.
-- Stability techniques: log-sum-exp evaluation, domain guards, ratio shortcuts, and conservative fallbacks.
-- Balanced two-asset optimization: polynomial approximations with error bounds and dispatcher preconditions.
-- Evaluation plan: analytical depth comparisons, numerical accuracy, monotonicity/no-negative-arbitrage checks, and gas microbenchmarks.
-
-3) Background and Related Work
-
-AMM landscape
-- CFMMs define implicit invariants over reserves. Examples include:
-  - Constant product (e.g., Uniswap): $x y = k$, offering simple two-asset liquidity and predictable slippage profiles.
-  - Constant mean (e.g., Balancer): $\prod_i q_i^{w_i} = \text{const}$, generalizing to many assets with weights.
-  - Stableswap (e.g., Curve): combines constant sum and constant product to target low-slippage near parity.
-- LMSR differs by specifying a convex cost function $C(\mathbf{q})$; prices are given by its gradient (or ratios thereof), rather than from a multiplicative invariant.
-
-LMSR primer and adaptation to AMMs
-- The classical LMSR potential with constant $b$ is
-  $$C(\mathbf{q}) = b \log\!\left(\sum_i e^{q_i/b}\right),\qquad \frac{\partial C}{\partial q_i} = \frac{e^{q_i/b}}{\sum_k e^{q_k/b}}.$$
-- In our AMM setting, we parameterize $b(\mathbf{q})=\kappa S(\mathbf{q})$ for scale-invariant responsiveness, and use a quasi-static-$b$ view to compute instantaneous price ratios:
-  $$P(\text{base}\to\text{quote})=\frac{e^{q_{\text{quote}}/b}}{e^{q_{\text{base}}/b}}=\exp\!\left(\frac{q_{\text{quote}}-q_{\text{base}}}{b}\right).$$
-- Two-asset reduction yields closed forms for exact-in and exact-out trades (see Sections 5–6 and Appendix A).
-
-Related LMSR applications and prior DeFi adaptations
-- LMSR originates from scoring-rule-based market making in information markets. Subsequent adaptations explored cost-function AMMs and variants that tailor $b$ to achieve targeted responsiveness. We adopt a proportional $b$ tied to total pool size for transparency and predictable scaling across liquidity regimes.
-
-When LMSR is preferable and limitations
-- Preferable when:
-  - Multi-asset exposure and cross-asset risk sharing are primary goals.
-  - A convex potential with softmax-driven pricing is desired for analytical tractability and monotonic behavior.
-- Limitations and design choices:
-  - With $b=\kappa S$, gradient components include a common additive term; we rely on pairwise ratios for pricing.
-  - Extreme imbalances can induce steep price moves; capacity caps and domain guards mitigate numerical and economic edge cases.
-
-4) System Model and Notation
-
-4.1 State, assets, and units
-- Assets and indices: We consider $n \ge 2$ assets indexed by $i \in \{0,\dots,n-1\}$.
-- State vector: $\mathbf{q} = (q_0,\dots,q_{n-1}) \in \mathbb{R}_{\ge 0}^{\,n}$ denotes normalized internal quantities held by the pool. Each $q_i$ is in common “internal units” so cross-asset operations are comparable. In practice, token amounts are scaled to a common unit (e.g., $10^{-\text{decimals}}$ normalization) and represented with fixed-point arithmetic; equations here are stated over reals for clarity.
-- Size metric: $S(\mathbf{q}) := \sum_i q_i$. This is the aggregate pool size used both to summarize liquidity and to set the effective liquidity parameter.
-- Liquidity parameterization: The effective LMSR liquidity parameter is $b(\mathbf{q}) := \kappa \cdot S(\mathbf{q})$, where $\kappa > 0$ is a fixed, deployment-time constant. Intuitively, $b$ scales linearly with the pool’s total size, preserving responsiveness under proportional rescaling of $\mathbf{q}$.
-- Fees: Let $f_{\text{swap}} \in [0,1)$ denote the swap fee applied at the token layer (separate from the fee-free pricing kernel). Optionally a protocol fee $f_{\text{proto}}$ can be taken as a fraction of the swap fee. All derivations of kernel prices below are fee-free; fees are applied as multiplicative factors to input/output amounts outside the kernel.
-
-4.2 Cost function and prices
-- Cost function: We use the LMSR cost function
-  $$C(\mathbf{q}) \;=\; b(\mathbf{q}) \,\log\!\left(\sum_{i} e^{\,q_i / b(\mathbf{q})}\right).$$
-  For numerical stability we compute it via a log-sum-exp formulation. Define $y_i := q_i / b(\mathbf{q})$ and $M := \max_i y_i$; then
-  $$C(\mathbf{q}) \;=\; b(\mathbf{q}) \left( M + \log \sum_{i} e^{\,y_i - M} \right).$$
-- Price shares (softmax): Define the unnormalized weights $w_i := e^{q_i / b(\mathbf{q})}$ and $W := \sum_i w_i$. The price share of asset $i$ is
-  $$\pi_i(\mathbf{q}) := \frac{w_i}{W} \;=\; \frac{e^{q_i / b(\mathbf{q})}}{\sum_j e^{q_j / b(\mathbf{q})}}.$$
-  Note: With $b$ constant, the gradient satisfies $\partial C/\partial q_i = \pi_i$. With $b = \kappa \, S(\mathbf{q})$, $\partial C/\partial q_i$ includes an additive term common across $i$; differences in marginal prices still track $\pi_i$ up to an additive constant, and the pairwise ratios below remain unchanged.
-- Pairwise marginal price ratio: The instantaneous marginal price of “base” in units of “quote” is
-  $$P(\text{base}\to\text{quote}\mid \mathbf{q}) \;=\; \exp\!\left(\frac{q_{\text{quote}} - q_{\text{base}}}{b(\mathbf{q})}\right).$$
-  This equals $w_{\text{quote}}/w_{\text{base}}$ and is invariant to the common softmax denominator, and remains valid under the quasi-static-$b$ swap model (holding $b$ constant over an infinitesimal trade or a single pricing step; see Appendix A).
-
-4.3 Swap quantities and conventions
-- Exact-in: Given an input amount $a \ge 0$ of asset $i$, the fee-free kernel determines the output amount $y \ge 0$ of asset $j$ by integrating the marginal price along the $i\to j$ path with $b$ held quasi-static at its pre-trade value (see Appendix A).
-- Exact-out: Given a desired output $y \ge 0$ of asset $j$, the fee-free kernel solves for the required input $a \ge 0$ of asset $i$ (inverse of exact-in).
-- Price limits (swap-to-limit): A user can provide a maximum acceptable marginal price ratio $\Lambda > 0$ for $p_i/p_j$. If the marginal price trajectory would exceed $\Lambda$ before consuming the full $a$, the swap truncates at the unique $a_{\text{lim}}$ that reaches $\Lambda$ (see Appendix A).
-- Capacity caps: Outputs cannot exceed the available balance of the out-asset; if a formula would produce $y > q_j$, we cap to $q_j$ and solve inversely for the corresponding input.
-
-4.4 Units, scaling, and normalization
-- Token decimals: For each token $i$ with decimals $d_i$, on-chain amounts are normalized to a common internal unit so that arithmetic over $\mathbf{q}$ is coherent. Let $s_i$ be the scale factor implied by $d_i$; normalized internal balances are proportional to on-chain token balances via $s_i$.
-- Scale invariance: If $\mathbf{q}$ is scaled by $\lambda > 0$ (all assets multiplied by the same $\lambda$), then $S$ scales by $\lambda$ and $b = \kappa S$ scales by $\lambda$; prices as pairwise ratios, $P(\text{base}\to\text{quote})$, are invariant to this rescaling.
-
-4.5 Assumptions
-- Tokens are standard fungible assets with deterministic, non-rebasing balances; no transfer fees are embedded at the kernel level.
-- Swaps and liquidity operations are atomic; the mechanism is permissionless (subject to access rules at the wrapper layer).
-- No external price oracles are required by the kernel; price discovery is endogenous via the cost function.
-- Numerical computations are performed in fixed-point with explicit domain guards (see Appendix B).
-
-5) AMM Design and LMSR Formulation
-
-5.1 Convex potential and invariant view
-- We model the pool by the LMSR potential
-  $$C(\mathbf{q}) \;=\; b(\mathbf{q}) \,\log\!\left(\sum_{i=0}^{n-1} e^{\,q_i / b(\mathbf{q})}\right), \qquad b(\mathbf{q}) = \kappa\,S(\mathbf{q}),\;\; S(\mathbf{q})=\sum_i q_i,$$
-  which induces a softmax over coordinates of $\mathbf{q}$. For pricing, we operate under a quasi-static-$b$ view for an infinitesimal step, recovering the usual LMSR gradient structure (see Section 6 and Appendix A).
-- Intuition: $C$ is a convex potential in $\mathbf{q}$ when $b$ is treated as a constant parameter; gradient components are softmax probabilities. This convexity underpins path independence of cost differences and no-arbitrage properties in the constant-$b$ setting. With $b=\kappa S(\mathbf{q})$, the gradient picks up a common additive term across coordinates; pairwise price ratios, which drive swaps, remain governed by softmax differences (Appendix A).
-
-5.2 Kappa parameterization: $b=\kappa \cdot S$
-- Rationale: Choosing $b$ proportional to pool size preserves responsiveness under proportional rescalings of inventory. If all $q_i$ are multiplied by $\lambda>0$, then $S$ and $b$ scale by $\lambda$, while price ratios
-  $$P(\text{base}\to\text{quote}\mid \mathbf{q}) \;=\; \exp\!\left(\frac{q_{\text{quote}}-q_{\text{base}}}{b(\mathbf{q})}\right)$$
-  remain invariant.
-- Responsiveness: Smaller $\kappa$ yields smaller $b$ for a given $S$, producing steeper price impact (more responsive market); larger $\kappa$ produces deeper liquidity and gentler impact.
-- Conformance: The induced prices coincide with the classic LMSR softmax ratios under quasi-static-$b$, ensuring consistency with LMSR’s scoring-rule interpretation for marginal moves.
-
-5.3 Choice of $S$ and alternatives
-- Default choice: $S(\mathbf{q})=\sum_i q_i$ (the $\ell_1$ size metric) is transparent, easy to compute, and scale-consistent across assets in normalized units.
-- Alternatives:
-  - Weighted sum: $S_w(\mathbf{q})=\sum_i w_i q_i$ for exogenous weights $w_i>0$; may bias depth across assets.
-  - Quadratic norm: $S_2(\mathbf{q})=(\sum_i q_i^2)^{1/2}$; increases $b$ more when inventory is concentrated, potentially dampening extreme price moves.
-- Trade-offs: Simplicity, composability, and transparency argue for $S=\sum_i q_i$. Alternatives can tailor depth but complicate interpretation and comparability.
-
-5.4 Fixed-parameter policy
-- The proportionality constant $\kappa$ and fee parameters are set at deployment and remain immutable. This yields reproducible behavior, eliminates governance risk, and allows users to evaluate depth and price impact ex-ante for a given $S$.
-
-5.5 Bounded-loss and capital efficiency implications
-- Classical LMSR with constant $b$ admits a bounded-loss guarantee of $b\ln n$ in appropriate units. With $b=\kappa S(\mathbf{q})$, scale invariance implies an instantaneous bound per unit of $S$ that is proportional to $\kappa \ln n$; as liquidity scales, so does absolute depth and the notional bound.
-- Capital efficiency: For fixed $\kappa$, larger $S$ linearly increases price depth while preserving price ratios; for fixed $S$, tuning $\kappa$ linearly trades off depth versus responsiveness. The two-asset closed forms in Section 6 quantify this via $y(a)$ and its slope at the origin $y'(0)=\frac{r_0}{1+r_0}$.
-
-6) Pricing and Swap Mechanics
-
-6.1 Instantaneous pricing from the gradient
-- Define unnormalized weights $w_i = e^{q_i/b}$ and $W=\sum_k w_k$. Under quasi-static $b$,
-  $$\pi_i(\mathbf{q})=\frac{\partial C}{\partial q_i}=\frac{w_i}{W},\qquad
-  \frac{\pi_{\text{quote}}}{\pi_{\text{base}}}=\frac{w_{\text{quote}}}{w_{\text{base}}}=\exp\!\left(\frac{q_{\text{quote}}-q_{\text{base}}}{b}\right).$$
-  We interpret $P(\text{base}\to\text{quote}) := \pi_{\text{quote}}/\pi_{\text{base}}$ as the instantaneous marginal price ratio.
-
-6.2 Cost differences and asset-to-asset swaps
-- Conceptually, an asset-to-asset trade from $i$ to $j$ of sizes $(+a,-y)$ satisfies
-  $$\Delta C \;=\; C(\mathbf{q} + a\,\mathbf{e}_i - y\,\mathbf{e}_j) - C(\mathbf{q}),$$
-  and the two-asset reduction with quasi-static $b$ yields a closed-form relation between $a$ and $y$ (Appendix A):
-  $$y(a) \;=\; b \,\ln\!\Big( 1 + r_0 \,\big(1 - e^{-a/b}\big) \Big),\qquad r_0 := \exp\!\left(\frac{q_i - q_j}{b}\right).$$
-- The inverse exact-out mapping for a target $y$ is
-  $$a(y) \;=\; b \,\ln\!\left(\frac{r_0}{\,r_0 + 1 - e^{\,y/b}\,}\right).$$
-
-6.3 Limit-hitting swaps and swap-to-limit
-- For a user-specified price limit $\Lambda > 0$ on $p_i/p_j$, the marginal price trajectory $r(t)=r_0 e^{t/b}$ hits the limit at
-  $$a_{\text{lim}} \;=\; b \,\ln\!\left(\frac{\Lambda}{r_0}\right),\qquad
-    y_{\text{lim}} \;=\; b \,\ln\!\Big( 1 + r_0 \,\big(1 - r_0/\Lambda\big) \Big).$$
-- Capacity cap: If $y_{\text{lim}} > q_j$, cap to $y=q_j$ and use the inverse mapping to compute the implied input
-  $$a_{\text{cap}} \;=\; b \,\ln\!\left(\frac{r_0}{\,r_0 + 1 - e^{\,q_j/b}\,}\right).$$
-
-6.4 Properties: monotonicity, uniqueness, and stability
-- Monotonicity and uniqueness: For feasible states, $y(a)$ is strictly increasing and concave in $a$; the inverse $a(y)$ is strictly increasing and convex in $y$. The limit-hitting $a_{\text{lim}}$ is unique when $\Lambda>r_0$.
-- Numerical stability: Evaluations use log-sum-exp style reformulations, direct ratio formation for $r_0$, and argument guards for $\exp$ and $\ln$. Domain checks ensure denominators (e.g., $r_0 + 1 - e^{y/b}$) remain positive. See Appendix B for details.
-
-7) Liquidity Operations
-
-7.1 Pool initialization and bootstrap
-- Let the seed inventory be $\mathbf{q}^{(0)} \in \mathbb{R}_{\ge 0}^{\,n}$ with $S^{(0)} := \sum_i q_i^{(0)} > 0$. The effective liquidity is $b^{(0)} = \kappa\,S^{(0)}$.
-- LP supply: We take LP supply proportional to the size metric, $L := \eta\,S(\mathbf{q})$, with a fixed conversion $\eta>0$. Without loss of generality we set $\eta=1$ so that
-  $$L \;=\; S(\mathbf{q}) \;=\; \sum_i q_i.$$
-  At bootstrap, the seeder mints $L^{(0)} = S^{(0)}$ LP shares against $\mathbf{q}^{(0)}$.
-- LP price in units of asset $k$: Define the marginal value of one unit of $S$ in asset $k$ as
-  $$P_L^{(k)}(\mathbf{q}) \;=\; \frac{1}{S(\mathbf{q})}\,\sum_{j=0}^{n-1} q_j \,\exp\!\left(\frac{q_j - q_k}{b(\mathbf{q})}\right),$$
-  which aggregates the marginal exchange rates from each asset into $k$ (cf. Section 6).
-
-7.2 Proportional deposit (mint)
-- A proportional deposit scales all coordinates by $(1+\alpha)$ for some $\alpha \ge 0$:
-  $$\mathbf{q}' \;=\; (1+\alpha)\,\mathbf{q},\qquad \Delta q_i \;=\; \alpha\,q_i.$$
-- Minted LP shares are linear in the size-metric increase:
-  $$\Delta L \;=\; L' - L \;=\; S(\mathbf{q}') - S(\mathbf{q}) \;=\; \alpha\,S(\mathbf{q}).$$
-- The post-deposit liquidity is $b'=\kappa\,S(\mathbf{q}')=(1+\alpha)\,b$.
-
-7.3 Single-asset deposit (exact-in)
-- A contributor provides amount $a$ of asset $i$ and receives a proportional growth $\alpha \ge 0$ such that the system state can be rebalanced to $(1+\alpha)\,\mathbf{q}$ by swapping from $i$ into $j\ne i$ along the fee-free kernel. For each $j \ne i$, target out-amount $y_j := \alpha\,q_j$ requires input
-  $$x_j(\alpha) \;=\; b \,\ln\!\left(\frac{r_{0,j}}{\,r_{0,j} + 1 - e^{\,y_j/b}\,}\right),\qquad
-    r_{0,j} \;:=\; \exp\!\left(\frac{q_i - q_j}{b}\right).$$
-- The total input required to realize proportional growth $\alpha$ is
-  $$a_{\text{req}}(\alpha) \;=\; \alpha\,q_i \;+\; \sum_{j\ne i} x_j(\alpha).$$
-- The minted shares are
-  $$\Delta L \;=\; \alpha\,S(\mathbf{q}),$$
-  where $\alpha$ is the unique solution to $a_{\text{req}}(\alpha)=a$ on its feasible domain (see Appendix A.5).
-
-7.4 Multi-asset deposit (arbitrary vector)
-- Given a deposit vector $\mathbf{a} \in \mathbb{R}_{\ge 0}^{\,n}$, decompose it into:
-  - a proportional component $\bar{\alpha} := \min_i \{ a_i / q_i \}$ (with convention $a_i/q_i=+\infty$ if $q_i=0$ and $a_i>0$), which mints $\bar{\alpha}\,S(\mathbf{q})$ shares and updates $\mathbf{q}$ proportionally, and
-  - residuals $\tilde{\mathbf{a}} := \mathbf{a} - \bar{\alpha}\,\mathbf{q}$ that can be contributed via single-asset deposit(s) using 7.3 (sequence or batching).
-- The total minted shares are additive in the realized proportional growths:
-  $$\Delta L \;=\; \left(\bar{\alpha} + \sum_{m} \alpha_m\right)\,S(\mathbf{q})$$
-  where each $\alpha_m$ solves $a_{\text{req}}(\alpha_m)$ for a residual leg.
-
-7.5 Proportional withdrawal (burn)
-- Burning $\Delta L$ LP shares effects a proportional redemption with factor
-  $$\alpha \;=\; \frac{\Delta L}{S(\mathbf{q})} \in (0,1],\qquad \mathbf{q}' \;=\; (1-\alpha)\,\mathbf{q}.$$
-- The holder receives $\alpha\,q_i$ units of each asset $i$; equivalently, $L' = L - \Delta L = S(\mathbf{q}')$ and $b'=(1-\alpha)\,b$.
-
-7.6 Single-asset withdrawal (exact-out)
-- A holder burns $\Delta L$ shares (i.e., $\alpha=\Delta L/S(\mathbf{q})$) and requests payout exclusively in asset $i$. Starting from $\mathbf{q}_\text{local}=(1-\alpha)\,\mathbf{q}$, for each $j\ne i$:
-  - withdraw $\alpha\,q_j$ units of $j$, and
-  - swap $j \to i$ along the fee-free kernel using the two-asset closed form. The candidate out-amount is
-    $$y_{j\to i} \;=\; b \,\ln\!\Big( 1 + r_{0,j}\,\big(1 - e^{-a_j/b}\big) \Big),\quad
-      a_j := \alpha\,q_j,\quad r_{0,j} := \exp\!\left(\frac{q^{\text{local}}_j - q^{\text{local}}_i}{b}\right),$$
-    with $b=\kappa\,S(\mathbf{q})$ evaluated at pre-burn or quasi-static local state.
-- If the computed $y_{j\to i}$ would exceed $q^{\text{local}}_i$, cap to capacity and invert to solve the implied input (Appendix A.6). The total single-asset payout is
-  $$Y_i \;=\; \alpha\,q_i \;+\; \sum_{j\ne i} y_{j\to i}.$$
-
-7.7 Share issuance, pricing, and dilution
-- With $L=S$, share issuance is linear in the size-metric; proportional joins/exits preserve relative ownership. The instantaneous LP price in units of asset $k$ is $P_L^{(k)}(\mathbf{q})$ from 7.1. Under joins, $P_L^{(k)}$ remains unchanged for proportional deposits; under single-asset joins, it adjusts according to the realized rebalancing path.
-
-7.8 Fee accrual to LPs and value capture
-- Swap fees are taken at the token layer and retained in the pool balances, increasing $S(\mathbf{q})$ relative to $L$ and thereby raising $P_L^{(k)}$ for all $k$. This constitutes implicit fee accrual to LPs via state appreciation rather than explicit distributions.
-
-7.9 Edge cases and operational notes
-- Tiny liquidity: When $S$ is small, $b=\kappa S$ is small and price impact is steep; deployments SHOULD enforce a minimum bootstrap $S^{(0)}$ and/or minimum minted $L^{(0)}$.
-- Extreme imbalances: As some $q_j \to 0$, price ratios $\exp((q_{\text{quote}}-q_{\text{base}})/b)$ can become large; capacity caps ($y \le q_j$) and positivity checks on logarithm arguments ensure safe evaluation.
-- Asset additions/removals: Changing the asset set alters $n$ and the pricing manifold. Deployments typically fix the asset universe; adding/removing assets is best handled via new pool instances with fresh initialization.
-
-8) Fees and Incentives (Static Parameters)
-
-8.1 Fee model and placement
-- Let the swap fee rate be $f_{\text{swap}} \in [0,1)$, and let the protocol capture a fraction $\phi \in [0,1]$ of that fee (so LPs receive the remaining $1-\phi$ share via state appreciation).
-- We apply fees outside the fee-free pricing kernel. For an exact-in trade with submitted input $a$ on asset $i$, the effective kernel input is
-  $$a_{\text{eff}} \;=\; (1 - f_{\text{swap}})\,a.$$
-  The fee amount is $a - a_{\text{eff}}$, of which $\phi\,(a - a_{\text{eff}})$ accrues to the protocol and $(1-\phi)\,(a - a_{\text{eff}})$ to LPs (retained in the pool state).
-- The fee-free kernel computes the out-amount $y_{\text{ker}}$ using $a_{\text{eff}}$; the user receives $y_{\text{user}} = y_{\text{ker}}$ (or a fee-adjusted variant if fees are taken from output instead). The invariant and closed forms remain unaffected because pricing is computed on $a_{\text{eff}}$.
-
-8.2 Economic impact
-- Effective price and slippage: With input-side fees, the user’s effective marginal price scales by $(1 - f_{\text{swap}})^{-1}$ for small trades; total slippage decomposes into kernel slippage (from the LMSR curve) plus a constant offset due to fees.
-- LP returns: Fees retained in the pool increase $S(\mathbf{q})$ relative to outstanding $L$ and thus raise LP share value. Protocol revenue scales with $\phi$ and trade flow; LP revenue scales with $(1-\phi)$.
-
-8.3 Static-parameter policy (immutability)
-- Parameters $\kappa$, $f_{\text{swap}}$, and $\phi$ are set at deployment and are immutable thereafter. Benefits include:
-  - Predictability: depth and fee impact are ex-ante auditable for a given $S$.
-  - Governance minimization: no discretionary levers to be toggled post-deployment.
-  - Composability: integrators can rely on stable behavior across time.
-
-9) Risk Analysis and Theoretical Properties
-
-9.1 Convexity and path independence
-- With constant $b$, $C(\mathbf{q}) = b\log\!\big(\sum_i e^{q_i/b}\big)$ is convex and cost differences are path independent:
-  $$\Delta C \;=\; C(\mathbf{q}+\Delta\mathbf{q}) - C(\mathbf{q}) \quad \text{depends only on the endpoints}.$$
-- With $b=\kappa S(\mathbf{q})$, $\partial C/\partial q_i$ includes a common additive term (Section 4); pairwise ratios
-  $$P(\text{base}\to\text{quote}\mid \mathbf{q}) \;=\; \exp\!\left(\frac{q_{\text{quote}}-q_{\text{base}}}{b(\mathbf{q})}\right)$$
-  remain valid under a quasi-static-$b$ view, which is the pricing lens used for infinitesimal (or discretized) steps.
-
-9.2 Bounded loss (intuition) and capital efficiency
-- For constant $b$, the classic LMSR worst-case loss is $b\ln n$ in the payout numéraire. Under $b=\kappa S$, this scales proportionally with $S$, giving an instantaneous per-unit-$S$ bound proportional to $\kappa \ln n$.
-- Capital efficiency follows from linear scaling: increasing $S$ (or $\kappa$) linearly deepens liquidity. The two-asset exact-in form
-  $$y(a) \;=\; b\,\ln\!\Big(1 + r_0(1 - e^{-a/b})\Big)$$
-  exhibits $y'(0)=\frac{r_0}{1+r_0}$ and curvature $\frac{\mathrm{d}^2 y}{\mathrm{d}a^2}<0$, quantifying the marginal depth and diminishing returns for larger $a$.
-
-9.3 Sensitivity to $b$ and reserve scales
-- Scale invariance: If $\mathbf{q}\mapsto \lambda \mathbf{q}$, then $S\mapsto \lambda S$, $b\mapsto \lambda b$, and $P(\text{base}\to\text{quote})$ is unchanged. Thus depth in notional terms scales linearly with $\lambda$.
-- As $b$ increases (via larger $S$ or $\kappa$), the function $y(a)$ becomes less curved (greater depth), reducing slippage for a given input size $a$.
-
-9.4 Failure modes and mitigations
-- Thin liquidity: Small $S$ implies small $b$, steep impact, and sensitivity to large orders. Mitigations: enforce minimum bootstrap $S^{(0)}$, external routing safeguards, and user-specified price limits $\Lambda$.
-- Extreme concentration: As some $q_j \to 0$, prices can become very large; capacity caps ($y\le q_j$) and limit-hitting logic prevent pathological outputs.
-- Numerical edge cases: Guard $\exp$/$\ln$ domains, ensure denominators like $r_0 + 1 - e^{y/b} > 0$, and prefer ratio-based computations (Appendix B).
-- No-arbitrage hygiene: Maintain monotonicity of $y(a)$ and its inverse $a(y)$; avoid rounding that could create free lunches (see Section 12).
-
-10) Numerical Methods and Implementation Considerations
-
-10.1 Fixed-point arithmetic and precision policy
-- Representation: Quantities are computed in fixed-point; equations are presented over reals for clarity. Let $F$ denote the fractional precision (bits or decimal places).
-- Range limits: For stability of exponentials and logarithms, enforce
-  $$|x| \le X_{\max} \quad \text{when evaluating } \exp(x),\qquad u > 0 \quad \text{when evaluating } \ln(u).$$
-  Practical choices take $X_{\max}$ large enough to cover the operating envelope while preventing overflow.
-- Rounding: Use round-toward-zero or round-to-nearest consistently, prioritizing order-preservation (see 10.6). Avoid mixed rounding modes within a single expression.
-
-10.2 Stable exp/log evaluation (log-sum-exp)
-- Cost and shares are evaluated via a log-sum-exp recentering. Define $y_i := q_i/b$, $M := \max_i y_i$, then
-  $$C(\mathbf{q}) \;=\; b\left(M + \log \sum_i e^{\,y_i - M}\right),\qquad
-    \pi_i \;=\; \frac{e^{\,y_i - M}}{\sum_k e^{\,y_k - M}}.$$
-  Centering at $M$ prevents overflow/underflow when $y_i$ are far apart.
-- Ratio formation: Compute ratios directly to avoid extra $\exp$/$\ln$ where possible, e.g.
-  $$r_0 \;=\; \exp\!\left(\frac{q_i - q_j}{b}\right)$$
-  rather than $e^{q_i/b}/e^{q_j/b}$.
-
-10.3 Reformulations for numerical stability
-- Use $\ln(1+u)$ and $e^x-1$ style identities for small arguments:
-  $$\ln(1+u) \approx u - \frac{u^2}{2} \quad (|u|\ll 1),\qquad e^{x}-1 \approx x + \frac{x^2}{2} \quad (|x|\ll 1),$$
-  switching to series forms when $|u|$ or $|x|$ are below thresholds to reduce cancellation.
-- Inverse mapping stability: For exact-out inversion
-  $$a(y) \;=\; b \,\ln\!\left(\frac{r_0}{\,r_0 + 1 - e^{\,y/b}\,}\right),$$
-  compute $E:=e^{y/b}$ once; if $E\approx 1$, use series for $E-1$ to avoid subtractive cancellation.
-- Precompute reciprocals: Cache $b^{-1}$ to replace divisions by multiplications and reduce dispersion.
-
-10.4 Algorithm selection, termination, and convergence
-- Closed forms: Prefer the exact two-asset formulas for exact-in and exact-out when applicable (Sections 6 and A.2–A.3).
-- Root-finding for proportional joins: Solve $a_{\text{req}}(\alpha)=a$ via bracketing and bisection on a monotone map:
-  $$a_{\text{req}}(\alpha) \;=\; \alpha q_i + \sum_{j\ne i} b \ln\!\left(\frac{r_{0,j}}{\,r_{0,j} + 1 - e^{\,\alpha q_j/b}\,}\right).$$
-  Terminate when the interval width is below $\varepsilon$ or the function gap is within tolerance. Monotonicity guarantees uniqueness.
-- Limit-hitting: Compute $a_{\text{lim}}=b\ln(\Lambda/r_0)$ directly; validate $\Lambda>r_0$ and that intermediate expressions stay in-range.
-
-10.5 Performance vs precision trade-offs
-- Caching: Reuse common subexpressions (e.g., $b$, $b^{-1}$, $r_{0,j}$) across loops and iterative steps.
-- Operation count: Prefer fused operations and single-pass accumulations (e.g., recentered $\sum e^{\cdot}$ with on-the-fly rescaling).
-- Approximation regions: In designated near-balanced regimes (Section 11), switch to polynomial approximations to avoid transcendental calls, respecting global error budgets.
-
-10.6 Error analysis, monotonicity, and arbitrage-safety
-- Error budgeting: Allocate a maximum relative error $\epsilon_{\text{rel}}$ to each primitive ($\exp$, $\ln$, polynomials), ensuring the composed map (e.g., $y(a)$) meets end-to-end bounds.
-- Monotonicity preservation: Ensure numerical implementations of $y(a)$ are strictly increasing and of $a(y)$ are strictly increasing by:
-  - enforcing positive denominators (e.g., $r_0 + 1 - e^{y/b} > 0$),
-  - clamping intermediate “inner” terms to $(0,\infty)$,
-  - preferring formulations without subtractive cancellation near boundaries.
-- Arbitrage hygiene: Use conservative branches (cap-and-invert) when near capacity or domain boundaries to avoid nonphysical outputs (negative or exceeding balances).
-
-11) BalancedPair Optimization (Dedicated Section)
-
-11.1 Applicability conditions
-- Define $\delta := (q_i - q_j)/b$ and $\tau := a/b$. The balanced regime is characterized by
-  $$|\delta| \le \delta_\star,\qquad |\tau| \le \tau_\star,$$
-  with design thresholds $(\delta_\star,\tau_\star)$ chosen so that polynomial approximations meet the global error budget while preserving monotonicity.
-
-11.2 Balanced 2-asset closed form and small-argument expansions
-- The exact two-asset mapping is
-  $$y(a) \;=\; b \,\ln\!\Big(1 + r_0 (1 - e^{-a/b})\Big),\qquad r_0=e^{\delta}.$$
-- For $|\delta|\ll 1$ and $|\tau|\ll 1$, use expansions
-  $$e^{\pm x} \approx 1 \pm x + \frac{x^2}{2},\qquad \ln(1+u) \approx u - \frac{u^2}{2},$$
-  yielding
-  $$y(a) \;\approx\; b \left[ r_0 \tau - \frac{1}{2} r_0 \tau^2 \right] + \mathcal{O}\!\left(\tau^3,\, |\delta|\,\tau^2\right),\quad r_0 \approx 1 + \delta + \frac{\delta^2}{2}.$$
-- Symmetry: At $\delta=0$, the mapping satisfies $y(a)\approx \tfrac{a}{2} - \tfrac{a^2}{4b} + \cdots$, reflecting equal liquidity on both sides.
-
-11.3 Polynomial approximations without $\exp/\ln$
-- Construct minimax polynomials $P_d(x)\approx e^{x}$ on $[-\tau_\star,0]$ and $Q_d(u)\approx \ln(1+u)$ on $[0,u_\star]$, where $u_\star$ is induced by the range of $r_0(1-e^{-\tau})$ in the regime.
-- Compose
-  $$\tilde{y}(a) \;=\; b \, Q_d\!\Big( r_0 \,\big(1 - P_d(-\tau)\big) \Big),\qquad \tau=\frac{a}{b},$$
-  with $r_0$ optionally approximated by a low-degree polynomial in $\delta$ when $|\delta|\le \delta_\star$.
-- Error bounds:
-  $$\big|e^{x}-P_d(x)\big| \le e^{\tau_\star}\,\frac{\tau_\star^{\,d+1}}{(d+1)!},\qquad
-    \big|\ln(1+u)-Q_d(u)\big| \le \frac{u^{\,d+1}}{(d+1)\,(1-u)^{\,d+1}},$$
-  ensuring $\big|y(a)-\tilde{y}(a)\big| \le \epsilon$ for a target $\epsilon$ via appropriate $d$, $\delta_\star$, $\tau_\star$, $u_\star$.
-
-11.4 Dispatcher logic and safe fallback
-- Preconditions:
-  - check $|\delta|\le \delta_\star$, $|a|/b \le \tau_\star$, and positivity of intermediate “inner” terms,
-  - ensure capacity is respected ($\tilde{y}(a)\le q_j$) or switch to cap-and-invert branch.
-- If any precondition fails, fall back to the general closed-form path with full transcendental evaluations.
-- Price-limit compatibility: When a price limit $\Lambda$ is set, verify that the approximated trajectory respects $r(t)\le \Lambda$; otherwise, revert to exact limit-hitting computation $a_{\text{lim}}=b\ln(\Lambda/r_0)$.
-
-11.5 Invariant preservation and monotonicity guarantees
-- Enforce $\tilde{y}'(a) > 0$ on the approximation domain by design (choose $P_d$, $Q_d$ that are monotonically increasing on their intervals and validate numerically).
-- Guard inner arguments to keep them in $(0,\infty)$, preventing nonphysical outputs or $\ln$ domain violations.
-- Capacity and nonnegativity: Clamp to $[0, q_j]$ and use inverse mapping to reconcile inputs in cap branches.
-
-11.6 Gas and performance analysis
-- Eliminating transcendental calls in the balanced regime reduces cost to a small fixed number of polynomial evaluations and multiplications.
-- Dispatcher overhead is minimal (few comparisons and a couple of scaled differences). Overall, the optimization provides substantial speedups in near-parity trades while maintaining accuracy guarantees.
-- The fallback ensures worst-case performance is bounded by the general path.
-
-12) Protocol Safety: Numerical and Invariant Guarantees
-
-12.1 Invariant checks and fail-fast conditions
-- Domain guards:
-  - Size metric: $S(\mathbf{q}) = \sum_i q_i > 0$, hence $b=\kappa S > 0$.
-  - Valid indices and nonnegative inputs/outputs for user-facing operations.
-  - Exponential and logarithm arguments within bounded, valid domains; prefer log-sum-exp recentering.
-- Capacity and limit checks:
-  - Out-amounts are capped by available balances ($y \le q_j$).
-  - Price-limit trades enforce $\Lambda > r_0$ and truncate at $a_{\text{lim}}=b\ln(\Lambda/r_0)$.
-- Consistency guards:
-  - Denominators (e.g., $r_0 + 1 - e^{y/b}$) must be positive.
-  - Reciprocal quantities (e.g., $1/b$) are computed once and reused to avoid drift.
-
-12.2 Precision-induced error handling and rounding
-- Monotonicity-first policy: Prefer formulations that preserve order (e.g., log-sum-exp, ratio formation for $r_0$).
-- Conservative rounding: When a decision boundary is approached (e.g., inner argument of $\ln$ near zero), choose the conservative branch (cap-and-invert) rather than extrapolating.
-- Bounded evaluations: Enforce $|x| \le X_{\max}$ for $\exp(x)$ to prevent overflow; clamp inputs that would violate this bound and surface clear errors to callers.
-
-12.3 Verification targets
-- Structural properties:
-  - Convexity under constant $b$; gradient softmax identities.
-  - Pairwise price ratios consistent with $P(\text{base}\to\text{quote})$ under quasi-static $b$.
-- Numerical properties:
-  - Monotonicity of $y(a)$ and $a(y)$, uniqueness of $a_{\text{lim}}$ when $\Lambda>r_0$.
-  - Path-independence of $\Delta C$ in constant-$b$ tests; bounded relative error within predefined budgets.
-
-12.4 Testing approach
-- Property-based tests across randomized states $\mathbf{q}$, input sizes, and asset pairs, including adversarial edge cases (tiny $S$, extreme $r_0$, near-capacity).
-- Boundary tests for domain guards (e.g., $S\downarrow 0$, $\Lambda \downarrow r_0$, inner argument of $\ln$ near zero).
-- Differential tests against high-precision reference implementations for $y(a)$, $a(y)$, and price ratios.
-- No-negative-arbitrage checks under rounding: ensure discrete effects cannot be exploited for profit with zero risk.
-
-13) Deployment Model and Parameter Fixity
-
-13.1 Immutable parameters and non-upgradability
-- The pool is deployed with a fixed asset set and immutable parameters $(\kappa, f_{\text{swap}}, \phi)$, where $\kappa>0$ determines $b(\mathbf{q})=\kappa S(\mathbf{q})$, $f_{\text{swap}}$ is the swap fee rate, and $\phi$ is the protocol share of fees.
-- Contracts are deployed in a non-upgradable, ownerless configuration. No governance can modify $\kappa$, fees, or the asset universe after deployment.
-
-13.2 Deployment inputs and initialization
-- Deployment specifies: the asset list, normalization conventions, and parameter tuple $(\kappa, f_{\text{swap}}, \phi)$. Initialization requires a seed inventory $\mathbf{q}^{(0)}$ with $S^{(0)}=\sum_i q_i^{(0)}>0$, yielding initial liquidity
-  $$b^{(0)} \;=\; \kappa \, S^{(0)}.$$
-- A minimum bootstrap size $S^{(0)}$ SHOULD be enforced to avoid thin-liquidity regimes at genesis.
-
-13.3 Reproducibility and transparency
-- Given $(\kappa, f_{\text{swap}}, \phi)$ and the initial state $\mathbf{q}^{(0)}$, the AMM’s pricing map is fully determined for all subsequent states via
-  $$C(\mathbf{q}) \;=\; b(\mathbf{q}) \,\log\!\left(\sum_i e^{q_i / b(\mathbf{q})}\right),\qquad b(\mathbf{q})=\kappa\,S(\mathbf{q}).$$
-- Observability: Public views expose instantaneous price ratios $P(\text{base}\to\text{quote})$, price shares $\pi_i$, LP price $P_L^{(k)}$, and size metric $S(\mathbf{q})$.
-
-13.4 Operational implications
-- Asset changes: To add or remove assets, deploy a new pool instance and migrate liquidity; existing pools remain immutable.
-- Ecosystem integration: The fixed-parameter model simplifies routing and valuation, enabling integrators to precompute depth profiles for anticipated $S$ regimes.
-- Risk discipline: The absence of admin levers eliminates governance risk but requires careful parameter selection at deployment.
-
-15) Limitations and Future Work
-
-15.1 Limitations
-- Quasi-static $b$ assumption: Pricing steps treat $b$ as locally constant. While pairwise ratios are exact for infinitesimal moves, finite trades are evaluated with closed forms derived from the two-asset reduction; model fidelity remains high but is not a full global-gradient integration under state-dependent $b$.
-- Thin-liquidity vulnerability: For small $S$, $b=\kappa S$ is small and price impact is steep; users should rely on price limits $\Lambda$ and integrators should enforce minimum bootstrap sizes.
-- Extreme concentration and domain edges: As some $q_j \to 0$, ratios $\exp((q_{\text{quote}}-q_{\text{base}})/b)$ become large; capacity caps and domain guards prevent nonphysical outcomes but can truncate trades.
-- Expressivity: The mechanism is not tuned for pegged pairs like stableswap, nor does it encode cross-asset correlations by default.
-- Numerical constraints: Fixed-point range/precision, exponential/log bounds, and approximation regimes impose domain restrictions for safe operation.
-- Static parameters: Immutability removes governance agility; mis-specified $\kappa$ or fees require new deployments.
-
-15.2 Future work
-- Adaptive proportionality: Explore principled adaptive $\kappa$ while preserving LMSR properties (e.g., bounded-loss analogues) and avoiding governance risk (e.g., rule-based or oracle-free triggers).
-- Correlated or basket-targeted variants: Incorporate weighted size metrics $S_w(\mathbf{q})$ or correlation-aware formulations, with rigorous analysis of price and risk implications.
-- Enhanced approximations: Extend polynomial or rational approximations with verified remainder bounds, larger safe domains, and automatic dispatchers with certified monotonicity.
-- Off-chain assists and proofs: Use off-chain computation for heavy numerical routines with on-chain verification (e.g., succinct proofs) while maintaining transparency.
-- MEV-aware design: Integrate user-settled price limits, batch auctions, or commit-reveal to mitigate adverse selection and sandwich risk.
-- Layer-2 deployment: Leverage lower fees and faster settlement to widen the safe domain for numerical precision and to support more assets.
-
-16) Conclusion
-
-- We presented a multi-asset AMM whose pricing kernel is the LMSR cost function with an effective liquidity parameter proportional to pool size, $b(\mathbf{q})=\kappa S(\mathbf{q})$. This delivers scale-invariant responsiveness, preserves softmax-derived pairwise price ratios, and supports any-to-any swaps via a single convex potential.
-- Closed-form two-asset reductions provide exact-in, exact-out, and limit-hitting formulas with strong monotonicity and uniqueness properties, while capacity caps and conservative inverses ensure safety at domain boundaries. Liquidity operations (proportional and single-asset joins/exits) follow directly from the same potential framework.
-- A fixed-parameter policy eliminates governance risk and makes depth calibration transparent. Numerical stability is achieved through log-sum-exp reformulations, guarded transcendental domains, and optional balanced-regime polynomial approximations with error bounds.
-- Outlook: This LMSR AMM complements CFMMs by offering multi-asset price discovery under a convex potential with predictable scaling. Future work includes adaptive yet governance-minimized responsiveness, correlation-aware variants, and verifiable off-chain assists—aimed at retaining theoretical guarantees while broadening applicability.
-
-
-
-
-
-
-
-
-
-17) Appendices
-
-A. Full derivations and proofs
-
-A.1 Gradient, price shares, and pairwise prices
-- With $b$ treated as a constant parameter, the LMSR cost $C(\mathbf{q}) = b \log\!\big(\sum_k e^{q_k/b}\big)$ yields
-  $$\frac{\partial C}{\partial q_i} \;=\; \frac{e^{q_i/b}}{\sum_k e^{q_k/b}} \;=\; \pi_i(\mathbf{q}).$$
-- With $b = \kappa \, S(\mathbf{q})$, the total derivative becomes
-  $$\frac{\partial C}{\partial q_i} \;=\; A(\mathbf{q}) \;+\; \frac{e^{q_i/b}}{\sum_k e^{q_k/b}},$$
-  where $A(\mathbf{q})$ is an additive term common to all $i$ that arises from $\partial b/\partial q_i$. Consequently, differences between marginal prices are preserved, and the pairwise marginal price ratio reduces to
-  $$P(\text{base}\to\text{quote}\mid \mathbf{q}) \;=\; \exp\!\left(\frac{q_{\text{quote}} - q_{\text{base}}}{b(\mathbf{q})}\right).$$
-  This is the exchange rate used by the kernel, under the quasi-static-$b$ assumption.
-
-A.2 Two-asset closed form: exact-in
-- Consider a swap from $i$ (in) to $j$ (out) with quasi-static $b$. Let $r_0 := \exp\!\big((q_i - q_j)/b\big)$. Along the trade path, the instantaneous marginal price ratio evolves as $r(t) = r_0 \, e^{t/b}$, where $t$ is the cumulative input of asset $i$.
-- The infinitesimal output satisfies
-  $$\mathrm{d}y \;=\; \frac{r(t)}{1 + r(t)} \,\mathrm{d}t,$$
-  in the two-asset reduction induced by the LMSR gradient. Integrating from $0$ to $a$ yields the closed form
-  $$y(a) \;=\; b \,\ln\!\Big( 1 + r_0 \,\big(1 - e^{-a/b}\big) \Big).$$
-- Properties: $y(0) = 0$, $y'(0) = \frac{r_0}{1 + r_0}$, $y$ is increasing and concave in $a$, and $\lim_{a\to\infty} y = b \,\ln(1 + r_0)$.
-
-A.3 Two-asset closed form: exact-out (inverse)
-- Given $y \ge 0$, invert the relation in A.2. Let $E := e^{y/b}$. Then
-  $$1 + r_0 \,\big(1 - e^{-a/b}\big) \;=\; E
-  \;\Rightarrow\; e^{-a/b} \;=\; 1 - \frac{E - 1}{r_0} \;=\; \frac{r_0 + 1 - E}{r_0}$$
-  $$\Rightarrow\quad a(y) \;=\; -\,b \,\ln\!\left(\frac{r_0 + 1 - E}{r_0}\right) \;=\; b \,\ln\!\left(\frac{r_0}{\,r_0 + 1 - E\,}\right).$$
-- This inverse exists and is unique for $y \in \big[0,\, b \ln(1 + r_0)\big]$.
-
-A.4 Limit-hitting and swap-to-limit
-- Let $\Lambda > 0$ be a maximum acceptable marginal price ratio for $p_i/p_j$. With $r(t) = r_0 \, e^{t/b}$, the limit is reached when $r(t) = \Lambda$, giving the unique truncated input
-  $$a_{\text{lim}} \;=\; b \,\ln\!\left(\frac{\Lambda}{r_0}\right).$$
-- The corresponding output at the limit is
-  $$y_{\text{lim}} \;=\; b \,\ln\!\Big( 1 + r_0 \,\big(1 - e^{-a_{\text{lim}}/b}\big) \Big)
-  \;=\; b \,\ln\!\Big( 1 + r_0 \,\big(1 - r_0/\Lambda\big) \Big).$$
-- If $y_{\text{lim}}$ exceeds the available out-asset balance $q_j$, cap output to $q_j$ and solve for the input required to realize $y = q_j$ using the inverse formula of A.3:
-  $$a_{\text{cap}} \;=\; b \,\ln\!\left(\frac{r_0}{\,r_0 + 1 - e^{\,q_j / b}\,}\right).$$
-
-A.5 Single-asset mint via proportional growth (exact-in to many)
-- Suppose a user contributes amount $a$ of asset $i$ and wishes to increase the pool proportionally by factor $1 + \alpha$ (with $\alpha \ge 0$). For each $j \ne i$, let $y_j := \alpha \, q_j$ be the target out-amount in $j$ when swapping from $i$. Define $r_{0,j} := \exp\!\big((q_i - q_j)/b\big)$. From A.3, the input required to realize $y_j$ is
-  $$x_j(\alpha) \;=\; b \,\ln\!\left(\frac{r_{0,j}}{\,r_{0,j} + 1 - e^{\,y_j / b}\,}\right).$$
-- The self-asset contribution is $\alpha \, q_i$. The total input required is
-  $$a_{\text{req}}(\alpha) \;=\; \alpha \, q_i \;+\; \sum_{j \ne i} x_j(\alpha).$$
-- Solve for $\alpha$ via a monotone root-find on $a_{\text{req}}(\alpha) = a$. The function is increasing in $\alpha$ on its domain, with unique solution when feasible.
-
-A.6 Single-asset burn via proportional redemption
-- Burning a proportional share $\alpha \in (0, 1]$ reduces the pool balances to $(1 - \alpha)\,\mathbf{q}$. A single-asset payout in asset $i$ aggregates (i) the direct $\alpha \, q_i$ redemption and (ii) the swaps from each asset $j \ne i$ of their redeemed $\alpha \, q_j$ portions into $i$ using A.2 with the local (post-burn) state. If a computed out-amount would exceed the local $q_i$, cap to capacity and solve the inverse for the input used.
-
-A.7 Balanced 2-asset special case and polynomial approximations
-- Near balance, define $\delta := (q_i - q_j)/b$ with $|\delta| \ll 1$ and let $a/b$ be small. Using second-order expansions:
-  $$e^{\pm x} \approx 1 \pm x + \frac{x^2}{2},\qquad \ln(1 + u) \approx u - \frac{u^2}{2},$$
-  we obtain for small $a/b$ and $\delta$:
-  $$r_0 = e^{\delta} \approx 1 + \delta + \frac{\delta^2}{2},$$
-  $$y(a) = b \,\ln\!\big(1 + r_0(1 - e^{-a/b})\big)
-       \approx b \left[ r_0 \left(\frac{a}{b}\right) - \frac{1}{2} r_0 \left(\frac{a}{b}\right)^2 \right]
-       + \mathcal{O}\!\left(\left(\frac{a}{b}\right)^3,\, \delta \left(\frac{a}{b}\right)^2\right).$$
-- In particular, when $\delta \approx 0$,
-  $$y(a) \approx \frac{a}{2} - \frac{a^2}{4b} + \cdots,$$
-  which admits efficient evaluation via fixed low-degree polynomials. This motivates a “balanced pair” dispatcher that, under explicit near-balance preconditions ($|\delta| \le \delta_\star$ and $a/b \le \tau_\star$), uses minimax Chebyshev polynomials for $\exp$ and $\ln$ on compact intervals to meet a specified error budget, and otherwise falls back to the general path.
-
-B. Error bounds and approximation details
-
-B.1 Fixed-point arithmetic and stability policy
-- Representation: All quantities are computed in fixed-point with a wide fractional field; equations are written over reals for exposition. Overflow/underflow and domain errors are prevented with explicit guards.
-- Log-sum-exp: The cost is evaluated as $C = b \left(M + \log \sum_i e^{\,y_i - M}\right)$ with $y_i := q_i/b$ and $M := \max_i y_i$. This ensures stable accumulation even when some $y_i$ are far apart.
-- Exponential guard: The arguments to $\exp(\cdot)$ are restricted to a bounded interval to ensure finite, monotone outputs. A practical bound is $|x| \le 32$ (in internal fixed-point units), which comfortably covers operational regimes while preventing overflow.
-- Ratio shortcuts: Where possible, we form ratios such as $r_0 = \exp\!\big((q_i - q_j)/b\big)$ directly, avoiding separate exponentials and a division, improving both precision and cost.
-
-B.2 Monotonicity and error budgets
-- Kernel monotonicity: The closed forms in A.2–A.4 are strictly increasing in input and satisfy $y'(a) \in (0,1)$ for feasible states. Numerical implementations preserve monotonicity by:
-  - using log-sum-exp,
-  - guarding denominators (e.g., $r_0 + 1 - e^{\,y/b} > 0$),
-  - clamping to capacity when necessary and solving inverses in the capped branch.
-- Error targets: Prices, shares, and swap amounts are computed to within small relative error (e.g., $\le 10^{-9}$ for typical ranges). Guards reject or cap inputs that would violate error or domain constraints.
-
-B.3 Polynomial approximations in balanced 2-asset mode
-- Domains: For $|\delta| \le \delta_\star$ and $\big|a/b\big| \le \tau_\star$, $\exp$ and $\ln$ are approximated by minimax polynomials on compact intervals $[-\tau_\star, \tau_\star]$ and $[\,1 - u_\star,\, 1 + u_\star\,]$, respectively, with $u_\star$ induced by the $\exp$ range.
-- Construction: Coefficients are obtained offline (e.g., via Remez) to minimize the maximum relative error over the domain.
-- Remainder bounds: Standard analytic bounds apply:
-  $$\big|e^{x} - P_d(x)\big| \;\le\; e^{\tau_\star}\,\frac{\tau_\star^{\,d+1}}{(d+1)!},$$
-  $$\big|\ln(1 + u) - Q_d(u)\big| \;\le\; \frac{|u|^{\,d+1}}{(d+1)\,(1 - |u|)^{\,d+1}},\qquad |u| < 1.$$
-  Degree $d$ and domain parameters $(\delta_\star, \tau_\star, u_\star)$ are chosen to meet the global error budget while maintaining monotonicity of the composed swap mapping.
-
-B.4 Implementation notes for stability
-- Prefer single-pass accumulations with on-the-fly recentering for $\sum \exp(\cdot)$.
-- Maintain consistent reciprocals (e.g., precompute $1/b$) to reduce rounding dispersion.
-- Use explicit positivity checks (e.g., size metric $S > 0$, $\exp$ arguments within bounds, denominators $> 0$).
-- When a computed “inner” argument to $\ln(\cdot)$ is $\le 0$ due to rounding, switch to a conservative branch (cap-and-invert) rather than continuing.
-
-C. Additional figures and tables (to be included)
-- Price impact curves vs. constant-product and constant-mean baselines across $\kappa$.
-- Parameter sweeps for $\kappa$ and $S$ showing depth and slippage profiles.
-- Numerical accuracy: worst-case relative error heatmaps for prices and swap amounts; monotonicity checks.
-- Gas microbenchmarks: general path vs. balanced 2-asset approximations; cache effects.
-
-D. Glossary and notation
-- $n$: number of assets.
-- $i, j$: asset indices in $\{0,\dots,n-1\}$.
-- $\mathbf{q}\in \mathbb{R}_{\ge 0}^{\,n}$: vector of normalized internal quantities; $q_i$ is the $i$-th component.
-- $S(\mathbf{q}) = \sum_i q_i$: size metric (aggregate pool size).
-- $\kappa > 0$: fixed liquidity proportionality constant.
-- $b(\mathbf{q}) = \kappa \cdot S(\mathbf{q})$: effective LMSR liquidity parameter.
-- $w_i = e^{q_i / b}$; $W = \sum_i w_i$.
-- $\pi_i = w_i / W$: price share (softmax probability).
-- $P(\text{base}\to\text{quote}) = \exp\!\big((q_{\text{quote}} - q_{\text{base}})/b\big)$: pairwise marginal price ratio.
-- $a$: exact-in input amount for asset $i$ (fee-free kernel).
-- $y$: exact-out output amount for asset $j$ (fee-free kernel).
-- $r_0 = \exp\!\big((q_i - q_j)/b\big)$: initial ratio for an $i\to j$ swap.
-- $\Lambda$: user-specified price limit (maximum acceptable $p_i/p_j$).
-- $\alpha$: proportional growth/redeem factor for liquidity operations.
-
-E. References
-- Hanson, R. (2002). [Logarithmic Market Scoring Rules for Modular Combinatorial Information Aggregation.](https://mason.gmu.edu/~rhanson/mktscore.pdf)
-- Abernethy, J., Chen, Y., & Waggoner, B. (2013). Low-Regret Learning in Prediction Markets.
-- Uniswap (Hayden Adams et al.). Constant product market maker design docs and whitepapers.
-- Balancer. Constant mean market makers and multi-asset pool design notes.
-- Curve Finance. StableSwap invariant design notes.
-- Fixed-point arithmetic references and standard libraries for 64.64 computations.
+## Abstract
+We present a multi-asset automated market maker whose pricing kernel is the Logarithmic Market Scoring Rule (LMSR) ([R. Hanson, 2002](https://mason.gmu.edu/~rhanson/mktscore.pdf)). The pool maintains the convex potential $C(\mathbf{q}) = b(\mathbf{q}) \log\!\Big(\sum_i e^{q_i / b(\mathbf{q})}\Big)$ over normalized inventories $\mathbf{q}$, and sets the effective liquidity parameter proportional to pool size as $b(\mathbf{q}) = \kappa \, S(\mathbf{q})$ with $S(\mathbf{q}) = \sum_i q_i$ and fixed $\kappa>0$. This proportional parameterization preserves scale-invariant responsiveness while retaining softmax-derived pairwise price ratios under a quasi-static-$b$ view, enabling any-to-any swaps within a single potential. We derive and use closed-form expressions for two-asset reductions to compute exact-in, exact-out, limit-hitting (swap-to-limit), and capped-output trades. We discuss stability techniques such as log-sum-exp, ratio-once shortcuts, and domain guards for fixed-point arithmetic. Liquidity operations (proportional and single-asset joins/exits) follow directly from the same potential and admit monotone, invertible mappings. Parameters are immutable post-deployment for transparency and predictable depth calibration.
+
+## Introduction and Motivation
+Multi-asset liquidity typically trades off simplicity and expressivity. Classical CFMMs define multiplicative invariants over reserves, while LMSR specifies a convex cost function whose gradient yields prices. Our goal is a multi-asset AMM that uses LMSR to support any-to-any swaps, shares risk across many assets, and scales depth predictably with pool size. By setting $b(\mathbf{q})=\kappa S(\mathbf{q})$, we achieve scale invariance: proportional rescaling of all balances scales $b$ proportionally and preserves pairwise price ratios, so the market’s responsiveness is consistent across liquidity regimes. The derivations below formulate instantaneous prices, closed-form swap mappings, limit logic, and liquidity operations tailored to this parameterization.
+
+## System Model and Pricing Kernel
+We consider $n\ge 2$ normalized assets with state vector $\mathbf{q}=(q_0,\dots,q_{n-1})\in\mathbb{R}_{\ge 0}^{\,n}$ and size metric $S(\mathbf{q})=\sum_i q_i$. The kernel is the LMSR cost function
+
+$$
+C(\mathbf{q}) = b(\mathbf{q}) \log\!\left(\sum_{i=0}^{n-1} e^{q_i / b(\mathbf{q})}\right), \qquad b(\mathbf{q})=\kappa\,S(\mathbf{q}),\quad \kappa>0.
+$$
+
+For numerical stability we evaluate $C$ with a log-sum-exp recentering. Let $y_i := q_i/b(\mathbf{q})$ and $M:=\max_i y_i$. Then
+
+$$
+C(\mathbf{q}) \;=\; b(\mathbf{q}) \left( M + \log \sum_{i=0}^{n-1} e^{\,y_i - M} \right),
+$$
+
+which prevents overflow/underflow when the $y_i$ are dispersed. Quantities are represented in fixed-point with explicit range and domain guards; equations are presented over the reals for clarity.
+
+## Gradient, Price Shares, and Pairwise Prices
+With $b$ treated as a constant parameter, the LMSR gradient recovers softmax shares
+
+$$
+\frac{\partial C}{\partial q_i} \;=\; \frac{e^{q_i/b}}{\sum_k e^{q_k/b}} \;=:\; \pi_i(\mathbf{q}),
+$$
+
+so that the ratio of marginal prices is $\pi_j/\pi_i = \exp\!\big((q_j-q_i)/b\big)$. When $b(\mathbf{q})=\kappa S(\mathbf{q})$ depends on state, $\frac{\partial C}{\partial q_i}$ acquires a common additive term across $i$ from $\partial b/\partial q_i$, but pairwise ratios remain governed by softmax differences. We therefore use a quasi-static-$b$ view for pricing steps, holding $b$ fixed at the pre-trade state for the infinitesimal move, and define the instantaneous pairwise marginal price ratio for exchanging $i$ into $j$ as
+
+$$
+P(i\to j \mid \mathbf{q}) \;=\; \exp\!\left(\frac{q_j - q_i}{b(\mathbf{q})}\right).
+$$
+
+This ratio drives swap computations and is invariant to proportional rescaling $\mathbf{q}\mapsto \lambda\mathbf{q}$ because $b$ scales by the same factor.
+
+## Two-Asset Reduction and Exact Swap Mappings
+Swaps are computed in the two-asset subspace spanned by the in-asset $i$ and out-asset $j$, with all other coordinates held fixed under a quasi-static-$b$ step. Let
+
+$$
+r_0 \;:=\; \exp\!\left(\frac{q_i - q_j}{b}\right), \qquad b \equiv b(\mathbf{q})\;\text{ held quasi-static}.
+$$
+
+Along the $i\!\to\! j$ path, the instantaneous ratio evolves multiplicatively as $r(t)=r_0\,e^{t/b}$ where $t$ denotes cumulative input of asset $i$. In the two-asset reduction the infinitesimal output satisfies
+
+$$
+\mathrm{d}y \;=\; \frac{r(t)}{1+r(t)}\,\mathrm{d}t.
+$$
+
+Integrating from $t=0$ to $t=a$ yields the exact-in closed form
+
+$$
+y(a) \;=\; b \,\ln\!\Big( 1 + r_0 \,\big(1 - e^{-a/b}\big) \Big).
+$$
+
+This mapping has $y(0)=0$, is strictly increasing and concave in $a$, and satisfies $y'(0)=\frac{r_0}{1+r_0}$ with asymptote $\lim_{a\to\infty} y = b\,\ln(1+r_0)$. The inverse exact-out mapping follows by solving for $a$ in terms of target $y$. Writing $E:=e^{y/b}$, we obtain
+
+$$
+a(y) \;=\; b \,\ln\!\left(\frac{r_0}{\,r_0 + 1 - E\,}\right),
+$$
+
+which is strictly increasing and convex for $y\in\big[0,\, b\ln(1+r_0)\big]$. These two expressions are the workhorses for exact-in and exact-out swaps in our kernel.
+
+## Price Limits, Swap-to-Limit, and Capacity Caps
+Users may provide a maximum acceptable marginal price ratio $\Lambda>0$ for $p_i/p_j$. The marginal ratio trajectory $r(t)=r_0 e^{t/b}$ first reaches the limit at the unique
+
+$$
+a_{\text{lim}} \;=\; b \,\ln\!\left(\frac{\Lambda}{r_0}\right),
+$$
+
+and the output realized at that truncation is
+
+$$
+y_{\text{lim}} \;=\; b \,\ln\!\Big( 1 + r_0 \,\big(1 - r_0/\Lambda\big) \Big).
+$$
+
+Outputs are further bounded by available inventory; if a computed $y$ would exceed $q_j$, we cap at $y=q_j$ and compute the implied input by inverting the exact-out formula,
+
+$$
+a_{\text{cap}} \;=\; b \,\ln\!\left(\frac{r_0}{\,r_0 + 1 - e^{\,q_j/b}\,}\right).
+$$
+
+These limit and capacity branches ensure monotone, conservative behavior near domain edges.
+
+## Liquidity Operations from the Same Potential
+Liquidity is accounted via pool shares $L$ taken proportional to the size metric, and we set $L=S(\mathbf{q})$ without loss of generality. At initialization with seed balances $\mathbf{q}^{(0)}$ the pool sets $L^{(0)}=S^{(0)}$ and $b^{(0)}=\kappa S^{(0)}$. A proportional deposit that scales balances to $\mathbf{q}'=(1+\alpha)\mathbf{q}$ mints $\Delta L = \alpha S(\mathbf{q})$ shares and scales liquidity to $b'=(1+\alpha)b$. Single-asset deposits target a proportional growth while rebalancing through kernel swaps: providing amount $a$ of asset $i$ induces a growth factor $\alpha\ge 0$ satisfying the monotone equation
+
+$$
+a \;=\; a_{\text{req}}(\alpha) \;=\; \alpha q_i \;+\; \sum_{j\ne i} b \,\ln\!\left(\frac{r_{0,j}}{\,r_{0,j} + 1 - e^{\,\alpha q_j/b}\,}\right), \quad r_{0,j}:=\exp\!\left(\frac{q_i-q_j}{b}\right),
+$$
+
+and mints $\Delta L=\alpha S(\mathbf{q})$ upon the unique solution. Proportional withdrawals burn $\Delta L$ and return $\alpha=\Delta L/S(\mathbf{q})$ of each asset, updating $b$ to $(1-\alpha)b$. Single-asset withdrawals redeem $\alpha q_i$ directly and swap each redeemed $\alpha q_j$ for $j\ne i$ into $i$ using the exact-in mapping evaluated on the local post-burn state; any capacity overrun is handled by a cap-and-invert branch as above. Because all operations reduce to the same two-asset closed forms, they inherit monotonicity and uniqueness.
+
+### Single-Asset Mint and Redeem
+
+#### Single-Asset Mint
+Given a deposit of amount $a>0$ of asset $i$, the pool targets a proportional growth factor $\alpha \ge 0$ so that the post-mint state can be rebalanced to $(1+\alpha)\,\mathbf{q}$ using fee-free kernel swaps from $i$ into each $j\ne i$. For each $j\ne i$, let $y_j := \alpha\,q_j$ and define $r_{0,j} := \exp\!\big((q_i - q_j)/b\big)$. The input required to realize $y_j$ via the exact-out inverse is
+
+$$
+x_j(\alpha) \;=\; b \,\ln\!\left(\frac{r_{0,j}}{\,r_{0,j} + 1 - e^{\,y_j/b}\,}\right),
+$$
+
+so the total required input for growth $\alpha$ is
+
+$$
+a_{\text{req}}(\alpha) \;=\; \alpha\,q_i \;+\; \sum_{j\ne i} x_j(\alpha).
+$$
+
+Properties and solver:
+- Monotonicity: $a_{\text{req}}(\alpha)$ is strictly increasing on its feasible domain, guaranteeing a unique solution.
+- Solver: bracket $\alpha$ (e.g., start from $\alpha\sim a/S$ and double until $a_{\text{req}}(\alpha)\ge a$ or a safety cap), then bisection to a small tolerance $\varepsilon$ (e.g., $\sim10^{-6}$ in fixed-point units).
+- Guards: enforce $b>0$, $e^{y_j/b}$ within range, and positivity of the denominator $r_{0,j}+1-e^{y_j/b}$; if a guard would be violated for some $j$, treat that path as infeasible and adjust the bracket.
+- Outcome: the consumed input is $a_{\text{in}} = a_{\text{req}}(\alpha^\star) \le a$ and minted LP shares are $\Delta L = \alpha^\star S(\mathbf{q})$.
+
+#### Single-Asset Redeem
+Burning a proportional share $\alpha \in (0,1]$ returns a single asset $i$ by redeeming and rebalancing from other assets into $i$:
+1) Form the local state after burn, $\mathbf{q}_{\text{local}}=(1-\alpha)\,\mathbf{q}$.
+2) Start with the direct redemption $\alpha\,q_i$ in asset $i$.
+3) For each $j\ne i$, withdraw $a_j := \alpha\,q_j$ and swap $j\to i$ using the exact-in form evaluated at $\mathbf{q}_{\text{local}}$:
+
+$$
+r_{0,j} \;=\; \exp\!\left(\frac{q^{\text{local}}_j - q^{\text{local}}_i}{b}\right),\qquad
+y_{j\to i} \;=\; b \,\ln\!\Big(1 + r_{0,j}\,\big(1 - e^{-a_j/b}\big)\Big).
+$$
+
+4) Capacity cap and inverse: if $y_{j\to i} > q^{\text{local}}_i$, cap to $y=q^{\text{local}}_i$ and solve the implied input via
+
+$$
+a_{j,\text{used}} \;=\; b \,\ln\!\left(\frac{r_{0,j}}{\,r_{0,j} + 1 - e^{\,q^{\text{local}}_i/b}\,}\right),
+$$
+
+then update $\mathbf{q}_{\text{local}}$ accordingly.
+5) The single-asset payout is
+
+$$
+Y_i \;=\; \alpha\,q_i \;+\; \sum_{j\ne i} y_{j\to i}, \qquad \text{with LP burned } L_{\text{in}} = \alpha \, S(\mathbf{q}).
+$$
+
+Guards and behavior:
+- Enforce $b>0$, positivity of inner terms (e.g., $r_{0,j} + 1 - e^{y/b} > 0$), and safe exponent ranges; treat any per-asset numerical failure as zero contribution rather than aborting the whole redeem.
+- The mapping is monotone in $\alpha$; the cap-and-invert branch preserves safety near capacity.
+
+### LP Pricing vs. an Asset Token
+With LP supply set to $L=S(\mathbf{q})$, the instantaneous price of one LP share in units of asset $k$ aggregates marginal exchange rates from each asset into $k$:
+
+$$
+P_L^{(k)}(\mathbf{q}) \;=\; \frac{1}{S(\mathbf{q})}\,\sum_{j=0}^{n-1} q_j \,\exp\!\left(\frac{q_j - q_k}{b(\mathbf{q})}\right).
+$$
+
+Interpretation: proportional deposits leave $P_L^{(k)}$ unchanged; swap fees retained in the pool increase $S$ relative to outstanding $L$, raising $P_L^{(k)}$ (implicit fee accrual). This expression helps LPs and integrators reason about share valuation and dilution across assets.
+
+## Numerical Methods and Safety Guarantees
+We evaluate log-sum-exp with recentring, compute ratios like $r_0=\exp((q_i-q_j)/b)$ directly rather than dividing exponentials, and guard all $\exp$ and $\ln$ calls to bounded domains with explicit checks on positivity of inner terms such as $r_0+1-e^{y/b}$. Fixed-point implementations precompute reciprocals like $1/b$ to reduce dispersion, clamp to capacity before inversion, and select cap-and-invert rather than extrapolating when inner terms approach zero. These measures ensure the swap maps remain strictly order-preserving and free of nonphysical outputs. Property-based and differential testing can confirm monotonicity of $y(a)$ and $a(y)$, uniqueness of limit hits when $\Lambda>r_0$, and adherence to predefined error budgets.
+
+## Balanced Regime Optimization: Approximations, Dispatcher, and Stability
+Since transcendental operations are gas-expensive on EVM chains, we use polynomial approximations in near-balanced regimes (e.g., stable-asset pairs) while preserving monotonicity and domain safety. Parameterize $\delta := (q_i - q_j)/b$ and $\tau := a/b$ for an $i\!\to\! j$ exact-in step. The exact mapping
+
+$$
+y(a) \;=\; b \,\ln\!\Big(1 + e^{\delta}\,\big(1 - e^{-\tau}\big)\Big)
+$$
+
+admits small-argument expansions for $|\delta|\ll 1$ and $|\tau|\ll 1$. Using $e^{\pm x}\approx 1\pm x+\tfrac{x^2}{2}$ and $\ln(1+u)\approx u - \tfrac{u^2}{2}$, we obtain
+
+$$
+y(a) \;\approx\; b \left[ r_0 \tau - \tfrac{1}{2} r_0 \tau^2 \right] + \mathcal{O}\!\left(\tau^3,\, |\delta|\,\tau^2\right), \qquad r_0=e^{\delta}\approx 1+\delta+\tfrac{\delta^2}{2},
+$$
+
+and at $\delta=0$ the symmetry reduces to $y(a)\approx \tfrac{a}{2} - \tfrac{a^2}{4b} + \cdots$.
+
+### Dispatcher preconditions and thresholds (approx path):
+- Scope: two-asset pools only; otherwise use the exact path.
+- Magnitude bounds: $|\delta| \le 0.01$ and $\tau := a/b$ satisfies $0 < \tau \le 0.5$.
+- Tiering: use the quadratic surrogate for $\tau \le 0.1$, and include a cubic correction for $0.1 < \tau \le 0.5$.
+- Limit-price gate: approximate the limit truncation only when a positive limit is provided with $\Lambda>r_0$ and $|(\Lambda/r_0)-1| \le 0.1$; otherwise compute the limit exactly (or reject if $\Lambda \le r_0$).
+- Capacity and positivity: require $b>0$ and $a>0$, and ensure the approximated output $\tilde{y}(a) \le q_j$; otherwise fall back to the exact cap-and-invert.
+- Example thresholds: $\delta_\star=0.01$, $\tau_{\text{tier1}}=0.1$, $\tau_\star=0.5$, and an auxiliary limit-ratio gate $|x| \le 0.1$ where $x=(\Lambda/r_0)-1$ (for reference, $e^{\delta_\star}\approx 1.01005$).
+
+### Approximation Path
+- Replace $\exp$ on the bounded $\tau$ domain and $\ln(1+\cdot)$ with verified polynomials to meet a global error budget while maintaining $\tilde{y}'(a)>0$ on the domain.
+- Cache common subexpressions (e.g., $r_0=e^\delta$, $\tau=a/b$) and guard inner terms to remain in $(0,\infty)$.
+
+### Fallback Policy
+- If any precondition fails (magnitude, domain, capacity, or limit binding), evaluate the exact closed forms for $y(a)$ or $a(y)$ (with cap and limit branches), preserving monotonicity and uniqueness.
+- Prefer cap-and-invert near capacity or when the inner term of $\ln(\cdot)$ approaches zero.
+
+### Error Shape
+- The small-argument expansion above shows the leading behavior; when using polynomial surrogates, the composed relative error can be kept within a target $\epsilon$ with degrees chosen for the specified $(\delta_\star,\tau_\star,u_\star)$, yielding an error budget of the form $\epsilon \approx \epsilon_{\exp} + \epsilon_{\ln} + c_1 \tau_\star + c_2 |\delta_\star| \tau_\star$ for modest constants $c_1,c_2$.
+- These bounds ensure the approximated path remains order-preserving and safely within domain; outside the domain, the dispatcher reverts to the exact path.
+- Regardless of path, our policy prioritizes monotonicity, domain safety, and conservative decisions at boundaries.
+
+## Fees and Economic Considerations
+Fees are applied outside the fee-free LMSR kernel and are retained in the pool so that fee accrual increases the size metric $S(\mathbf{q})$ (and thereby raises LP share value under $L\propto S$). We extend the single global swap-fee to a per-token fee vector $f = (f_0, f_1, \dots, f_{n-1})$, where $f_i$ denotes the canonical fee rate associated with token $i$ (expressed as a fractional rate, e.g., ppm or bps). For a trade that takes token $i$ as input and token $j$ as output, the pool computes an effective pair fee and applies it to the user-submitted input before invoking the fee-free kernel.
+
+Effective pair fee composition
+- The effective fee for an asset-to-asset swap is an exact multiplicative composition:
+  $$
+  f_{\mathrm{eff}} \;=\; 1 - (1 - f_i)\,(1 - f_j),
+  $$
+
+Asset-to-asset policy
+- Charge on input: compute the kernel input as
+  $$
+  a_{\mathrm{eff}} \;=\; a_{\mathrm{user}}\,(1 - f_{\mathrm{eff}})
+  $$
+  and pass $a_{\mathrm{eff}}$ to the fee-free LMSR kernel; collect the retained fee in the input token. Charging on input keeps gas logic simple and makes effective price shifts monotone and predictable for takers.
+- Protocol fees are taken as a fraction of LP fee earnings, and immediately moved to a separate account that does not participate in liquidity operations.
+- Limit semantics: all limitPrice and cap computations refer to the fee-free kernel path (i.e., are evaluated against the kernel output computed from $a_{\mathrm{eff}}$). Aggregators should compute $f_{\mathrm{eff}}$ externally and present accurate expected outputs to users.
+
+SwapMint and BurnSwap: single-asset fee policy
+- Overview: swapMint (single-asset mint) and burnSwap (single-asset redeem) are single-asset-facing operations that interface the pool with one external token and the LP shares on the other side. To keep semantics simple and predictable, only the single asset’s fee is applied for these operations; there is no separate “LP token” fee ($f_{\mathrm{LP}} = 0$).
+- swapMint (deposit one token to mint LP):
+  - Apply only the deposited token’s fee $f_i$. Compute the effective kernel input as
+    $$
+    a_{\mathrm{eff}} \;=\; a_{\mathrm{user}}\,(1 - f_i).
+    $$
+    The fee is collected in the deposited token and split by the protocol share $\phi$; the remainder increases the pool (raising $S$ and accruing value to LPs implicitly).
+- burnSwap (burn LP to receive one token):
+  - Apply only the withdrawn token’s fee $f_j$. Compute the gross payout via the fee-free kernel for the burned LP fraction, and remit to the user:
+    $$
+    \text{payout}_{\mathrm{net}} \;=\; \text{payout}_{\mathrm{gross}}\,(1 - f_j).
+    $$
+    The collected fee is retained in the withdrawn token, the protocol takes $\phi$ of that fee, and the remainder increases pool-held balances (raising $S$ for remaining LPs).
+
+Rationale and interactions with pair-fee rules
+- Conceptual consistency: single-asset operations touch a single external token, so applying only that token’s fee is the most natural mapping from the per-token fee vector to operation-level economics. For asset-to-asset swaps the two-token multiplicative composition remains the canonical rule.
+- $f_{\mathrm{LP}} = 0$: keeping LP-side fees at zero simplifies LP accounting and avoids double charging when LP shares are the other leg of a transaction. LPs still receive value via retained fees that increase $S$.
+
+Rounding
+Our policies aim to always protect the LPs value.
+- Total fees are rounded up for the benefit of the pool and against takers.
+- The Protocol fee is rounded down for the benefit of LPs and against the protocol developers.
+
+## Risk Management and Bounded Loss
+Under constant $b$, classical LMSR admits a worst-case loss bound of $b \ln n$ in the payoff numéraire. With $b(\mathbf{q})=\kappa S(\mathbf{q})$, the per-state bound scales with the current size metric, giving an instantaneous worst-case loss $b(\mathbf{q}) \ln n = \kappa\,S(\mathbf{q})\,\ln n$; per unit of size $S$ this is $\kappa \ln n$. Because $b$ varies with state, global worst-case loss along an arbitrary path depends on how $S$ evolves, but the proportionality clarifies how risk scales with liquidity. Operational mitigations include user price limits (swap-to-limit), capacity caps on outputs ($y \le q_j$), minimum bootstrap $S^{(0)}$ to avoid thin-liquidity regimes, and strict numerical guards (e.g., positivity of inner logarithm arguments) to prevent nonphysical states.
+
+## Deployment and Parameter Fixity
+The parameter tuple $(\kappa, f_{\text{swap}}, \phi)$ is set at deployment and remains immutable, with $\kappa>0$ defining $b(\mathbf{q})=\kappa S(\mathbf{q})$, $f_{\text{swap}}$ the swap fee rate, and $\phi$ the protocol share of fees. Given the initial state $\mathbf{q}^{(0)}$ with $S^{(0)}>0$, the induced pricing map is fully determined by
+
+$$
+C(\mathbf{q}) = b(\mathbf{q}) \log\!\left(\sum_i e^{q_i / b(\mathbf{q})}\right), \qquad b(\mathbf{q})=\kappa S(\mathbf{q}),
+$$
+
+and the two-asset closed forms above. Fixity eliminates governance risk, makes depth calibration transparent, and simplifies integration for external routers and valuation tools.
+
+## Conclusion
+By coupling LMSR with the proportional parameterization $b(\mathbf{q})=\kappa S(\mathbf{q})$, we obtain a multi-asset AMM that preserves softmax-driven price ratios under a quasi-static-b view and supports any-to-any swaps via a single convex potential. Exact two-asset reductions yield closed-form mappings for exact-in, exact-out, limit-hitting, and capped-output trades, and the same formulas underpin liquidity operations with monotonicity and uniqueness. Numerical stability follows from log-sum-exp evaluation, ratio-first derivations, guarded transcendental domains, and optional near-balance approximations, while fixed parameters provide predictable scaling and transparent economics.
+
+## References
+Hanson, R. (2002) [_Logarithmic Market Scoring Rules for Modular Combinatorial Information Aggregation_](https://mason.gmu.edu/~rhanson/mktscore.pdf)
+Othman, Pennock, Reeves, Sandholm (2013) [_A Practical Liquidity-Sensitive Automated Market Maker_](https://www.cs.cmu.edu/~sandholm/liquidity-sensitive%20automated%20market%20maker.teac.pdf)
+Xu, Paruch, Cousaert, Feng (2023) [SoK: Decentralized Exchanges (DEX) with Automated Market Maker (AMM) Protocols](https://arxiv.org/pdf/2103.12732)

foundry.lock

@@ -0,0 +1,11 @@
+{
+  "lib/abdk-libraries-solidity": {
+    "rev": "5e1e7c11b35f8313d3f7ce11c1b86320d7c0b554"
+  },
+  "lib/forge-std": {
+    "rev": "8bbcf6e3f8f62f419e5429a0bd89331c85c37824"
+  },
+  "lib/openzeppelin-contracts": {
+    "rev": "c64a1edb67b6e3f4a15cca8909c9482ad33a02b0"
+  }
+}

foundry.toml

@@ -7,10 +7,10 @@ remappings = [
     '@abdk/=lib/abdk-libraries-solidity/',
 ]
 optimizer=true
-optimizer_runs=999999999
+optimizer_runs=100000000 # maximum value allowed by etherscan's verifier XD. The max value is formally 2^32-1
 viaIR=true
-gas_reports = ['PartyPool', 'PartyPlanner', 'PartyPoolSwapImpl', 'PartyPoolMintImpl',]
-fs_permissions = [{ access = "write", path = "chain.json"}]
+gas_reports = ['PartyPool', 'PartyPoolBalancedPair', 'PartyPlanner', 'PartyPoolSwapImpl', 'PartyPoolMintImpl',]
+fs_permissions = [{ access = "write", path = "liqp-deployments.json"}]
 
 [lint]
 lint_on_build=false  # more annoying than helpful