Contract

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

interface IERC20V2 {
    function approve(address spender, uint256 amount) external returns (bool);
    function transfer(address to, uint256 amount) external returns (bool);
}

interface IERC1271V2 {
    function isValidSignature(bytes32 hash, bytes calldata signature) external view returns (bytes4 magicValue);
}

interface IUniswapV3PoolV2 {
    function slot0() external view returns (uint160, int24);
    function liquidity() external view returns (uint128);
}

interface INonfungiblePositionManagerV2 {
    struct MintParams {
        address token0; address token1; uint24 fee; int24 tickLower; int24 tickUpper;
        uint256 amount0Desired; uint256 amount1Desired; uint256 amount0Min; uint256 amount1Min;
        address recipient; uint256 deadline;
    }
    function createAndInitializePoolIfNecessary(address, address, uint24, uint160) external payable returns (address);
    function mint(MintParams calldata) external payable returns (uint256, uint128, uint256, uint256);
}

contract SilkPadTokenV2 is IERC20V2 {
    string public name;
    string public symbol;
    uint8 public constant decimals = 18;
    uint256 public immutable totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;
    event Transfer(address indexed from, address indexed to, uint256 amount);
    event Approval(address indexed owner, address indexed spender, uint256 amount);

    constructor(string memory name_, string memory symbol_, uint256 supply_, address receiver_) {
        name = name_; symbol = symbol_; totalSupply = supply_; balanceOf[receiver_] = supply_;
        emit Transfer(address(0), receiver_, supply_);
    }
    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount; emit Approval(msg.sender, spender, amount); return true;
    }
    function transfer(address to, uint256 amount) external returns (bool) { _transfer(msg.sender, to, amount); return true; }
    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        uint256 permitted = allowance[from][msg.sender];
        if (permitted != type(uint256).max) { require(permitted >= amount, "ALLOWANCE"); allowance[from][msg.sender] = permitted - amount; }
        _transfer(from, to, amount); return true;
    }
    function _transfer(address from, address to, uint256 amount) internal {
        require(to != address(0), "ZERO_ADDRESS"); require(balanceOf[from] >= amount, "BALANCE");
        unchecked { balanceOf[from] -= amount; balanceOf[to] += amount; }
        emit Transfer(from, to, amount);
    }
}

/// @notice Timelocked allowlist for canonical quote assets. A delayed two-step
/// update prevents an operator key from instantly substituting a fake stock.
contract SilkQuoteRegistryV2 {
    struct Quote { bytes12 symbol; uint8 decimals; uint64 enabledAt; bool stockToken; bool disabled; }
    uint64 public immutable updateDelay;
    address public owner;
    address public pendingOwner;
    mapping(address => Quote) private quotes;
    mapping(address => Quote) private pendingQuotes;
    event QuoteScheduled(address indexed token, bytes12 symbol, uint8 decimals, bool stockToken, uint64 enabledAt);
    event QuoteActivated(address indexed token, bytes12 symbol, uint8 decimals, bool stockToken);
    event QuoteDisabled(address indexed token);
    event OwnershipTransferStarted(address indexed pendingOwner);
    event OwnershipTransferred(address indexed owner);

    constructor(address owner_, uint64 updateDelay_) {
        require(owner_ != address(0), "ZERO_OWNER"); require(updateDelay_ >= 1 hours && updateDelay_ <= 30 days, "UPDATE_DELAY");
        owner = owner_; updateDelay = updateDelay_;
    }
    modifier onlyOwner() { require(msg.sender == owner, "OWNER_ONLY"); _; }

    function scheduleQuote(address token, bytes12 symbol, uint8 decimals, bool stockToken) external onlyOwner {
        require(token.code.length != 0, "INVALID_TOKEN"); require(symbol != bytes12(0), "EMPTY_SYMBOL"); require(decimals <= 18, "DECIMALS");
        uint64 enabledAt = uint64(block.timestamp) + updateDelay;
        pendingQuotes[token] = Quote(symbol, decimals, enabledAt, stockToken, false);
        emit QuoteScheduled(token, symbol, decimals, stockToken, enabledAt);
    }
    function activateQuote(address token) external {
        Quote memory item = pendingQuotes[token];
        require(item.symbol != bytes12(0) && block.timestamp >= item.enabledAt, "QUOTE_DELAY");
        quotes[token] = Quote(item.symbol, item.decimals, item.enabledAt, item.stockToken, false);
        delete pendingQuotes[token]; emit QuoteActivated(token, item.symbol, item.decimals, item.stockToken);
    }
    function disableQuote(address token) external onlyOwner { quotes[token].disabled = true; emit QuoteDisabled(token); }
    function quote(address token) external view returns (Quote memory) { return quotes[token]; }
    function pendingQuote(address token) external view returns (Quote memory) { return pendingQuotes[token]; }
    function isEnabled(address token) public view returns (bool) {
        Quote memory item = quotes[token]; return item.symbol != bytes12(0) && !item.disabled && block.timestamp >= item.enabledAt;
    }
    function transferOwnership(address next) external onlyOwner { require(next != address(0), "ZERO_OWNER"); pendingOwner = next; emit OwnershipTransferStarted(next); }
    function acceptOwnership() external { require(msg.sender == pendingOwner, "PENDING_OWNER_ONLY"); owner = msg.sender; pendingOwner = address(0); emit OwnershipTransferred(msg.sender); }
}

/// @notice EIP-1271 adapter that gives the factory an immutable verification
/// address while allowing a governance-controlled, delayed signer rotation and
/// immediate incident pause.
contract SilkPriceAuthorityV2 is IERC1271V2 {
    bytes4 private constant MAGIC = IERC1271V2.isValidSignature.selector;
    uint64 public immutable updateDelay;
    address public owner;
    address public pendingOwner;
    address public signer;
    address public pendingSigner;
    uint64 public signerActivatesAt;
    bool public paused;
    event SignerScheduled(address indexed signer, uint64 activatesAt);
    event SignerActivated(address indexed signer);
    event PauseChanged(bool paused);
    event OwnershipTransferStarted(address indexed pendingOwner);
    event OwnershipTransferred(address indexed owner);

    constructor(address owner_, address signer_, uint64 updateDelay_) {
        require(owner_ != address(0) && signer_ != address(0), "ZERO_ADDRESS");
        require(updateDelay_ >= 1 hours && updateDelay_ <= 30 days, "UPDATE_DELAY");
        owner = owner_; signer = signer_; updateDelay = updateDelay_;
    }
    modifier onlyOwner() { require(msg.sender == owner, "OWNER_ONLY"); _; }
    function scheduleSigner(address next) external onlyOwner {
        require(next != address(0), "ZERO_SIGNER"); pendingSigner = next; signerActivatesAt = uint64(block.timestamp) + updateDelay;
        emit SignerScheduled(next, signerActivatesAt);
    }
    function activateSigner() external {
        require(pendingSigner != address(0) && block.timestamp >= signerActivatesAt, "SIGNER_DELAY");
        signer = pendingSigner; pendingSigner = address(0); signerActivatesAt = 0; emit SignerActivated(signer);
    }
    function setPaused(bool value) external onlyOwner { paused = value; emit PauseChanged(value); }
    function transferOwnership(address next) external onlyOwner { require(next != address(0), "ZERO_OWNER"); pendingOwner = next; emit OwnershipTransferStarted(next); }
    function acceptOwnership() external { require(msg.sender == pendingOwner, "PENDING_OWNER_ONLY"); owner = msg.sender; pendingOwner = address(0); emit OwnershipTransferred(msg.sender); }
    function isValidSignature(bytes32 digest, bytes calldata signature) external view returns (bytes4) {
        return !paused && _recover(digest, signature) == signer ? MAGIC : bytes4(0xffffffff);
    }
    function _recover(bytes32 digest, bytes calldata signature) private pure returns (address) {
        if (signature.length != 65) return address(0); bytes32 r; bytes32 s; uint8 v;
        assembly { r := calldataload(signature.offset) s := calldataload(add(signature.offset, 32)) v := byte(0, calldataload(add(signature.offset, 64))) }
        if (v < 27) v += 27; if (v != 27 && v != 28) return address(0);
        if (uint256(s) > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) return address(0);
        return ecrecover(digest, v, r, s);
    }
}

/// @notice Creates fixed-supply tokens with token-only, permanently locked
/// Uniswap V3 liquidity against an approved quote asset. Opening price and
/// range are authorized offchain and bound to every launch field, caller,
/// chain, factory, nonce and deadline.
contract SilkPadMultiQuoteFactoryV2 {
    struct Launch {
        address token; address quoteToken; address pool; address creator; string name; string symbol;
        string imageURI; string description; uint256 totalSupply; uint256 creatorAllocation; uint256 createdAt;
    }
    struct Authorization {
        address creator; address quoteToken; bytes32 launchHash;
        uint160 token0SqrtPriceX96; int24 token0TickLower; int24 token0StartTick; int24 token0TickUpper;
        uint160 token1SqrtPriceX96; int24 token1TickLower; int24 token1StartTick; int24 token1TickUpper;
        uint64 deadline; uint256 nonce;
    }

    bytes32 private constant AUTH_TYPEHASH = keccak256("SilkPadLaunch(address creator,address quoteToken,bytes32 launchHash,uint160 token0SqrtPriceX96,int24 token0TickLower,int24 token0StartTick,int24 token0TickUpper,uint160 token1SqrtPriceX96,int24 token1TickLower,int24 token1StartTick,int24 token1TickUpper,uint64 deadline,uint256 nonce,uint256 chainId,address factory)");
    INonfungiblePositionManagerV2 public immutable positionManager;
    SilkQuoteRegistryV2 public immutable quoteRegistry;
    address public immutable priceSigner;
    address payable public immutable feeReceiver;
    uint24 public immutable poolFee;
    int24 public immutable tickSpacing;
    uint256 public immutable launchFee;
    uint64 public immutable maxAuthorizationLifetime;
    Launch[] private launches;
    mapping(uint256 => uint256) public positionIdByLaunch;
    mapping(address => mapping(uint256 => bool)) public nonceUsed;
    uint256 public accruedFees;
    bool private entered;
    event LaunchCreated(uint256 indexed launchId, address indexed token, address indexed quoteToken, address pool, address creator, uint256 positionId, uint128 liquidity);

    modifier nonReentrant() { require(!entered, "REENTRANCY"); entered = true; _; entered = false; }
    constructor(address manager, address registry, address signer, address payable receiver, uint24 fee, int24 spacing, uint256 feeWei, uint64 maxLifetime) {
        require(manager.code.length != 0 && registry.code.length != 0, "INVALID_CONTRACT");
        require(signer != address(0) && receiver != address(0), "ZERO_ADDRESS");
        require(spacing > 0 && fee != 0 && maxLifetime >= 30 && maxLifetime <= 30 minutes, "CONFIG");
        positionManager = INonfungiblePositionManagerV2(manager); quoteRegistry = SilkQuoteRegistryV2(registry);
        priceSigner = signer; feeReceiver = receiver; poolFee = fee; tickSpacing = spacing; launchFee = feeWei; maxAuthorizationLifetime = maxLifetime;
    }
    function getLaunchCount() external view returns (uint256) { return launches.length; }
    function getLaunch(uint256 id) external view returns (Launch memory) { return launches[id]; }
    function launchHash(string calldata name, string calldata symbol, string calldata imageURI, string calldata description, uint256 supply, uint256 creatorBps) public pure returns (bytes32) {
        return keccak256(abi.encode(keccak256(bytes(name)), keccak256(bytes(symbol)), keccak256(bytes(imageURI)), keccak256(bytes(description)), supply, creatorBps));
    }
    function authorizationBodyHash(Authorization calldata auth) public view returns (bytes32) {
        return keccak256(abi.encode(AUTH_TYPEHASH, auth.creator, auth.quoteToken, auth.launchHash,
            auth.token0SqrtPriceX96, auth.token0TickLower, auth.token0StartTick, auth.token0TickUpper,
            auth.token1SqrtPriceX96, auth.token1TickLower, auth.token1StartTick, auth.token1TickUpper,
            auth.deadline, auth.nonce, block.chainid, address(this)));
    }
    function authorizationDigest(Authorization calldata auth) public view returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", authorizationBodyHash(auth)));
    }
    function createLaunch(
        string calldata name, string calldata symbol, string calldata imageURI, string calldata description,
        uint256 totalSupply, uint256 creatorAllocationBps, Authorization calldata auth, bytes calldata signature
    ) external payable nonReentrant returns (uint256 launchId, address tokenAddress, address pool, uint256 positionId) {
        require(msg.value == launchFee, "LAUNCH_FEE"); require(quoteRegistry.isEnabled(auth.quoteToken), "QUOTE_DISABLED");
        require(auth.creator == msg.sender, "CREATOR"); require(auth.launchHash == launchHash(name, symbol, imageURI, description, totalSupply, creatorAllocationBps), "LAUNCH_HASH");
        require(auth.deadline >= block.timestamp && auth.deadline <= block.timestamp + maxAuthorizationLifetime, "AUTH_DEADLINE");
        require(!nonceUsed[msg.sender][auth.nonce], "NONCE_USED"); require(_validPriceSignature(authorizationDigest(auth), signature), "PRICE_SIGNATURE");
        require(auth.token0SqrtPriceX96 != 0 && auth.token1SqrtPriceX96 != 0, "PRICE_RANGE");
        // A token0-only position starts at its lower boundary; a token1-only
        // position starts at its upper boundary. Requiring an interior start
        // tick would silently require some of the quote asset at mint time.
        require(auth.token0TickLower == auth.token0StartTick && auth.token0StartTick < auth.token0TickUpper, "PRICE_RANGE");
        require(auth.token1TickLower < auth.token1StartTick && auth.token1StartTick == auth.token1TickUpper, "PRICE_RANGE");
        require(auth.token0TickLower % tickSpacing == 0 && auth.token0StartTick % tickSpacing == 0 && auth.token0TickUpper % tickSpacing == 0, "TICK_SPACING");
        require(auth.token1TickLower % tickSpacing == 0 && auth.token1StartTick % tickSpacing == 0 && auth.token1TickUpper % tickSpacing == 0, "TICK_SPACING");
        require(bytes(name).length != 0 && bytes(name).length <= 48, "NAME"); require(_validSymbol(symbol), "SYMBOL");
        require(bytes(imageURI).length <= 500 && bytes(description).length <= 500, "METADATA");
        require(totalSupply > 0 && totalSupply <= type(uint128).max, "SUPPLY"); require(creatorAllocationBps <= 2_000, "CREATOR_ALLOCATION");
        nonceUsed[msg.sender][auth.nonce] = true;
        SilkPadTokenV2 token = new SilkPadTokenV2(name, symbol, totalSupply, address(this)); tokenAddress = address(token);
        uint256 allocation = totalSupply * creatorAllocationBps / 10_000; uint256 liquidityTokens = totalSupply - allocation;
        if (allocation != 0) require(token.transfer(msg.sender, allocation), "CREATOR_TRANSFER");
        require(token.approve(address(positionManager), liquidityTokens), "APPROVE");
        bool launchedIsToken0 = tokenAddress < auth.quoteToken;
        address token0 = launchedIsToken0 ? tokenAddress : auth.quoteToken; address token1 = launchedIsToken0 ? auth.quoteToken : tokenAddress;
        uint160 expectedPrice = launchedIsToken0 ? auth.token0SqrtPriceX96 : auth.token1SqrtPriceX96;
        int24 expectedTick = launchedIsToken0 ? auth.token0StartTick : auth.token1StartTick;
        int24 lowerTick = launchedIsToken0 ? auth.token0TickLower : auth.token1TickLower;
        int24 upperTick = launchedIsToken0 ? auth.token0TickUpper : auth.token1TickUpper;
        pool = positionManager.createAndInitializePoolIfNecessary(token0, token1, poolFee, expectedPrice);
        (uint160 actualPrice, int24 actualTick) = IUniswapV3PoolV2(pool).slot0();
        require(actualPrice == expectedPrice && actualTick == expectedTick, "POOL_PRICE"); require(IUniswapV3PoolV2(pool).liquidity() == 0, "POOL_NOT_EMPTY");
        INonfungiblePositionManagerV2.MintParams memory params = INonfungiblePositionManagerV2.MintParams({
            token0: token0, token1: token1, fee: poolFee, tickLower: lowerTick, tickUpper: upperTick,
            amount0Desired: launchedIsToken0 ? liquidityTokens : 0, amount1Desired: launchedIsToken0 ? 0 : liquidityTokens,
            amount0Min: 0, amount1Min: 0, recipient: address(this), deadline: block.timestamp
        });
        uint128 liquidity; uint256 amount0; uint256 amount1; (positionId, liquidity, amount0, amount1) = positionManager.mint(params);
        require(liquidity != 0, "NO_LIQUIDITY"); uint256 consumed = launchedIsToken0 ? amount0 : amount1;
        require(consumed != 0 && consumed <= liquidityTokens, "TOKEN_DEPOSIT"); uint256 dust = liquidityTokens - consumed;
        require(dust <= liquidityTokens / 1e12 + 1, "EXCESS_TOKEN_DUST"); require(token.approve(address(positionManager), 0), "REVOKE_APPROVAL");
        if (dust != 0) require(token.transfer(address(0x000000000000000000000000000000000000dEaD), dust), "DUST_BURN");
        launchId = launches.length; launches.push(Launch(tokenAddress, auth.quoteToken, pool, msg.sender, name, symbol, imageURI, description, totalSupply, allocation, block.timestamp));
        positionIdByLaunch[launchId] = positionId; accruedFees += msg.value;
        emit LaunchCreated(launchId, tokenAddress, auth.quoteToken, pool, msg.sender, positionId, liquidity);
    }
    function withdrawFees() external nonReentrant {
        require(msg.sender == feeReceiver, "FEE_RECEIVER_ONLY"); uint256 amount = accruedFees; accruedFees = 0;
        (bool paid,) = feeReceiver.call{value: amount}(""); require(paid, "FEE_TRANSFER");
    }
    function _recover(bytes32 digest, bytes calldata signature) private pure returns (address) {
        if (signature.length != 65) return address(0); bytes32 r; bytes32 s; uint8 v;
        assembly { r := calldataload(signature.offset) s := calldataload(add(signature.offset, 32)) v := byte(0, calldataload(add(signature.offset, 64))) }
        if (v < 27) v += 27; if (v != 27 && v != 28) return address(0);
        if (uint256(s) > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) return address(0);
        return ecrecover(digest, v, r, s);
    }
    function _validPriceSignature(bytes32 digest, bytes calldata signature) private view returns (bool) {
        if (priceSigner.code.length == 0) return _recover(digest, signature) == priceSigner;
        try IERC1271V2(priceSigner).isValidSignature(digest, signature) returns (bytes4 magicValue) {
            return magicValue == IERC1271V2.isValidSignature.selector;
        } catch { return false; }
    }
    function _validSymbol(string calldata value) private pure returns (bool) {
        bytes calldata chars = bytes(value); if (chars.length < 2 || chars.length > 12) return false;
        for (uint256 i; i < chars.length; ++i) { bytes1 c = chars[i]; if (!((c >= 0x41 && c <= 0x5A) || (c >= 0x30 && c <= 0x39))) return false; }
        return true;
    }
}