From 1817931875d63bdbbf7f9a756a75da932c24b880 Mon Sep 17 00:00:00 2001 From: simplyoptimistic <111120814+simplyoptimistic@users.noreply.github.com> Date: Fri, 23 Feb 2024 10:26:36 +1100 Subject: [PATCH] revert: "feat: update art (#139)" This reverts commit d8097839980e2025df87c31b8108ae6c0422097c. --- .../periphery/libraries/NFTDescriptor.sol | 43 +- contracts/periphery/libraries/NFTSVG.sol | 392 +++++++++++++++--- .../periphery/test/NFTDescriptorTest.sol | 19 + test/periphery/NFTDescriptor.spec.ts | 94 +++++ .../__snapshots__/NFTDescriptor.spec.ts.snap | 6 +- .../periphery/__snapshots__/NFTDescriptor.svg | 2 +- 6 files changed, 496 insertions(+), 60 deletions(-) diff --git a/contracts/periphery/libraries/NFTDescriptor.sol b/contracts/periphery/libraries/NFTDescriptor.sol index bf39586..4d2f0be 100644 --- a/contracts/periphery/libraries/NFTDescriptor.sol +++ b/contracts/periphery/libraries/NFTDescriptor.sol @@ -403,9 +403,50 @@ library NFTDescriptor { tickLower: params.tickLower, tickUpper: params.tickUpper, tickSpacing: params.tickSpacing, - tokenId: params.tokenId + overRange: overRange(params.tickLower, params.tickUpper, params.tickCurrent), + tokenId: params.tokenId, + color0: tokenToColorHex(uint256(params.quoteTokenAddress), 136), + color1: tokenToColorHex(uint256(params.baseTokenAddress), 136), + color2: tokenToColorHex(uint256(params.quoteTokenAddress), 0), + color3: tokenToColorHex(uint256(params.baseTokenAddress), 0), + x1: scale(getCircleCoord(uint256(params.quoteTokenAddress), 16, params.tokenId), 0, 255, 16, 274), + y1: scale(getCircleCoord(uint256(params.baseTokenAddress), 16, params.tokenId), 0, 255, 100, 484), + x2: scale(getCircleCoord(uint256(params.quoteTokenAddress), 32, params.tokenId), 0, 255, 16, 274), + y2: scale(getCircleCoord(uint256(params.baseTokenAddress), 32, params.tokenId), 0, 255, 100, 484), + x3: scale(getCircleCoord(uint256(params.quoteTokenAddress), 48, params.tokenId), 0, 255, 16, 274), + y3: scale(getCircleCoord(uint256(params.baseTokenAddress), 48, params.tokenId), 0, 255, 100, 484) }); return NFTSVG.generateSVG(svgParams); } + + function overRange(int24 tickLower, int24 tickUpper, int24 tickCurrent) private pure returns (int8) { + if (tickCurrent < tickLower) { + return -1; + } else if (tickCurrent > tickUpper) { + return 1; + } else { + return 0; + } + } + + function scale(uint256 n, uint256 inMn, uint256 inMx, uint256 outMn, uint256 outMx) + private + pure + returns (string memory) + { + return (n.sub(inMn).mul(outMx.sub(outMn)).div(inMx.sub(inMn)).add(outMn)).toString(); + } + + function tokenToColorHex(uint256 token, uint256 offset) internal pure returns (string memory str) { + return string((token >> offset).toHexStringNoPrefix(3)); + } + + function getCircleCoord(uint256 tokenAddress, uint256 offset, uint256 tokenId) internal pure returns (uint256) { + return (sliceTokenHex(tokenAddress, offset) * tokenId) % 255; + } + + function sliceTokenHex(uint256 token, uint256 offset) internal pure returns (uint256) { + return uint256(uint8(token >> offset)); + } } diff --git a/contracts/periphery/libraries/NFTSVG.sol b/contracts/periphery/libraries/NFTSVG.sol index 1bb86c8..8394617 100644 --- a/contracts/periphery/libraries/NFTSVG.sol +++ b/contracts/periphery/libraries/NFTSVG.sol @@ -2,6 +2,7 @@ pragma solidity >=0.7.6; import "@openzeppelin/contracts/utils/Strings.sol"; +import "contracts/core/libraries/BitMath.sol"; import "base64-sol/base64.sol"; /// @title NFTSVG @@ -9,6 +10,15 @@ import "base64-sol/base64.sol"; library NFTSVG { using Strings for uint256; + string constant curve1 = "M1 1C41 41 105 105 145 145"; + string constant curve2 = "M1 1C33 49 97 113 145 145"; + string constant curve3 = "M1 1C33 57 89 113 145 145"; + string constant curve4 = "M1 1C25 65 81 121 145 145"; + string constant curve5 = "M1 1C17 73 73 129 145 145"; + string constant curve6 = "M1 1C9 81 65 137 145 145"; + string constant curve7 = "M1 1C1 89 57.5 145 145 145"; + string constant curve8 = "M1 1C1 97 49 145 145 145"; + struct SVGParams { string quoteToken; string baseToken; @@ -18,87 +28,313 @@ library NFTSVG { int24 tickLower; int24 tickUpper; int24 tickSpacing; + int8 overRange; uint256 tokenId; + string color0; + string color1; + string color2; + string color3; + string x1; + string y1; + string x2; + string y2; + string x3; + string y3; } function generateSVG(SVGParams memory params) internal pure returns (string memory svg) { + /* + address: "0xe8ab59d3bcde16a29912de83a90eb39628cfc163", + msg: "Forged in SVG for Uniswap in 2021 by 0xe8ab59d3bcde16a29912de83a90eb39628cfc163", + sig: "0x2df0e99d9cbfec33a705d83f75666d98b22dea7c1af412c584f7d626d83f02875993df740dc87563b9c73378f8462426da572d7989de88079a382ad96c57b68d1b", + version: "2" + */ return string( abi.encodePacked( - '', - generateArt(), - generateSVGDefs(), - generateGroupText(params), + generateSVGDefs(params), + generateSVGBorderText( + params.quoteToken, params.baseToken, params.quoteTokenSymbol, params.baseTokenSymbol + ), + generateSVGCardMantle( + params.quoteTokenSymbol, params.baseTokenSymbol, (uint256(params.tickSpacing)).toString() + ), + generageSvgCurve(params.tickLower, params.tickUpper, params.tickSpacing, params.overRange), + generateSVGPositionDataAndLocationCurve(params.tokenId.toString(), params.tickLower, params.tickUpper), + generateSVGRareSparkle(params.tokenId, params.poolAddress), "" ) ); } - function generateArt() private pure returns (string memory svg) { + function generateSVGDefs(SVGParams memory params) private pure returns (string memory svg) { svg = string( abi.encodePacked( - '', - '', - '', - '', - '', - '', - '', - '', - '', - '', - '', - '', - '', - '', - '', - '', - '', - '', - '', - "" + '", + "", + '" + ) + ) + ), + '"/>" + ) + ) + ), + '"/>" + ) + ) + ), + '" />', + '" + ) + ) + ), + '" /> ', + '', + '', + '', + '', + '', + '', + '', + '', + '', + '', + '', + '', + '', + '', + ' ', + '', + '', + '' ) ); } - function generateSVGDefs() private pure returns (string memory svg) { + function generateSVGBorderText( + string memory quoteToken, + string memory baseToken, + string memory quoteTokenSymbol, + string memory baseTokenSymbol + ) private pure returns (string memory svg) { svg = string( abi.encodePacked( - '', - '', - '', - '' + '', + '', + baseToken, + unicode" • ", + baseTokenSymbol, + ' ', + ' ', + baseToken, + unicode" • ", + baseTokenSymbol, + ' ', + '', + quoteToken, + unicode" • ", + quoteTokenSymbol, + ' ', + quoteToken, + unicode" • ", + quoteTokenSymbol, + ' ' ) ); } - function generateGroupText(SVGParams memory params) private pure returns (string memory svg) { - string memory symbol = string(abi.encodePacked(params.quoteTokenSymbol, "/", params.baseTokenSymbol)); - string memory id = string(abi.encodePacked("ID #", params.tokenId.toString())); - string memory tickSpacings = string( - abi.encodePacked(tickToString(params.tickLower), " MIN : ", tickToString(params.tickUpper), " MAX TICK") - ); - string memory tickSpacing = string(abi.encodePacked("CL", tickToString(params.tickSpacing))); + function generateSVGCardMantle( + string memory quoteTokenSymbol, + string memory baseTokenSymbol, + string memory tickSpacing + ) private pure returns (string memory svg) { svg = string( abi.encodePacked( - '', - '', - symbol, - '', - id, - '', - tickSpacings, - ' ', + quoteTokenSymbol, + "/", + baseTokenSymbol, + '', tickSpacing, - '" fill="#231E33" xml:space="preserve" style="white-space: pre" font-family="Arial, sans-serif" font-size="28" font-weight="500" letter-spacing="0em">', - tickSpacing, - "", - "" + "", + '' + ) + ); + } + + function generageSvgCurve(int24 tickLower, int24 tickUpper, int24 tickSpacing, int8 overRange) + private + pure + returns (string memory svg) + { + string memory fade = overRange == 1 ? "#fade-up" : overRange == -1 ? "#fade-down" : "#none"; + string memory curve = getCurve(tickLower, tickUpper, tickSpacing); + svg = string( + abi.encodePacked( + '' + '' '', + '', + '', + '', + generateSVGCurveCircle(overRange) + ) + ); + } + + function getCurve(int24 tickLower, int24 tickUpper, int24 tickSpacing) + internal + pure + returns (string memory curve) + { + int24 tickRange = (tickUpper - tickLower) / tickSpacing; + if (tickRange <= 4) { + curve = curve1; + } else if (tickRange <= 8) { + curve = curve2; + } else if (tickRange <= 16) { + curve = curve3; + } else if (tickRange <= 32) { + curve = curve4; + } else if (tickRange <= 64) { + curve = curve5; + } else if (tickRange <= 128) { + curve = curve6; + } else if (tickRange <= 256) { + curve = curve7; + } else { + curve = curve8; + } + } + + function generateSVGCurveCircle(int8 overRange) internal pure returns (string memory svg) { + string memory curvex1 = "73"; + string memory curvey1 = "190"; + string memory curvex2 = "217"; + string memory curvey2 = "334"; + if (overRange == 1 || overRange == -1) { + svg = string( + abi.encodePacked( + '' + ) + ); + } else { + svg = string( + abi.encodePacked( + '', + '' + ) + ); + } + } + + function generateSVGPositionDataAndLocationCurve(string memory tokenId, int24 tickLower, int24 tickUpper) + private + pure + returns (string memory svg) + { + string memory tickLowerStr = tickToString(tickLower); + string memory tickUpperStr = tickToString(tickUpper); + uint256 str1length = bytes(tokenId).length + 4; + uint256 str2length = bytes(tickLowerStr).length + 10; + uint256 str3length = bytes(tickUpperStr).length + 10; + (string memory xCoord, string memory yCoord) = rangeLocation(tickLower, tickUpper); + svg = string( + abi.encodePacked( + ' ', + '', + 'ID: ', + tokenId, + "", + ' ', + '', + 'Min Tick: ', + tickLowerStr, + "", + ' ', + '', + 'Max Tick: ', + tickUpperStr, + "" '', + '', + '', + '' ) ); } @@ -111,4 +347,50 @@ library NFTSVG { } return string(abi.encodePacked(sign, uint256(tick).toString())); } + + function rangeLocation(int24 tickLower, int24 tickUpper) internal pure returns (string memory, string memory) { + int24 midPoint = (tickLower + tickUpper) / 2; + if (midPoint < -125_000) { + return ("8", "7"); + } else if (midPoint < -75_000) { + return ("8", "10.5"); + } else if (midPoint < -25_000) { + return ("8", "14.25"); + } else if (midPoint < -5_000) { + return ("10", "18"); + } else if (midPoint < 0) { + return ("11", "21"); + } else if (midPoint < 5_000) { + return ("13", "23"); + } else if (midPoint < 25_000) { + return ("15", "25"); + } else if (midPoint < 75_000) { + return ("18", "26"); + } else if (midPoint < 125_000) { + return ("21", "27"); + } else { + return ("24", "27"); + } + } + + function generateSVGRareSparkle(uint256 tokenId, address poolAddress) private pure returns (string memory svg) { + if (isRare(tokenId, poolAddress)) { + svg = string( + abi.encodePacked( + '', + '', + '' + ) + ); + } else { + svg = ""; + } + } + + function isRare(uint256 tokenId, address poolAddress) internal pure returns (bool) { + bytes32 h = keccak256(abi.encodePacked(tokenId, poolAddress)); + return uint256(h) < type(uint256).max / (1 + BitMath.mostSignificantBit(tokenId) * 2); + } } diff --git a/contracts/periphery/test/NFTDescriptorTest.sol b/contracts/periphery/test/NFTDescriptorTest.sol index 6b75bf6..43a07c5 100644 --- a/contracts/periphery/test/NFTDescriptorTest.sol +++ b/contracts/periphery/test/NFTDescriptorTest.sol @@ -4,8 +4,11 @@ pragma abicoder v2; import "../libraries/NFTDescriptor.sol"; import "../libraries/NFTSVG.sol"; +import "../libraries/HexStrings.sol"; contract NFTDescriptorTest { + using HexStrings for uint256; + function constructTokenURI(NFTDescriptor.ConstructTokenURIParams calldata params) public pure @@ -53,4 +56,20 @@ contract NFTDescriptorTest { { return NFTDescriptor.generateSVGImage(params); } + + function tokenToColorHex(address token, uint256 offset) public pure returns (string memory) { + return NFTDescriptor.tokenToColorHex(uint256(token), offset); + } + + function sliceTokenHex(address token, uint256 offset) public pure returns (uint256) { + return NFTDescriptor.sliceTokenHex(uint256(token), offset); + } + + function rangeLocation(int24 tickLower, int24 tickUpper) public pure returns (string memory, string memory) { + return NFTSVG.rangeLocation(tickLower, tickUpper); + } + + function isRare(uint256 tokenId, address poolAddress) public pure returns (bool) { + return NFTSVG.isRare(tokenId, poolAddress); + } } diff --git a/test/periphery/NFTDescriptor.spec.ts b/test/periphery/NFTDescriptor.spec.ts index d136368..30e1dbe 100644 --- a/test/periphery/NFTDescriptor.spec.ts +++ b/test/periphery/NFTDescriptor.spec.ts @@ -633,6 +633,90 @@ describe('NFTDescriptor', () => { }) }) + describe('#tokenToColorHex', () => { + function tokenToColorHex(tokenAddress: string, startIndex: number): string { + return `${tokenAddress.slice(startIndex, startIndex + 6).toLowerCase()}` + } + + it('returns the correct hash for the first 3 bytes of the token address', async () => { + expect(await nftDescriptor.tokenToColorHex(tokens[0].address, 136)).to.eq(tokenToColorHex(tokens[0].address, 2)) + expect(await nftDescriptor.tokenToColorHex(tokens[1].address, 136)).to.eq(tokenToColorHex(tokens[1].address, 2)) + }) + + it('returns the correct hash for the last 3 bytes of the address', async () => { + expect(await nftDescriptor.tokenToColorHex(tokens[0].address, 0)).to.eq(tokenToColorHex(tokens[0].address, 36)) + expect(await nftDescriptor.tokenToColorHex(tokens[1].address, 0)).to.eq(tokenToColorHex(tokens[1].address, 36)) + }) + }) + + describe('#rangeLocation', () => { + it('returns the correct coordinates when range midpoint under -125_000', async () => { + const coords = await nftDescriptor.rangeLocation(-887_272, -887_100) + expect(coords[0]).to.eq('8') + expect(coords[1]).to.eq('7') + }) + + it('returns the correct coordinates when range midpoint is between -125_000 and -75_000', async () => { + const coords = await nftDescriptor.rangeLocation(-100_000, -90_000) + expect(coords[0]).to.eq('8') + expect(coords[1]).to.eq('10.5') + }) + + it('returns the correct coordinates when range midpoint is between -75_000 and -25_000', async () => { + const coords = await nftDescriptor.rangeLocation(-50_000, -20_000) + expect(coords[0]).to.eq('8') + expect(coords[1]).to.eq('14.25') + }) + + it('returns the correct coordinates when range midpoint is between -25_000 and -5_000', async () => { + const coords = await nftDescriptor.rangeLocation(-10_000, -5_000) + expect(coords[0]).to.eq('10') + expect(coords[1]).to.eq('18') + }) + + it('returns the correct coordinates when range midpoint is between -5_000 and 0', async () => { + const coords = await nftDescriptor.rangeLocation(-5_000, -4_000) + expect(coords[0]).to.eq('11') + expect(coords[1]).to.eq('21') + }) + + it('returns the correct coordinates when range midpoint is between 0 and 5_000', async () => { + const coords = await nftDescriptor.rangeLocation(4_000, 5_000) + expect(coords[0]).to.eq('13') + expect(coords[1]).to.eq('23') + }) + + it('returns the correct coordinates when range midpoint is between 5_000 and 25_000', async () => { + const coords = await nftDescriptor.rangeLocation(10_000, 15_000) + expect(coords[0]).to.eq('15') + expect(coords[1]).to.eq('25') + }) + + it('returns the correct coordinates when range midpoint is between 25_000 and 75_000', async () => { + const coords = await nftDescriptor.rangeLocation(25_000, 50_000) + expect(coords[0]).to.eq('18') + expect(coords[1]).to.eq('26') + }) + + it('returns the correct coordinates when range midpoint is between 75_000 and 125_000', async () => { + const coords = await nftDescriptor.rangeLocation(100_000, 125_000) + expect(coords[0]).to.eq('21') + expect(coords[1]).to.eq('27') + }) + + it('returns the correct coordinates when range midpoint is above 125_000', async () => { + const coords = await nftDescriptor.rangeLocation(200_000, 100_000) + expect(coords[0]).to.eq('24') + expect(coords[1]).to.eq('27') + }) + + it('math does not overflow on max value', async () => { + const coords = await nftDescriptor.rangeLocation(887_272, 887_272) + expect(coords[0]).to.eq('24') + expect(coords[1]).to.eq('27') + }) + }) + describe('#svgImage', () => { let tokenId: number let baseTokenAddress: string @@ -705,6 +789,16 @@ describe('NFTDescriptor', () => { }) }) + describe('#isRare', () => { + it('returns true sometimes', async () => { + expect(await nftDescriptor.isRare(1, `0x${'b'.repeat(40)}`)).to.eq(true) + }) + + it('returns false sometimes', async () => { + expect(await nftDescriptor.isRare(2, `0x${'b'.repeat(40)}`)).to.eq(false) + }) + }) + function constructTokenMetadata( tokenId: number, quoteTokenAddress: string, diff --git a/test/periphery/__snapshots__/NFTDescriptor.spec.ts.snap b/test/periphery/__snapshots__/NFTDescriptor.spec.ts.snap index f4a92b8..3ee3541 100644 --- a/test/periphery/__snapshots__/NFTDescriptor.spec.ts.snap +++ b/test/periphery/__snapshots__/NFTDescriptor.spec.ts.snap @@ -1,7 +1,7 @@ // Jest Snapshot v1, https://goo.gl/fbAQLP -exports[`NFTDescriptor #constructTokenURI gas 1`] = `4009329`; +exports[`NFTDescriptor #constructTokenURI gas 1`] = `1510940`; -exports[`NFTDescriptor #constructTokenURI snapshot matches 1`] = `"data:application/json;base64,{"name":"CL - UNI/WETH - 1.0000<>1.1052", "description":"This NFT represents a liquidity position in a CL UNI-WETH pool. The owner of this NFT can modify or redeem the position.\n\nPool Address: 0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nUNI Address: 0xabcdeabcdefabcdefabcdefabcdefabcdefabcdf\nWETH Address: 0x1234567890123456789123456789012345678901\nTick Spacing: 10\nToken ID: 1\n\n⚠️ DISCLAIMER: Due diligence is imperative when assessing this NFT. Make sure token addresses match the expected tokens, as token symbols may be imitated.", "image": "data:image/svg+xml;base64,<svg width="800" height="800" viewBox="0 0 800 800" fill="none" xmlns="http://www.w3.org/2000/svg"><g id="NFT Velo" clip-path="url(#clip0_1098_756)"><rect id="Rectangle 1" width="800" height="800" fill="url(#paint0_radial_1098_756)" /><path id="Rectangle 2" d="M394 234L394 566L-5.63368e-05 566L-6.10352e-05 234L394 234Z" fill="url(#paint1_linear_1098_756)" /><circle id="Ellipse" cx="399.837" cy="399.837" r="165.837" fill="#21293A" /><path id="Vector" d="M394.949 246.974C395.328 249.002 395.62 250.928 396.084 252.836C398.938 264.612 404.92 274.514 414.083 282.456C417.006 285 420.409 286.565 424.415 286.445C428.025 286.324 431.034 284.794 433.664 282.456C438.065 278.554 440.833 273.637 442.431 268.033C443.996 262.532 444.219 256.876 444.58 251.22C444.701 249.243 444.838 247.266 444.976 245.237C451.027 245.787 456.098 248.211 460.448 252.234C465.433 256.841 468.527 262.6 470.642 268.978C472.808 275.494 474.08 282.198 474.596 289.023C474.923 293.441 474.94 297.894 474.974 302.329C474.974 303.051 474.441 303.773 474.149 304.495C474.046 304.736 473.874 304.994 473.874 305.234C474.063 314.002 472.619 322.649 472.12 331.365C472 333.359 472.292 335.199 473.169 337.038C475.198 341.302 475.421 345.84 474.304 350.361C473.289 354.504 472.155 358.613 470.848 362.67C469.731 366.108 467.101 368.171 463.697 369.203C461.909 369.753 460.826 369.031 460.413 367.174C460.138 365.902 459.932 364.63 459.657 363.358C458.935 360.177 458.247 356.98 457.439 353.817C456.769 351.186 456.7 348.539 457.336 345.926C458.075 342.832 458.11 339.772 457.422 336.677C456.442 332.225 455.393 327.789 454.534 323.337C453.846 319.761 453.365 316.151 452.798 312.558C452.746 312.248 452.677 311.939 452.591 311.492C452.351 311.801 452.179 311.991 452.024 312.197C449.6 315.824 446.265 318.076 441.967 319.039C434.558 320.689 427.114 321.48 419.584 320.277C411.608 319.005 404.336 316.168 398.422 310.443C395.946 308.037 393.901 305.303 392.216 302.295C392.027 301.968 391.838 301.659 391.494 301.091C390.445 303.154 389.465 305.028 388.52 306.902C387.557 308.759 386.612 310.632 385.666 312.506C383.122 317.492 381.85 322.804 382.09 328.391C382.262 332.431 381.437 336.247 379.941 339.943C378.927 342.471 377.81 344.946 376.641 347.662C375.901 346.785 375.265 346.098 374.715 345.359C373.392 343.588 372.309 343.296 370.28 344.172C367.89 345.204 366.601 347.112 365.948 349.519C363.799 357.41 361.684 365.318 359.518 373.191C358.985 375.099 358.246 376.956 357.541 379.036C355.547 376.131 354.344 373.277 355.444 369.994C356.166 367.827 357.077 365.679 358.143 363.65C361.753 356.791 363.146 349.45 363.146 341.8C363.146 336.007 363.318 330.265 365.019 324.678C365.656 322.615 366.412 320.569 367.272 318.575C368.819 314.965 369.249 311.165 369.438 307.315C369.61 303.653 369.867 299.991 369.902 296.329C369.919 293.854 369.403 291.361 369.472 288.903C369.575 285.671 369.85 282.422 370.349 279.224C371.277 273.276 373.013 267.551 376.159 262.36C380.302 255.5 385.941 250.36 393.557 247.558C393.969 247.403 394.382 247.249 395.001 247.025L394.949 246.974Z" fill="white" /><path id="Vector_2" d="M385.185 416.84C384.274 418.902 383.466 421.034 382.417 423.028C381.506 424.747 380.457 426.449 379.185 427.911C375.403 432.26 373.374 437.211 373.151 442.987C372.876 450.431 370.796 457.393 367.529 464.098C364.246 470.854 361.186 477.748 358.315 484.693C357.249 487.237 356.733 490.074 356.372 492.824C355.599 498.669 349.823 499.959 346.092 498.119C344.562 497.38 343.943 496.194 344.201 494.509C345.422 486.636 345.37 478.711 345.318 470.768C345.284 464.029 345.422 457.29 345.748 450.551C345.972 446.116 347.519 442.042 350.098 438.346C355.255 430.936 357.61 422.547 358.384 413.659C358.951 407.023 359.501 400.37 359.897 393.717C360.103 390.228 361.874 388.147 364.968 386.841C370.675 384.451 376.28 385.036 381.781 387.408C384.05 388.388 386.251 389.574 388.417 390.795C390.634 392.033 390.927 392.806 390.342 395.265C389.362 399.408 388.314 403.551 387.316 407.694C386.835 409.688 386.44 411.699 385.958 413.831C386.852 413.247 387.592 412.748 388.348 412.232C389.19 413.178 389.603 414.123 389.5 415.413C388.726 424.352 386.818 433.085 385.133 441.87C380.406 466.419 374.681 490.744 368.337 514.915C364.693 528.84 360.67 542.662 356.802 556.535C356.544 557.446 356.166 558.306 355.874 559.217C355.41 560.644 354.567 561.675 352.934 561.985C352.212 561.245 351.714 560.437 351.886 559.2C352.453 555.4 352.9 551.584 353.398 547.785C353.433 547.475 353.519 547.149 353.587 546.839C353.708 546.839 353.845 546.873 353.966 546.891L353.433 554.145C353.433 554.145 353.553 554.197 353.622 554.231C353.897 553.595 354.241 552.976 354.447 552.323C356.579 545.292 358.968 538.329 360.756 531.23C365.638 511.907 370.4 492.567 374.939 473.175C378.738 456.981 382.245 440.718 384.858 424.283C385.185 422.186 385.357 420.054 385.58 417.94C385.615 417.613 385.58 417.269 385.58 416.925C385.443 416.891 385.305 416.874 385.185 416.84Z" fill="white" /><path id="Vector_3" d="M402.565 419.401C401.379 420.415 400.433 421.223 399.264 422.22C399.866 419.831 400.674 417.854 402.548 416.479C404.404 415.121 406.57 415.035 408.737 414.949C408.685 413.367 407.533 411.992 405.866 411.648C404.886 411.442 403.854 411.373 402.84 411.373C401.121 411.373 400.021 412.232 399.316 413.831C396.084 421.12 393.952 428.753 392.01 436.472C387.832 452.941 384.72 469.651 381.489 486.309C381.489 486.378 381.489 486.447 381.489 486.619C384.256 487.306 387.058 488.011 389.947 488.733C389.586 490.246 389.242 491.707 388.864 493.272C387.213 492.893 385.614 492.532 384.033 492.171C382.95 491.931 381.85 491.69 380.767 491.415C378.979 490.985 378.704 490.573 378.979 488.75C379.718 483.851 380.371 478.934 381.231 474.035C384.17 457.101 387.179 440.168 390.204 423.252C391.03 418.627 392.989 414.381 395.293 410.324C397.029 407.264 399.35 405.992 402.874 405.94C403.029 405.236 403.201 404.496 403.339 403.757C405.384 393.047 407.43 382.337 409.476 371.627C409.527 371.352 409.579 371.077 409.648 370.802C410.146 368.859 410.782 368.378 412.742 368.653C413.98 368.825 415.2 369.151 416.455 369.34C417.195 369.461 417.384 369.822 417.246 370.492C416.92 372.091 416.644 373.724 416.283 375.306C413.997 385.036 411.711 394.766 409.407 404.496C409.012 406.181 409.183 406.92 410.421 407.694C413.447 409.551 414.392 412.336 414.135 415.688C412.776 433.257 410.507 450.706 407.378 468.035C403.768 488.045 398.92 507.746 393.11 527.224C390.428 536.198 387.763 545.206 384.617 554.025C382.434 560.145 379.494 565.99 376.795 571.904C375.489 574.775 372.326 576.064 369.3 575.187C367.392 574.637 366.309 573.348 365.965 571.405C365.157 566.833 365.466 562.277 365.965 557.721C366.051 556.896 366.12 556.054 366.257 555.228C366.292 554.971 366.498 554.73 366.756 554.506C367.478 558.306 366.79 562.328 369.162 566.025C369.695 564.959 370.246 564.116 370.555 563.188C374.956 549.469 379.443 535.768 383.655 521.998C387.058 510.841 390.29 499.615 393.264 488.32C396.531 475.908 398.955 463.307 400.897 450.62C401.894 444.105 402.72 437.538 403.459 430.988C403.768 428.289 403.751 425.538 403.665 422.822C403.631 421.722 403.012 420.656 402.582 419.384L402.565 419.401Z" fill="white" /><path id="Vector_4" d="M416.782 357.994C415.097 355.794 415.218 353.335 415.183 350.877C415.166 349.21 415.149 347.508 414.839 345.857C414.616 344.671 414.1 343.416 413.378 342.453C411.728 340.236 408.754 340.511 407.292 342.883C405.986 345.015 405.178 347.37 404.679 349.828C404.473 350.843 404.181 351.874 403.785 352.82C403.218 354.195 402.066 354.865 400.588 354.676C399.213 354.504 397.837 354.212 396.479 353.868C391.941 352.682 387.419 351.444 382.898 350.241C379.305 349.278 378.532 347.783 379.941 344.31C382.572 337.777 383.809 330.97 384.067 323.973C384.274 318.472 386.44 313.813 389.929 309.704C391.442 307.899 392.181 307.934 394.038 309.464C396.307 311.337 398.525 313.28 400.949 314.93C409.613 320.827 419.154 323.681 429.693 323.045C435.108 322.718 440.351 321.411 445.577 320.088C446.523 319.847 447.485 319.606 448.448 319.434C449.497 319.245 450.184 319.624 450.459 320.638C452.557 328.168 454.671 335.68 454.86 343.571C454.946 346.923 455.187 350.275 455.239 353.628C455.256 354.831 454.929 356.034 454.723 357.427C453.829 356.705 453.124 356.103 452.402 355.536C447.348 351.513 441.623 349.295 435.108 349.106C430.329 348.969 426.34 350.877 422.644 353.645C420.822 355.003 419.034 356.395 417.229 357.754C417.091 357.857 416.937 357.908 416.748 358.011L416.782 357.994Z" fill="white" /><path id="Vector_5" d="M447.365 377.575C447.228 378.572 447.159 379.586 446.918 380.549C446.643 381.666 446.299 382.784 445.835 383.833C444.219 387.597 443.875 391.5 444.34 395.54C444.649 398.308 444.804 401.127 444.787 403.912C444.769 408.141 443.085 411.871 440.815 415.361C436.483 422.031 431.996 428.581 427.87 435.389C425.773 438.844 419.258 439.446 417.006 434.753C415.579 431.813 415.527 428.942 415.751 425.917C416.129 420.759 415.63 415.653 414.926 410.548C414.427 406.937 414.152 403.31 415.252 399.734C415.888 397.654 416.834 395.712 418.415 394.233C421.991 390.933 423.16 386.807 423.005 382.096C422.902 379.346 422.885 376.578 422.971 373.81C423.04 371.747 424.243 370.802 426.255 371.197C432.151 372.349 438.03 373.552 443.927 374.773C444.494 374.893 445.062 375.134 445.595 375.375C446.523 375.787 447.09 376.492 447.365 377.558V377.575Z" fill="white" /><path id="Vector_6" d="M359.432 381.443C359.054 380.411 358.813 379.431 359.14 378.297C361.77 369.014 364.332 359.713 366.962 350.43C367.323 349.175 367.839 347.903 368.526 346.803C369.455 345.341 370.933 344.619 372.687 345.049C373.357 345.204 374.062 345.737 374.457 346.304C375.712 348.092 377.449 349.089 379.46 349.759C389.362 353.129 399.367 356.103 409.562 358.493C427.389 362.653 445.199 366.951 463.009 371.18C466.447 372.005 467.616 371.575 469.696 368.67C471.123 366.676 472.877 365.214 475.456 365.146C478.292 365.077 479.478 366.504 478.825 369.254C478.155 372.074 477.381 374.876 476.659 377.678C475.18 383.54 473.633 389.385 472.258 395.265C471.639 397.912 471.33 400.628 470.9 403.31C470.831 403.723 470.797 404.135 470.728 404.548C468.803 404.307 467.393 402.588 467.427 400.319C467.479 396.519 467.616 392.703 467.823 388.904C467.977 386.153 468.287 383.403 468.527 380.669C468.699 378.658 468.356 378.056 466.379 377.626C459.21 376.045 452.041 374.515 444.872 372.968C421.922 367.999 398.972 363.031 376.039 358.063C375.661 357.977 375.283 357.891 374.904 357.822C372.48 357.427 371.105 358.114 370.142 360.401C368.853 363.495 367.684 366.658 366.412 369.753C365.037 373.122 363.627 376.475 362.234 379.827C361.719 381.082 360.687 381.426 359.415 381.426L359.432 381.443Z" fill="white" /><path id="Vector_7" d="M356.2 522.943C357.043 527.619 356.716 532.244 355.633 536.817C355.186 538.742 354.103 539.584 352.246 539.344C346.608 538.604 340.969 537.814 335.33 536.971C332.27 536.507 330.242 534.41 328.454 532.141C327.44 530.851 327.955 529.373 328.832 528.152C330.311 526.072 331.875 524.044 333.388 521.981C334.694 520.21 336.121 518.491 337.256 516.617C339.044 513.694 341.777 512.182 344.854 511.219C346.505 510.703 348.258 510.411 349.977 510.239C351.524 510.084 352.693 510.961 353.14 512.474C354.189 515.964 355.152 519.471 356.166 522.96L356.2 522.943Z" fill="white" /><path id="Vector_8" d="M393.282 389.454C385.907 386.875 378.652 384.314 371.226 381.718C371.604 381.202 371.93 380.773 372.24 380.343C373.736 378.228 375.3 376.165 376.727 373.999C378.394 371.489 378.326 370.681 376.366 368.429C375.111 366.985 374.079 365.421 373.65 363.547C373.117 361.243 374.767 359.318 377.122 359.731C380.217 360.264 383.277 361.003 386.354 361.673C390.514 362.567 394.692 363.478 398.852 364.372C399.058 364.424 399.264 364.458 399.471 364.51C401.276 364.957 401.774 365.696 401.259 367.467C400.399 370.458 399.557 373.449 398.508 376.372C397.03 380.446 395.379 384.451 393.798 388.474C393.677 388.801 393.488 389.093 393.299 389.471L393.282 389.454Z" fill="white" /><path id="Vector_9" d="M426.134 447.801C426.615 449.434 427.114 450.999 427.527 452.58C428.799 457.566 429.349 462.551 427.527 467.554C426.478 470.39 424.948 471.404 421.94 471.078C419.859 470.854 417.762 470.734 415.699 470.407C412.209 469.857 410.8 468.327 410.903 464.82C411.075 459.147 411.419 453.457 411.797 447.784C411.848 446.959 412.209 445.858 412.828 445.429C413.688 444.827 414.461 445.79 415.166 446.34C418.261 448.729 421.647 449.314 425.343 448.007C425.532 447.939 425.739 447.904 426.169 447.784L426.134 447.801Z" fill="white" /><path id="Vector_10" d="M472.808 397.568C473.186 398.737 473.565 399.889 473.926 401.058C474.527 403.018 473.891 404.634 472.516 406.043C472.052 406.525 471.502 406.92 471.055 407.402C469.336 409.207 467.066 409.052 464.883 409.172C462.201 409.327 459.502 409.396 456.82 409.464C454.62 409.533 453.073 408.141 453.107 405.957C453.176 402.502 453.451 399.047 453.52 395.608C453.554 393.786 454.431 392.531 455.961 391.912C458.866 390.743 459.64 388.835 458.969 385.844C458.471 383.609 458.488 381.254 458.333 378.95C458.196 377.025 458.969 376.389 460.809 376.973C462.545 377.523 464.23 378.211 465.932 378.847C466.894 379.208 467.015 380.05 466.998 380.927C466.912 385.397 466.808 389.867 466.722 394.336C466.688 396.605 466.671 398.875 466.688 401.144C466.705 403.482 468.098 405.184 470.401 405.734C471.639 406.026 471.983 405.734 472.017 404.462C472.052 403.001 472.121 401.539 472.224 400.078C472.275 399.253 472.447 398.445 472.567 397.62C472.653 397.603 472.739 397.585 472.825 397.568H472.808Z" fill="white" /><path id="Vector_11" d="M418.673 358.819C419.481 358.132 420.22 357.307 421.132 356.791C424.157 355.106 427.217 353.507 430.312 351.96C433.097 350.568 436.053 350.551 439.028 351.273C442.724 352.166 446.196 353.679 449.48 355.588C453.348 357.822 454.362 361.879 452.11 365.782C451.594 366.659 450.855 367.02 449.824 366.779C439.887 364.441 429.968 362.103 420.031 359.765C419.619 359.662 419.223 359.421 418.828 359.232C418.776 359.095 418.742 358.957 418.69 358.819H418.673Z" fill="white" /><path id="Vector_12" d="M354.963 499.718C354.98 502.262 354.688 504.893 354.017 507.454C353.656 508.829 352.436 509.379 351.043 508.95C348.017 508.021 345.232 508.486 342.465 509.981C341.33 510.6 339.989 510.824 338.476 511.305C338.511 505.855 339.714 500.87 340.419 495.781C342.826 497.139 344.923 498.876 347.313 499.529C349.668 500.165 352.332 499.701 354.963 499.718Z" fill="white" /><path id="Vector_13" d="M361.409 384.245C364.83 378.933 366.464 372.83 368.853 367.054C369.713 364.991 370.761 362.997 371.724 360.986C371.862 360.693 372.068 360.418 372.377 359.954C372.343 361.157 372.309 362.137 372.274 363.1C372.205 365.025 372.927 366.641 374.251 368.017C376.641 370.492 376.744 371.214 374.647 373.931C371.948 377.42 369.163 380.841 366.326 384.228C364.607 386.274 363.352 386.222 361.409 384.228V384.245Z" fill="white" /><path id="Vector_14" d="M428.111 438.294C427.87 440.374 427.716 442.248 427.406 444.087C427.183 445.48 425.979 446.013 424.845 446.477C420.719 448.179 415.441 446.236 413.396 442.265C413.206 441.887 413.086 441.406 413.12 440.976C413.327 438.827 413.602 436.678 413.877 434.529C413.911 434.254 414.118 434.013 414.238 433.756C414.479 433.91 414.754 434.031 414.943 434.254C415.785 435.217 416.542 436.3 417.47 437.194C420.341 439.944 423.366 440.409 427.011 438.775C427.303 438.655 427.578 438.518 428.094 438.277L428.111 438.294Z" fill="white" /><path id="Vector_15" d="M418.008 201C411.616 203.515 405.849 206.869 401.055 211.9C394.802 218.467 393.482 225.873 396.678 234.048C397.512 236.214 399.527 237.891 401.264 239.638C402.792 241.175 404.599 242.502 405.78 244.598C403.07 242.712 400.361 240.825 397.651 238.939C397.304 239.009 396.956 239.079 396.678 239.149C397.304 241.524 397.998 243.9 398.624 246.205C399.04 247.743 399.735 249.21 400.013 250.747C401.82 261.996 405.016 272.686 412.866 281.419C415.993 284.913 419.536 287.428 424.608 286.939C428.29 286.59 431.208 285.053 433.223 281.909C439.059 272.826 442.116 262.834 442.325 252.074C441.352 253.192 440.101 254.17 439.407 255.498C438.642 256.826 438.712 258.782 437.739 259.76C436.141 261.297 433.918 262.136 432.112 263.533C429.124 265.769 426.553 266.398 423.913 262.974C422.385 261.018 420.926 262.485 420.092 263.882C418.772 266.188 417.243 266.607 415.02 265.21C414.048 264.651 412.936 264.092 411.824 263.882C408.073 263.114 405.919 260.948 404.946 257.175C404.529 255.428 402.931 254.031 402.097 252.773C408.073 254.45 413.77 256.197 419.606 257.664C421.412 258.083 423.566 258.083 425.372 257.524C432.112 255.568 438.226 252.424 443.367 247.463C446.91 244.039 447.049 243.271 446.285 237.751C442.95 240.266 439.685 242.712 436.419 245.157C436.28 244.948 436.072 244.808 435.933 244.598C438.087 242.712 440.171 240.756 442.325 238.939C449.481 233 449.759 220.703 443.784 213.786C438.434 207.638 431.973 203.515 424.4 201C422.176 201 420.092 201 418.008 201ZM424.261 226.223C424.191 232.232 424.816 238.45 421.898 244.389C418.772 238.59 419.119 232.232 418.633 226.223C420.578 226.223 422.246 226.223 424.261 226.223ZM434.126 224.616C433.918 231.463 432.459 237.611 427.943 242.782C428.499 236.424 429.124 230.066 429.68 223.638C430.861 223.917 432.32 224.197 434.126 224.616ZM412.033 224.476C413.214 230.974 414.395 237.262 415.715 244.529C410.365 238.799 408.698 232.511 407.725 225.873C409.323 225.314 410.782 224.895 412.033 224.476ZM420.37 204.703C420.856 204.703 421.343 204.633 421.898 204.633C422.593 208.755 423.427 212.878 423.774 217.07C423.844 218.188 422.385 219.376 421.69 220.563C420.856 219.445 419.397 218.397 419.397 217.28C419.397 213.018 419.953 208.895 420.37 204.703ZM427.735 206.939C431.486 210.153 432.39 213.786 432.598 217.978C428.777 217.349 427.665 214.834 427.735 206.939ZM412.727 207.638C413.631 214.974 412.519 218.258 408.906 218.887C408.628 214.834 409.323 211.201 412.727 207.638ZM403.07 229.856C404.807 233.559 406.197 236.703 407.725 239.987C402.723 237.821 402.028 236.424 403.07 229.856ZM435.238 239.079C436.628 235.166 437.878 231.882 439.129 228.389C440.727 234.956 440.518 235.655 435.238 239.079ZM443.089 224.266C442.464 224.406 441.908 224.476 441.283 224.616C440.866 221.961 440.449 219.236 440.032 216.581C440.518 216.511 441.005 216.371 441.491 216.301C442.047 218.956 442.603 221.611 443.089 224.266ZM399.805 218.188C400.291 218.258 400.777 218.328 401.264 218.328C401.055 221.052 400.847 223.707 400.638 226.432C400.083 226.363 399.527 226.293 398.971 226.223C399.249 223.568 399.527 220.843 399.805 218.188Z" fill="white" /></g><defs><radialGradient id="paint0_radial_1098_756" cx="0" cy="0" r="1" gradientUnits="userSpaceOnUse" gradientTransform="translate(800 -5.07397e-05) rotate(135.56) scale(596.14)"><stop stop-color="#354053" /><stop offset="1" stop-color="#171F2D" /></radialGradient><linearGradient id="paint1_linear_1098_756" x1="491" y1="566" x2="26.2102" y2="566" gradientUnits="userSpaceOnUse"><stop offset="0.142" stop-color="#21293A" /><stop offset="1" stop-color="#21293A" stop-opacity="0" /></linearGradient></defs><g id="Group Text"><text id="UNI/WETH" fill="#F3F4F6" xml:space="preserve" style="white-space: pre" font-family="Arial, sans-serif" font-size="48" font-weight="800" letter-spacing="0em"><tspan x="55" y="102">UNI/WETH</tspan></text><text id="ID #1" fill="#F3F4F6" xml:space="preserve" style="white-space: pre" font-family="Arial, sans-serif" font-size="28" font-weight="500" letter-spacing="0em"><tspan x="55" y="740">ID #1</tspan></text><text id="0 MIN  :  1000 MAX TICK" fill="#F3F4F6" xml:space="preserve" style="white-space: pre" font-family="Arial, sans-serif" font-size="28" font-weight="500" letter-spacing="0em"><tspan x="360" y="740">0 MIN  :  1000 MAX TICK</tspan></text><rect id="Rectangle 174" x="548" y="56" width="196" height="61" rx="8" fill="#F3F4F6" /><text id="CL10" fill="#231E33" xml:space="preserve" style="white-space: pre" font-family="Arial, sans-serif" font-size="28" font-weight="500" letter-spacing="0em"><tspan x="598" y="97">CL10</tspan></text></g></svg>"}"`; +exports[`NFTDescriptor #constructTokenURI snapshot matches 1`] = `"data:application/json;base64,{"name":"CL - UNI/WETH - 1.0000<>1.1052", "description":"This NFT represents a liquidity position in a CL UNI-WETH pool. The owner of this NFT can modify or redeem the position.\n\nPool Address: 0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\nUNI Address: 0xabcdeabcdefabcdefabcdefabcdefabcdefabcdf\nWETH Address: 0x1234567890123456789123456789012345678901\nTick Spacing: 10\nToken ID: 1\n\n⚠️ DISCLAIMER: Due diligence is imperative when assessing this NFT. Make sure token addresses match the expected tokens, as token symbols may be imitated.", "image": "data:image/svg+xml;base64,<svg width="290" height="500" viewBox="0 0 290 500" xmlns="http://www.w3.org/2000/svg" xmlns:xlink='http://www.w3.org/1999/xlink'><defs><filter id="f1"><feImage result="p0" xlink:href="data:image/svg+xml;base64,PHN2ZyB3aWR0aD0nMjkwJyBoZWlnaHQ9JzUwMCcgdmlld0JveD0nMCAwIDI5MCA1MDAnIHhtbG5zPSdodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Zyc+PHJlY3Qgd2lkdGg9JzI5MHB4JyBoZWlnaHQ9JzUwMHB4JyBmaWxsPScjYWJjZGVhJy8+PC9zdmc+"/><feImage result="p1" xlink:href="data:image/svg+xml;base64,PHN2ZyB3aWR0aD0nMjkwJyBoZWlnaHQ9JzUwMCcgdmlld0JveD0nMCAwIDI5MCA1MDAnIHhtbG5zPSdodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Zyc+PGNpcmNsZSBjeD0nMjY4JyBjeT0nMjU1JyByPScxMjBweCcgZmlsbD0nIzEyMzQ1NicvPjwvc3ZnPg=="/><feImage result="p2" xlink:href="data:image/svg+xml;base64,PHN2ZyB3aWR0aD0nMjkwJyBoZWlnaHQ9JzUwMCcgdmlld0JveD0nMCAwIDI5MCA1MDAnIHhtbG5zPSdodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Zyc+PGNpcmNsZSBjeD0nMjA2JyBjeT0nMTUyJyByPScxMjBweCcgZmlsbD0nI2ZhYmNkZicvPjwvc3ZnPg==" /><feImage result="p3" xlink:href="data:image/svg+xml;base64,PHN2ZyB3aWR0aD0nMjkwJyBoZWlnaHQ9JzUwMCcgdmlld0JveD0nMCAwIDI5MCA1MDAnIHhtbG5zPSdodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Zyc+PGNpcmNsZSBjeD0nMjQwJyBjeT0nMzA2JyByPScxMDBweCcgZmlsbD0nIzY3ODkwMScvPjwvc3ZnPg==" /><feBlend mode="overlay" in="p0" in2="p1" /><feBlend mode="exclusion" in2="p2" /><feBlend mode="overlay" in2="p3" result="blendOut" /><feGaussianBlur in="blendOut" stdDeviation="42" /></filter> <clipPath id="corners"><rect width="290" height="500" rx="42" ry="42" /></clipPath><path id="text-path-a" d="M40 12 H250 A28 28 0 0 1 278 40 V460 A28 28 0 0 1 250 488 H40 A28 28 0 0 1 12 460 V40 A28 28 0 0 1 40 12 z" /><path id="minimap" d="M234 444C234 457.949 242.21 463 253 463" /><filter id="top-region-blur"><feGaussianBlur in="SourceGraphic" stdDeviation="24" /></filter><linearGradient id="grad-up" x1="1" x2="0" y1="1" y2="0"><stop offset="0.0" stop-color="white" stop-opacity="1" /><stop offset=".9" stop-color="white" stop-opacity="0" /></linearGradient><linearGradient id="grad-down" x1="0" x2="1" y1="0" y2="1"><stop offset="0.0" stop-color="white" stop-opacity="1" /><stop offset="0.9" stop-color="white" stop-opacity="0" /></linearGradient><mask id="fade-up" maskContentUnits="objectBoundingBox"><rect width="1" height="1" fill="url(#grad-up)" /></mask><mask id="fade-down" maskContentUnits="objectBoundingBox"><rect width="1" height="1" fill="url(#grad-down)" /></mask><mask id="none" maskContentUnits="objectBoundingBox"><rect width="1" height="1" fill="white" /></mask><linearGradient id="grad-symbol"><stop offset="0.7" stop-color="white" stop-opacity="1" /><stop offset=".95" stop-color="white" stop-opacity="0" /></linearGradient><mask id="fade-symbol" maskContentUnits="userSpaceOnUse"><rect width="290px" height="200px" fill="url(#grad-symbol)" /></mask></defs><g clip-path="url(#corners)"><rect fill="abcdea" x="0px" y="0px" width="290px" height="500px" /><rect style="filter: url(#f1)" x="0px" y="0px" width="290px" height="500px" /> <g style="filter:url(#top-region-blur); transform:scale(1.5); transform-origin:center top;"><rect fill="none" x="0px" y="0px" width="290px" height="500px" /><ellipse cx="50%" cy="0px" rx="180px" ry="120px" fill="#000" opacity="0.85" /></g><rect x="0" y="0" width="290" height="500" rx="42" ry="42" fill="rgba(0,0,0,0)" stroke="rgba(255,255,255,0.2)" /></g><text text-rendering="optimizeSpeed"><textPath startOffset="-100%" fill="white" font-family="'Courier New', monospace" font-size="10px" xlink:href="#text-path-a">0x1234567890123456789123456789012345678901 • WETH <animate additive="sum" attributeName="startOffset" from="0%" to="100%" begin="0s" dur="30s" repeatCount="indefinite" /></textPath> <textPath startOffset="0%" fill="white" font-family="'Courier New', monospace" font-size="10px" xlink:href="#text-path-a">0x1234567890123456789123456789012345678901 • WETH <animate additive="sum" attributeName="startOffset" from="0%" to="100%" begin="0s" dur="30s" repeatCount="indefinite" /> </textPath><textPath startOffset="50%" fill="white" font-family="'Courier New', monospace" font-size="10px" xlink:href="#text-path-a">0xabcdeabcdefabcdefabcdefabcdefabcdefabcdf • UNI <animate additive="sum" attributeName="startOffset" from="0%" to="100%" begin="0s" dur="30s" repeatCount="indefinite" /></textPath><textPath startOffset="-50%" fill="white" font-family="'Courier New', monospace" font-size="10px" xlink:href="#text-path-a">0xabcdeabcdefabcdefabcdefabcdefabcdefabcdf • UNI <animate additive="sum" attributeName="startOffset" from="0%" to="100%" begin="0s" dur="30s" repeatCount="indefinite" /></textPath></text><g mask="url(#fade-symbol)"><rect fill="none" x="0px" y="0px" width="290px" height="200px" /> <text y="70px" x="32px" fill="white" font-family="'Courier New', monospace" font-weight="200" font-size="36px">UNI/WETH</text><text y="115px" x="32px" fill="white" font-family="'Courier New', monospace" font-weight="200" font-size="36px">10</text></g><rect x="16" y="16" width="258" height="468" rx="26" ry="26" fill="rgba(0,0,0,0)" stroke="rgba(255,255,255,0.2)" /><g mask="url(#fade-down)" style="transform:translate(72px,189px)"><rect x="-16px" y="-16px" width="180px" height="180px" fill="none" /><path d="M1 1C9 81 65 137 145 145" stroke="rgba(0,0,0,0.3)" stroke-width="32px" fill="none" stroke-linecap="round" /></g><g mask="url(#fade-down)" style="transform:translate(72px,189px)"><rect x="-16px" y="-16px" width="180px" height="180px" fill="none" /><path d="M1 1C9 81 65 137 145 145" stroke="rgba(255,255,255,1)" fill="none" stroke-linecap="round" /></g><circle cx="73px" cy="190px" r="4px" fill="white" /><circle cx="73px" cy="190px" r="24px" fill="none" stroke="white" /> <g style="transform:translate(29px, 384px)"><rect width="63px" height="26px" rx="8px" ry="8px" fill="rgba(0,0,0,0.6)" /><text x="12px" y="17px" font-family="'Courier New', monospace" font-size="12px" fill="white"><tspan fill="rgba(255,255,255,0.6)">ID: </tspan>1</text></g> <g style="transform:translate(29px, 414px)"><rect width="105px" height="26px" rx="8px" ry="8px" fill="rgba(0,0,0,0.6)" /><text x="12px" y="17px" font-family="'Courier New', monospace" font-size="12px" fill="white"><tspan fill="rgba(255,255,255,0.6)">Min Tick: </tspan>0</text></g> <g style="transform:translate(29px, 444px)"><rect width="126px" height="26px" rx="8px" ry="8px" fill="rgba(0,0,0,0.6)" /><text x="12px" y="17px" font-family="'Courier New', monospace" font-size="12px" fill="white"><tspan fill="rgba(255,255,255,0.6)">Max Tick: </tspan>1000</text></g><g style="transform:translate(226px, 433px)"><rect width="36px" height="36px" rx="8px" ry="8px" fill="none" stroke="rgba(255,255,255,0.2)" /><path stroke-linecap="round" d="M8 9C8.00004 22.9494 16.2099 28 27 28" fill="none" stroke="white" /><circle style="transform:translate3d(13px, 23px, 0px)" cx="0px" cy="0px" r="4px" fill="white"/></g><g style="transform:translate(226px, 392px)"><rect width="36px" height="36px" rx="8px" ry="8px" fill="none" stroke="rgba(255,255,255,0.2)" /><g><path style="transform:translate(6px,6px)" d="M12 0L12.6522 9.56587L18 1.6077L13.7819 10.2181L22.3923 6L14.4341 11.3478L24 12L14.4341 12.6522L22.3923 18L13.7819 13.7819L18 22.3923L12.6522 14.4341L12 24L11.3478 14.4341L6 22.3923L10.2181 13.7819L1.6077 18L9.56587 12.6522L0 12L9.56587 11.3478L1.6077 6L10.2181 10.2181L6 1.6077L11.3478 9.56587L12 0Z" fill="white" /><animateTransform attributeName="transform" type="rotate" from="0 18 18" to="360 18 18" dur="10s" repeatCount="indefinite"/></g></g></svg>"}"`; -exports[`NFTDescriptor #svgImage matches the current snapshot 1`] = `"UNI/WETHID #123-1000 MIN : 2000 MAX TICKCL60"`; +exports[`NFTDescriptor #svgImage matches the current snapshot 1`] = `" 0xabcdeabcdefabcdefabcdefabcdefabcdefabcdf • WETH 0xabcdeabcdefabcdefabcdefabcdefabcdefabcdf • WETH 0x1234567890123456789123456789012345678901 • UNI 0x1234567890123456789123456789012345678901 • UNI UNI/WETH60 ID: 123 Min Tick: -1000 Max Tick: 2000"`; diff --git a/test/periphery/__snapshots__/NFTDescriptor.svg b/test/periphery/__snapshots__/NFTDescriptor.svg index 9c03b5b..e053dec 100644 --- a/test/periphery/__snapshots__/NFTDescriptor.svg +++ b/test/periphery/__snapshots__/NFTDescriptor.svg @@ -1 +1 @@ -UNI/WETHID #123-1000 MIN : 2000 MAX TICKCL60 \ No newline at end of file + 0xabcdeabcdefabcdefabcdefabcdefabcdefabcdf • WETH 0xabcdeabcdefabcdefabcdefabcdefabcdefabcdf • WETH 0x1234567890123456789123456789012345678901 • UNI 0x1234567890123456789123456789012345678901 • UNI UNI/WETH60 ID: 123 Min Tick: -1000 Max Tick: 2000 \ No newline at end of file