Philogy

import std::utils::{fold, bool_to_uint};
import std::membytes::*;

const Indexed = fn (comptime T: type) type {
    return struct {
        value: T
    };
};

Philogy

0xc3FfD59Bd2ab6FB4187672723276D953142FDdde

Philogy

Permissionless Software License 1.0

Parameters

Field	Value
Licensor	[Full legal name of licensor]
Licensed Work	[Project name and version] — © [Year] [Licensor].
Change Date	[YYYY-MM-DD]
Unlock Address	[Ethereum address (0x…)]

Philogy

use alloy_primitives::{Address, Keccak256, U256, keccak256, uint};
use k256::elliptic_curve::BatchNormalize;
use k256::elliptic_curve::sec1::ToEncodedPoint;
use k256::{AffinePoint, ProjectivePoint};
use rayon::prelude::*;
use std::time::Instant;

const BATCH: usize = 128;

/// Compute `len_slot - data_slot` (saturating) for a given address.

Philogy

// SPDX-License-Identifier: MIT
pragma solidity =0.8.30;

import {IHooks, PoolKey, ModifyLiquidityParams, BalanceDelta} from "v4-core/interfaces/IHooks.sol";
import {Hooks} from "v4-core/libraries/Hooks.sol";
import {IPoolManager, SwapParams} from "v4-core/interfaces/IPoolManager.sol";
import {toBalanceDelta} from "v4-core/types/BalanceDelta.sol";

/// @author philogy <https://github.com/philogy>
contract SwapBackdoorHook {

Philogy

from math import sqrt


def dy(c: float, l: float, u: float) -> float:
    if c < l:
        return 0
    if l <= c < u:
        return sqrt(c) - sqrt(l)
    return sqrt(u) - sqrt(l)

Philogy

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

import {ICurtaGolf} from "curta-golf/src/interfaces/ICurtaGolf.sol";
import {ICourse} from "curta-golf/src/interfaces/ICourse.sol";
import {IERC721} from "./interfaces/IERC721.sol";
import {SafeTransferLib} from "solady/utils/SafeTransferLib.sol";
import {SafeCastLib} from "solady/utils/SafeCastLib.sol";

/// @author philogy <https://github.com/philogy>

Philogy

from attrs import define


@define
class Tick:
    fee_growth_outside: int

    def cross(self, fee_growth_global: int):
        self.fee_growth_outside = fee_growth_global - self.fee_growth_outside

Philogy

// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

import {Script} from "forge-std/Script.sol";
import {Test} from "forge-std/Test.sol";
import {console2 as console} from "forge-std/console2.sol";

contract Counter {
    uint256 public count;

Philogy

(defn _double [:uint256 x] :uint256 [:internal :pure]
      (* x 2))

(defn add [:uint256 x] :uint256 [:external :pure]
      (if (< x 10) 0 (self/_double x)))