element.
+ */
+ function _generateStats(Properties memory properties)
+ private
+ view
+ returns (string memory)
+ {
+ return string.concat(
+ '',
+ "| ",
+ PRIMITIVE_LOGO,
+ " | ",
+ _generateTitle(properties),
+ "
|
",
+ _generateSpotPrice(properties),
+ _generateStrikePrice(properties),
+ "
",
+ _generateAssetReserves(properties),
+ _generateQuoteReserves(properties),
+ "
",
+ _generatePoolValuation(properties),
+ _generateSwapFee(properties),
+ "
"
+ );
+ }
+
+ /**
+ * @dev Generates the spot price element.
+ */
+ function _generateSpotPrice(Properties memory properties)
+ internal
+ pure
+ returns (string memory)
+ {
+ return string.concat(
+ _generateStat(
+ "Spot Price",
+ AssemblyLib.scaleFromWadDown(
+ properties.pool.spotPriceWad, properties.pair.quoteDecimals
+ ),
+ properties.pair.quoteDecimals,
+ properties.pair.quoteSymbol
+ )
+ );
+ }
+
+ /**
+ * @dev Generates the strike price | element.
+ */
+ function _generateStrikePrice(Properties memory properties)
+ internal
+ pure
+ returns (string memory)
+ {
+ return string.concat(
+ _generateStat(
+ "Strike Price",
+ AssemblyLib.scaleFromWadDown(
+ properties.config.strikePriceWad,
+ properties.pair.quoteDecimals
+ ),
+ properties.pair.quoteDecimals,
+ properties.pair.quoteSymbol
+ )
+ );
+ }
+
+ /**
+ * @dev Calculates the asset reserves and generates the | element.
+ */
+ function _generateAssetReserves(Properties memory properties)
+ internal
+ pure
+ returns (string memory)
+ {
+ return string.concat(
+ _generateStat(
+ "Asset Reserves",
+ AssemblyLib.scaleFromWadDown(
+ properties.pool.virtualX, properties.pair.assetDecimals
+ ),
+ properties.pair.assetDecimals,
+ properties.pair.assetSymbol
+ )
+ );
+ }
+
+ /**
+ * @dev Calculates the quote reserves and generates the | element.
+ */
+ function _generateQuoteReserves(Properties memory properties)
+ internal
+ pure
+ returns (string memory)
+ {
+ return string.concat(
+ _generateStat(
+ "Asset Reserves",
+ AssemblyLib.scaleFromWadDown(
+ properties.pool.virtualY, properties.pair.quoteDecimals
+ ),
+ properties.pair.quoteDecimals,
+ properties.pair.quoteSymbol
+ )
+ );
+ }
+
+ /**
+ * @dev Calculates the pool valuation and generates the | element.
+ */
+ function _generatePoolValuation(Properties memory properties)
+ internal
+ pure
+ returns (string memory)
+ {
+ uint256 poolValuation = AssemblyLib.scaleFromWadDown(
+ properties.pool.virtualX, properties.pair.assetDecimals
+ )
+ * AssemblyLib.scaleFromWadDown(
+ properties.pool.spotPriceWad, properties.pair.quoteDecimals
+ ) / 10 ** properties.pair.assetDecimals
+ + AssemblyLib.scaleFromWadDown(
+ properties.pool.virtualY, properties.pair.quoteDecimals
+ );
+
+ return string.concat(
+ _generateStat(
+ "Pool Valuation",
+ poolValuation,
+ properties.pair.quoteDecimals,
+ properties.pair.quoteSymbol
+ )
+ );
+ }
+
+ /**
+ * @dev Generates the swap fee | element.
+ */
+ function _generateSwapFee(Properties memory properties)
+ internal
+ pure
+ returns (string memory)
+ {
+ return string.concat(
+ _generatePercentStat("Swap Fee", properties.pool.feeBasisPoints)
+ );
+ }
+
+ /**
+ * @dev Generates the footer element.
+ */
+ function _generateFooter(Properties memory properties)
+ internal
+ pure
+ returns (string memory)
+ {
+ string memory controlledLabel = properties.pool.controller == address(0)
+ ? "This pool is not controlled"
+ : string.concat(
+ "This pool is controlled by ",
+ properties.pool.controller.toHexString()
+ );
+
+ return (
+ string.concat(
+ ' ',
+ controlledLabel,
+ " and uses ",
+ properties.pool.hasDefaultStrategy
+ ? "the default strategy."
+ : "a custom strategy.",
+ " "
+ )
);
}
}
diff --git a/contracts/libraries/StringsLib.sol b/contracts/libraries/StringsLib.sol
new file mode 100644
index 00000000..9c1cb578
--- /dev/null
+++ b/contracts/libraries/StringsLib.sol
@@ -0,0 +1,124 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.19;
+
+import { Math } from "openzeppelin/utils/math/Math.sol";
+
+/**
+ * @dev Modified version of:
+ * OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)
+ *
+ * Some of these functions are not really optimized, but since they are not
+ * supposed to be used onchain it doesn't really matter.
+ */
+library StringsLib {
+ bytes16 private constant _SYMBOLS = "0123456789abcdef";
+ uint8 private constant _ADDRESS_LENGTH = 20;
+
+ /**
+ * @dev The `value` string doesn't fit in the specified `length`.
+ */
+ error StringsInsufficientHexLength(uint256 value, uint256 length);
+
+ /**
+ * @dev Converts a `uint256` to its ASCII `string` decimal representation.
+ */
+ function toString(uint256 value) internal pure returns (string memory) {
+ unchecked {
+ uint256 length = Math.log10(value) + 1;
+ string memory buffer = new string(length);
+ uint256 ptr;
+ /// @solidity memory-safe-assembly
+ assembly {
+ ptr := add(buffer, add(32, length))
+ }
+ while (true) {
+ ptr--;
+ /// @solidity memory-safe-assembly
+ assembly {
+ mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
+ }
+ value /= 10;
+ if (value == 0) break;
+ }
+ return buffer;
+ }
+ }
+
+ /**
+ * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
+ */
+ function toHexString(uint256 value) internal pure returns (string memory) {
+ unchecked {
+ return toHexString(value, Math.log256(value) + 1);
+ }
+ }
+
+ /**
+ * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
+ */
+ function toHexString(
+ uint256 value,
+ uint256 length
+ ) internal pure returns (string memory) {
+ uint256 localValue = value;
+ bytes memory buffer = new bytes(2 * length + 2);
+ buffer[0] = "0";
+ buffer[1] = "x";
+ for (uint256 i = 2 * length + 1; i > 1; --i) {
+ buffer[i] = _SYMBOLS[localValue & 0xf];
+ localValue >>= 4;
+ }
+ if (localValue != 0) {
+ revert StringsInsufficientHexLength(value, length);
+ }
+ return string(buffer);
+ }
+
+ /**
+ * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
+ */
+ function toHexString(address addr) internal pure returns (string memory) {
+ return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
+ }
+
+ function toHexColor(bytes3 value) internal pure returns (string memory) {
+ bytes memory result = new bytes(6);
+
+ for (uint256 i = 0; i < 3; i++) {
+ result[i * 2] = _SYMBOLS[uint8(value[i] >> 4)];
+ result[i * 2 + 1] = _SYMBOLS[uint8(value[i] & 0x0F)];
+ }
+
+ return string.concat("#", string(result));
+ }
+
+ function toCountdown(uint256 deadline)
+ internal
+ view
+ returns (string memory)
+ {
+ uint256 timeLeft = deadline - block.timestamp;
+ uint256 daysLeft = timeLeft / 86400;
+ uint256 hoursLeft = (timeLeft % 86400) / 3600;
+ uint256 minutesLeft = (timeLeft % 3600) / 60;
+ uint256 secondsLeft = timeLeft % 60;
+
+ // TODO: Fix the plurals
+ if (daysLeft >= 1) {
+ return (string.concat("Expires in ", toString(daysLeft), " days"));
+ }
+
+ if (hoursLeft >= 1) {
+ return (string.concat("Expires in ", toString(hoursLeft), " hours"));
+ }
+
+ if (minutesLeft >= 1) {
+ return (
+ string.concat("Expires in ", toString(minutesLeft), " minutes")
+ );
+ }
+
+ return (string.concat("Expires in ", toString(secondsLeft), " seconds"));
+ }
+}
diff --git a/scripts/TestDeploy.s.sol b/scripts/TestDeploy.s.sol
new file mode 100644
index 00000000..67a946c6
--- /dev/null
+++ b/scripts/TestDeploy.s.sol
@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.13;
+
+import "forge-std/Script.sol";
+import "solmate/test/utils/mocks/MockERC20.sol";
+
+import "../contracts/test/SimpleRegistry.sol";
+import "../contracts/Portfolio.sol";
+import "../contracts/PositionRenderer.sol";
+import "../contracts/libraries/AssemblyLib.sol";
+
+contract TestDeploy is Script {
+ function run() external {
+ uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
+ address sender = vm.addr(deployerPrivateKey);
+ console.log("Sender:", sender);
+ vm.startBroadcast(deployerPrivateKey);
+
+ MockERC20 usdt = new MockERC20("USDT", "USDT", 18);
+ MockERC20 dai = new MockERC20("DAI", "DAI", 18);
+ MockERC20 weth = new MockERC20("Wrapped Ether", "WETH", 18);
+ MockERC20 usdc = new MockERC20("USD Coin", "USDC", 6);
+
+ address registry = address(new SimpleRegistry());
+ address positionRenderer = address(new PositionRenderer());
+ Portfolio portfolio =
+ new Portfolio(address(weth), registry, positionRenderer);
+
+ // USDT - DAI
+
+ uint64 poolId = _createPool(
+ portfolio,
+ address(usdt),
+ address(dai),
+ AssemblyLib.scaleToWad(1 ether, 18)
+ );
+ _allocate(sender, portfolio, poolId, usdt, dai, 1000 ether, 1000 ether);
+
+ // USDT - USDC
+
+ poolId = _createPool(
+ portfolio,
+ address(usdt),
+ address(usdc),
+ AssemblyLib.scaleToWad(1 * 10 ** 6, 6)
+ );
+ _allocate(
+ sender, portfolio, poolId, usdt, usdc, 2000 ether, 2000 * 10 ** 6
+ );
+
+ // WETH - USDC
+ poolId = _createPool(
+ portfolio,
+ address(weth),
+ address(usdc),
+ AssemblyLib.scaleToWad(2000 * 10 ** 6, 6)
+ );
+ _allocate(
+ sender, portfolio, poolId, weth, usdc, 2 ether, 4000 * 10 ** 6
+ );
+
+ console.log(unicode"🚀 Contracts deployed!");
+ console.log("Portfolio:", address(portfolio));
+
+ vm.stopBroadcast();
+ }
+
+ function _createPool(
+ Portfolio portfolio,
+ address asset,
+ address quote,
+ uint256 price
+ ) public returns (uint64) {
+ uint24 pairId = portfolio.getPairId(asset, quote);
+
+ if (pairId == 0) pairId = portfolio.createPair(asset, quote);
+
+ (bytes memory strategyData, uint256 initialX, uint256 initialY) =
+ INormalStrategy(portfolio.DEFAULT_STRATEGY()).getStrategyData(
+ price, 1_00, 3 days, false, price
+ );
+
+ uint64 poolId = portfolio.createPool(
+ pairId,
+ initialX,
+ initialY,
+ 100,
+ 0,
+ address(0),
+ address(0),
+ strategyData
+ );
+
+ return poolId;
+ }
+
+ function _allocate(
+ address sender,
+ Portfolio portfolio,
+ uint64 poolId,
+ MockERC20 asset,
+ MockERC20 quote,
+ uint128 amount0,
+ uint128 amount1
+ ) public {
+ asset.mint(sender, amount0);
+ asset.approve(address(portfolio), amount0);
+ quote.mint(sender, amount1);
+ quote.approve(address(portfolio), amount1);
+
+ uint128 deltaLiquidity =
+ portfolio.getMaxLiquidity(poolId, amount0, amount1);
+
+ (uint128 deltaAsset, uint128 deltaQuote) =
+ portfolio.getLiquidityDeltas(poolId, int128(deltaLiquidity));
+
+ portfolio.allocate(
+ false, sender, poolId, deltaLiquidity, deltaAsset, deltaQuote
+ );
+ }
+}
diff --git a/test/TestPortfolioUri.t.sol b/test/TestPortfolioBalanceOf.t.sol
similarity index 60%
rename from test/TestPortfolioUri.t.sol
rename to test/TestPortfolioBalanceOf.t.sol
index 9dca2951..396941fc 100644
--- a/test/TestPortfolioUri.t.sol
+++ b/test/TestPortfolioBalanceOf.t.sol
@@ -1,48 +1,12 @@
// SPDX-License-Identifier: GPL-3.0-only
pragma solidity ^0.8.4;
-import "openzeppelin/utils/Base64.sol";
import "solmate/tokens/ERC1155.sol";
+import "../contracts/libraries/AssemblyLib.sol";
import "./Setup.sol";
+import "../contracts/strategies/NormalStrategy.sol";
-contract TestPortfolioUri is Setup {
- function test_uri() public defaultConfig useActor usePairTokens(10 ether) {
- subject().allocate(
- false,
- address(this),
- ghost().poolId,
- 1 ether,
- type(uint128).max,
- type(uint128).max
- );
-
- string memory uri = ERC1155(address(subject())).uri(ghost().poolId);
- console.log(uri);
- }
-
- function test_balanceOf_allocating_sets_balance()
- public
- defaultConfig
- useActor
- usePairTokens(10 ether)
- {
- uint128 liquidity = 1 ether;
-
- subject().allocate(
- false,
- address(this),
- ghost().poolId,
- liquidity,
- type(uint128).max,
- type(uint128).max
- );
-
- assertEq(
- ERC1155(address(subject())).balanceOf(address(this), ghost().poolId),
- liquidity - BURNED_LIQUIDITY
- );
- }
-
+contract TestPortfolioBalanceOf is Setup {
function test_balanceOf_allocating_increases_balance()
public
defaultConfig
diff --git a/test/TestPositionRendererUri.t.sol b/test/TestPositionRendererUri.t.sol
new file mode 100644
index 00000000..cf3346d7
--- /dev/null
+++ b/test/TestPositionRendererUri.t.sol
@@ -0,0 +1,191 @@
+// SPDX-License-Identifier: GPL-3.0-only
+pragma solidity ^0.8.4;
+
+import "solmate/tokens/ERC1155.sol";
+import "../contracts/libraries/AssemblyLib.sol";
+import "./Setup.sol";
+import "../contracts/strategies/NormalStrategy.sol";
+
+contract TestPositionRendererUri is Setup {
+ struct MetaContext {
+ address asset;
+ address quote;
+ uint256 strikePriceWad;
+ uint256 durationSeconds;
+ uint16 swapFee;
+ bool isPerpetual;
+ uint256 priceWad;
+ address controller;
+ address strategy;
+ uint16 prioritySwapFee;
+ }
+
+ function _createPool(MetaContext memory ctx)
+ public
+ returns (uint64 poolId)
+ {
+ uint24 pairId = subject().getPairId(ctx.asset, ctx.quote);
+
+ if (pairId == 0) {
+ pairId = subject().createPair(ctx.asset, ctx.quote);
+ }
+
+ (bytes memory strategyData, uint256 initialX, uint256 initialY) =
+ INormalStrategy(subject().DEFAULT_STRATEGY()).getStrategyData(
+ ctx.strikePriceWad,
+ 1_00, // volatilityBasisPoints
+ ctx.durationSeconds,
+ ctx.isPerpetual,
+ ctx.priceWad
+ );
+
+ poolId = subject().createPool(
+ pairId,
+ initialX,
+ initialY,
+ ctx.swapFee,
+ ctx.prioritySwapFee,
+ ctx.controller,
+ ctx.strategy,
+ strategyData
+ );
+ }
+
+ function _allocate(
+ MetaContext memory ctx,
+ uint64 poolId,
+ uint256 amount0,
+ uint256 amount1
+ ) public {
+ MockERC20(ctx.asset).mint(address(this), amount0);
+ MockERC20(ctx.asset).approve(address(subject()), amount0);
+ MockERC20(ctx.quote).mint(address(this), amount1);
+ MockERC20(ctx.quote).approve(address(subject()), amount1);
+
+ uint128 deltaLiquidity =
+ subject().getMaxLiquidity(poolId, amount0, amount1);
+
+ (uint128 deltaAsset, uint128 deltaQuote) =
+ subject().getLiquidityDeltas(poolId, int128(deltaLiquidity));
+
+ subject().allocate(
+ false, address(this), poolId, deltaLiquidity, deltaAsset, deltaQuote
+ );
+ }
+
+ function test_uri() public {
+ MetaContext memory ctx = MetaContext({
+ asset: address(new MockERC20("Ethereum", "ETH", 18)),
+ quote: address(new MockERC20("USD Coin", "USDC", 6)),
+ strikePriceWad: AssemblyLib.scaleToWad(1666 * 10 ** 6, 6),
+ durationSeconds: 86_400 * 3,
+ swapFee: 400,
+ isPerpetual: false,
+ priceWad: AssemblyLib.scaleToWad(1666 * 10 ** 6, 6),
+ controller: address(0),
+ strategy: address(0),
+ prioritySwapFee: 0
+ });
+
+ uint64 poolId = _createPool(ctx);
+ _allocate(ctx, poolId, 1 ether, 2_000 * 10 ** 6);
+ console.log(ERC1155(address(subject())).uri(poolId));
+ }
+
+ function test_uri_controlled_pool() public {
+ MetaContext memory ctx = MetaContext({
+ asset: address(new MockERC20("Ethereum", "ETH", 18)),
+ quote: address(new MockERC20("USD Coin", "USDC", 6)),
+ strikePriceWad: AssemblyLib.scaleToWad(1666 * 10 ** 6, 6),
+ durationSeconds: 86_400 * 3,
+ swapFee: 400,
+ isPerpetual: false,
+ priceWad: AssemblyLib.scaleToWad(1666 * 10 ** 6, 6),
+ controller: address(this),
+ strategy: address(0),
+ prioritySwapFee: 200
+ });
+
+ uint64 poolId = _createPool(ctx);
+ _allocate(ctx, poolId, 1 ether, 2_000 * 10 ** 6);
+ console.log(ERC1155(address(subject())).uri(poolId));
+ }
+
+ function test_uri_perpetual() public {
+ MetaContext memory ctx = MetaContext({
+ asset: address(new MockERC20("Ethereum", "ETH", 18)),
+ quote: address(new MockERC20("USD Coin", "USDC", 6)),
+ strikePriceWad: AssemblyLib.scaleToWad(1666 * 10 ** 6, 6),
+ durationSeconds: 86_400 * 3,
+ swapFee: 400,
+ isPerpetual: true,
+ priceWad: AssemblyLib.scaleToWad(1666 * 10 ** 6, 6),
+ controller: address(0),
+ strategy: address(0),
+ prioritySwapFee: 0
+ });
+
+ uint64 poolId = _createPool(ctx);
+ _allocate(ctx, poolId, 1 ether, 2_000 * 10 ** 6);
+ console.log(ERC1155(address(subject())).uri(poolId));
+ }
+
+ function test_uri_custom_strategy() public {
+ MetaContext memory ctx = MetaContext({
+ asset: address(new MockERC20("Ethereum", "ETH", 18)),
+ quote: address(new MockERC20("USD Coin", "USDC", 6)),
+ strikePriceWad: AssemblyLib.scaleToWad(1666 * 10 ** 6, 6),
+ durationSeconds: 86_400 * 3,
+ swapFee: 400,
+ isPerpetual: false,
+ priceWad: AssemblyLib.scaleToWad(1666 * 10 ** 6, 6),
+ controller: address(0),
+ strategy: address(new NormalStrategy(address(subject()))),
+ prioritySwapFee: 0
+ });
+
+ uint64 poolId = _createPool(ctx);
+ _allocate(ctx, poolId, 1 ether, 2_000 * 10 ** 6);
+ console.log(ERC1155(address(subject())).uri(poolId));
+ }
+
+ function test_uri_controlled_custom_strategy() public {
+ MetaContext memory ctx = MetaContext({
+ asset: address(new MockERC20("Ethereum", "ETH", 18)),
+ quote: address(new MockERC20("USD Coin", "USDC", 6)),
+ strikePriceWad: AssemblyLib.scaleToWad(1666 * 10 ** 6, 6),
+ durationSeconds: 86_400 * 3,
+ swapFee: 400,
+ isPerpetual: false,
+ priceWad: AssemblyLib.scaleToWad(1666 * 10 ** 6, 6),
+ controller: address(this),
+ strategy: address(new NormalStrategy(address(subject()))),
+ prioritySwapFee: 100
+ });
+
+ uint64 poolId = _createPool(ctx);
+ _allocate(ctx, poolId, 1 ether, 2_000 * 10 ** 6);
+ console.log(ERC1155(address(subject())).uri(poolId));
+ }
+
+ function test_uri_many_pools() public {
+ MetaContext memory ctx = MetaContext({
+ asset: address(new MockERC20("Ethereum", "ETH", 18)),
+ quote: address(new MockERC20("USD Coin", "USDC", 6)),
+ strikePriceWad: AssemblyLib.scaleToWad(1666 * 10 ** 6, 6),
+ durationSeconds: 86_400 * 3,
+ swapFee: 400,
+ isPerpetual: false,
+ priceWad: AssemblyLib.scaleToWad(1666 * 10 ** 6, 6),
+ controller: address(0),
+ strategy: address(0),
+ prioritySwapFee: 0
+ });
+
+ _createPool(ctx);
+ _createPool(ctx);
+ uint64 poolId = _createPool(ctx);
+ _allocate(ctx, poolId, 1 ether, 2_000 * 10 ** 6);
+ console.log(ERC1155(address(subject())).uri(poolId));
+ }
+}
|