Comparar texto

Encontre a diferença entre dois arquivos de texto

Editor live

Recolher inalteradas

Sem quebra de linha

Layout

Nível de detalhe

Realce de sintaxe

Diffchecker Desktop A maneira mais segura de usar o Diffchecker. Obtenha o aplicativo Diffchecker Desktop: seus diffs nunca saem do seu computador!Obter Desktop

Differ tlchook

Criado ano passadoO diff nunca expira

15 remoções

Linhas
Total
Removido

Caracteres
Total
Removido

Para continuar usando este recurso, atualize para Diffchecker Pro Ver preços

107 linhas

72 adições

Linhas
Total
Adicionado

Caracteres
Total
Adicionado

Para continuar usando este recurso, atualize para Diffchecker Pro Ver preços

107 linhas

// SPDX-License-Identifier: BUSL-1.1

// This code is made available under the terms and conditions of the Business Source License 1.1 (BUSL-1.1).

// The act of publishing this code is driven by the aim to promote transparency and facilitate its utilization for educational purposes.

pragma solidity 0.8.18;

import { OwnableUpgradeable } from "@openzeppelin-upgradeable/contracts/access/OwnableUpgradeable.sol";

import {OwnableUpgradeable} from "@openzeppelin-upgradeable/contracts/access/OwnableUpgradeable.sol";

import { ITradeServiceHook } from "../services/interfaces/ITradeServiceHook.sol";

import {ITradeServiceHook} from "../services/interfaces/ITradeServiceHook.sol";

import { ITradeService } from "../services/interfaces/ITradeService.sol";

import {ITradeService} from "../services/interfaces/ITradeService.sol";

import { ITradingStaking } from "./interfaces/ITradingStaking.sol";

import {ITradingStaking} from "./interfaces/ITradingStaking.sol";

import { TraderLoyaltyCredit } from "@hmx/tokens/TraderLoyaltyCredit.sol";

import {TraderLoyaltyCredit} from "@hmx/tokens/TraderLoyaltyCredit.sol";

import { TLCStaking } from "@hmx/staking/TLCStaking.sol";

import {TLCStaking} from "@hmx/staking/TLCStaking.sol";

import { FullMath } from "@hmx/libraries/FullMath.sol";

import {FullMath} from "@hmx/libraries/FullMath.sol";

contract TLCHook is ITradeServiceHook, OwnableUpgradeable {

using FullMath for uint256;

error TLCHook_Forbidden();

error TLCHook_BadArgs();

uint32 internal constant BPS = 100_00;

address public tradeService;

address public tlc;

address public tlcStaking;

// mapping weight with the marketIndex

mapping(uint256 marketIndex => uint256 weight) public marketWeights;

mapping(address whitelisted => bool isWhitelisted) public whitelistedCallers;

modifier onlyWhitelistedCaller() {

if (!whitelistedCallers[msg.sender]) revert TLCHook_Forbidden();

}

event LogSetMarketWeight(uint256 marketIndex, uint256 oldWeight, uint256 newWeight);

event LogSetWhitelistedCaller(address indexed caller, bool isWhitelisted);

function initialize(address _tradeService, address _tlc, address _tlcStaking) external initializer {

OwnableUpgradeable.__Ownable_init();

tradeService = _tradeService;

tlc = _tlc;

tlcStaking = _tlcStaking;

// Sanity checks

ITradeService(tradeService).configStorage();

TraderLoyaltyCredit(tlc).symbol();

}

function onIncreasePosition(

address _primaryAccount,

uint256,

uint256 _marketIndex,

uint256 _sizeDelta,

bytes32

) external onlyWhitelistedCaller {

_mintTLC(_primaryAccount, _sizeDelta, _marketIndex);

}

function onDecreasePosition(

address _primaryAccount,

uint256,

uint256 _sizeDelta,

bytes32

) external onlyWhitelistedCaller {

// Do nothing

}

function _mintTLC(address _primaryAccount, uint256 _sizeDelta, uint256 _marketIndex) internal {

// SLOADs

TraderLoyaltyCredit _tlc = TraderLoyaltyCredit(tlc);

TLCStaking _tlcStaking = TLCStaking(tlcStaking);

// Calculate mint amount which is equal to sizeDelta but convert decimal from 1e30 to 1e18

// This is to make the TLC token composable as ERC20 with regular 18 decimals, also wighted

uint256 weight = marketWeights[_marketIndex] == 0 ? BPS : marketWeights[_marketIndex];

uint256 _mintAmount = _sizeDelta.mulDiv(weight, 1e16); // 1e16 = (1e30 / 1e18) * BPS, optimized math

_tlc.mint(address(this), _mintAmount);

_tlc.approve(address(_tlcStaking), _mintAmount);

_tlcStaking.deposit(_primaryAccount, _mintAmount);

}

function setMarketWeight(uint256 _marketIndex, uint256 _weight) external onlyOwner {

emit LogSetMarketWeight(_marketIndex, marketWeights[_marketIndex], _weight);

marketWeights[_marketIndex] = _weight;

}

function setWhitelistedCallers(address[] calldata _callers, bool[] calldata _isWhitelisteds) external onlyOwner {

if (_callers.length != _isWhitelisteds.length) revert TLCHook_BadArgs();

for (uint256 i = 0; i < _callers.length; ) {

whitelistedCallers[_callers[i]] = _isWhitelisteds[i];

emit LogSetWhitelistedCaller(_callers[i], _isWhitelisteds[i]);

unchecked {

++i;

}

/// @custom:oz-upgrades-unsafe-allow constructor

constructor() {

_disableInitializers();

}

Diferenças salvas

Texto original

Abrir arquivo

// SPDX-License-Identifier: BUSL-1.1
// This code is made available under the terms and conditions of the Business Source License 1.1 (BUSL-1.1).
// The act of publishing this code is driven by the aim to promote transparency and facilitate its utilization for educational purposes.

pragma solidity 0.8.18;

import { OwnableUpgradeable } from "@openzeppelin-upgradeable/contracts/access/OwnableUpgradeable.sol";
import { ITradeServiceHook } from "../services/interfaces/ITradeServiceHook.sol";
import { ITradeService } from "../services/interfaces/ITradeService.sol";
import { ITradingStaking } from "./interfaces/ITradingStaking.sol";
import { TraderLoyaltyCredit } from "@hmx/tokens/TraderLoyaltyCredit.sol";
import { TLCStaking } from "@hmx/staking/TLCStaking.sol";
import { FullMath } from "@hmx/libraries/FullMath.sol";

contract TLCHook is ITradeServiceHook, OwnableUpgradeable {
  using FullMath for uint256;

error TLCHook_Forbidden();
  error TLCHook_BadArgs();

uint32 internal constant BPS = 100_00;

address public tradeService;
  address public tlc;
  address public tlcStaking;

// mapping weight with the marketIndex
  mapping(uint256 marketIndex => uint256 weight) public marketWeights;
  mapping(address whitelisted => bool isWhitelisted) public whitelistedCallers;

modifier onlyWhitelistedCaller() {
    if (!whitelistedCallers[msg.sender]) revert TLCHook_Forbidden();
    _;
  }

event LogSetMarketWeight(uint256 marketIndex, uint256 oldWeight, uint256 newWeight);
  event LogSetWhitelistedCaller(address indexed caller, bool isWhitelisted);

function initialize(address _tradeService, address _tlc, address _tlcStaking) external initializer {
    OwnableUpgradeable.__Ownable_init();

tradeService = _tradeService;
    tlc = _tlc;
    tlcStaking = _tlcStaking;

// Sanity checks
    ITradeService(tradeService).configStorage();
    TraderLoyaltyCredit(tlc).symbol();
  }

function onIncreasePosition(
    address _primaryAccount,
    uint256,
    uint256 _marketIndex,
    uint256 _sizeDelta,
    bytes32
  ) external onlyWhitelistedCaller {
    _mintTLC(_primaryAccount, _sizeDelta, _marketIndex);
  }

function onDecreasePosition(
    address _primaryAccount,
    uint256,
    uint256,
    uint256 _sizeDelta,
    bytes32
  ) external onlyWhitelistedCaller {
    // Do nothing
  }

function _mintTLC(address _primaryAccount, uint256 _sizeDelta, uint256 _marketIndex) internal {
    // SLOADs
    TraderLoyaltyCredit _tlc = TraderLoyaltyCredit(tlc);
    TLCStaking _tlcStaking = TLCStaking(tlcStaking);
    // Calculate mint amount which is equal to sizeDelta but convert decimal from 1e30 to 1e18
    // This is to make the TLC token composable as ERC20 with regular 18 decimals, also wighted
    uint256 weight = marketWeights[_marketIndex] == 0 ? BPS : marketWeights[_marketIndex];
    uint256 _mintAmount = _sizeDelta.mulDiv(weight, 1e16); // 1e16 = (1e30 / 1e18) * BPS, optimized math

_tlc.mint(address(this), _mintAmount);
    _tlc.approve(address(_tlcStaking), _mintAmount);
    _tlcStaking.deposit(_primaryAccount, _mintAmount);
  }

function setMarketWeight(uint256 _marketIndex, uint256 _weight) external onlyOwner {
    emit LogSetMarketWeight(_marketIndex, marketWeights[_marketIndex], _weight);
    marketWeights[_marketIndex] = _weight;
  }

function setWhitelistedCallers(address[] calldata _callers, bool[] calldata _isWhitelisteds) external onlyOwner {
    if (_callers.length != _isWhitelisteds.length) revert TLCHook_BadArgs();
    for (uint256 i = 0; i < _callers.length; ) {
      whitelistedCallers[_callers[i]] = _isWhitelisteds[i];

emit LogSetWhitelistedCaller(_callers[i], _isWhitelisteds[i]);

unchecked {
        ++i;
      }
    }
  }

/// @custom:oz-upgrades-unsafe-allow constructor
  constructor() {
    _disableInitializers();
  }
}

Texto alterado

Abrir arquivo

pragma solidity 0.8.18;

import {OwnableUpgradeable} from "@openzeppelin-upgradeable/contracts/access/OwnableUpgradeable.sol";
import {ITradeServiceHook} from "../services/interfaces/ITradeServiceHook.sol";
import {ITradeService} from "../services/interfaces/ITradeService.sol";
import {ITradingStaking} from "./interfaces/ITradingStaking.sol";
import {TraderLoyaltyCredit} from "@hmx/tokens/TraderLoyaltyCredit.sol";
import {TLCStaking} from "@hmx/staking/TLCStaking.sol";
import {FullMath} from "@hmx/libraries/FullMath.sol";

contract TLCHook is ITradeServiceHook, OwnableUpgradeable {
    using FullMath for uint256;

error TLCHook_Forbidden();
    error TLCHook_BadArgs();

uint32 internal constant BPS = 100_00;

address public tradeService;
    address public tlc;
    address public tlcStaking;

// mapping weight with the marketIndex
    mapping(uint256 marketIndex => uint256 weight) public marketWeights;
    mapping(address whitelisted => bool isWhitelisted) public whitelistedCallers;

modifier onlyWhitelistedCaller() {
        if (!whitelistedCallers[msg.sender]) revert TLCHook_Forbidden();
        _;
    }

event LogSetMarketWeight(uint256 marketIndex, uint256 oldWeight, uint256 newWeight);
    event LogSetWhitelistedCaller(address indexed caller, bool isWhitelisted);

function initialize(address _tradeService, address _tlc, address _tlcStaking) external initializer {
        OwnableUpgradeable.__Ownable_init();

tradeService = _tradeService;
        tlc = _tlc;
        tlcStaking = _tlcStaking;

// Sanity checks
        ITradeService(tradeService).configStorage();
        TraderLoyaltyCredit(tlc).symbol();
    }

function onIncreasePosition(
        address _primaryAccount,
        uint256,
        uint256 _marketIndex,
        uint256 _sizeDelta,
        bytes32
    ) external onlyWhitelistedCaller {
        _mintTLC(_primaryAccount, _sizeDelta, _marketIndex);
    }

function onDecreasePosition(
        address _primaryAccount,
        uint256,
        uint256,
        uint256 _sizeDelta,
        bytes32
    ) external onlyWhitelistedCaller {
        // Do nothing
    }

function _mintTLC(address _primaryAccount, uint256 _sizeDelta, uint256 _marketIndex) internal {
        // SLOADs
        TraderLoyaltyCredit _tlc = TraderLoyaltyCredit(tlc);
        TLCStaking _tlcStaking = TLCStaking(tlcStaking);
        // Calculate mint amount which is equal to sizeDelta but convert decimal from 1e30 to 1e18
        // This is to make the TLC token composable as ERC20 with regular 18 decimals, also wighted
        uint256 weight = marketWeights[_marketIndex] == 0 ? BPS : marketWeights[_marketIndex];
        uint256 _mintAmount = _sizeDelta.mulDiv(weight, 1e16); // 1e16 = (1e30 / 1e18) * BPS, optimized math

_tlc.mint(address(this), _mintAmount);
        _tlc.approve(address(_tlcStaking), _mintAmount);
        _tlcStaking.deposit(_primaryAccount, _mintAmount);
    }

function setMarketWeight(uint256 _marketIndex, uint256 _weight) external onlyOwner {
        emit LogSetMarketWeight(_marketIndex, marketWeights[_marketIndex], _weight);
        marketWeights[_marketIndex] = _weight;
    }

function setWhitelistedCallers(address[] calldata _callers, bool[] calldata _isWhitelisteds) external onlyOwner {
        if (_callers.length != _isWhitelisteds.length) revert TLCHook_BadArgs();
        for (uint256 i = 0; i < _callers.length; ) {
            whitelistedCallers[_callers[i]] = _isWhitelisteds[i];

emit LogSetWhitelistedCaller(_callers[i], _isWhitelisteds[i]);

unchecked {
                ++i;
            }
        }
    }

/// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        _disableInitializers();
    }
}