ETH Price: $3,086.38 (-1.38%)
Gas: 2 Gwei

Contract

0x1Ed460D149D48FA7d91703bf4890F97220C09437
 

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To
Value
Liquid Exit187838372023-12-14 10:38:11157 days ago1702550291IN
TrueFi: tfBUSD Token
0 ETH0.0052634839.25686214
Approve177456182023-07-22 2:14:23303 days ago1689992063IN
TrueFi: tfBUSD Token
0 ETH0.0006244917.96440741
Approve170123282023-04-09 17:53:35406 days ago1681062815IN
TrueFi: tfBUSD Token
0 ETH0.0010821131.12843866
Liquid Exit168700542023-03-20 16:24:35426 days ago1679329475IN
TrueFi: tfBUSD Token
0 ETH0.0049389332.66705931
Liquid Exit165434552023-02-02 20:19:59472 days ago1675369199IN
TrueFi: tfBUSD Token
0 ETH0.0054472536.032087
Liquid Exit162995762022-12-30 19:09:23506 days ago1672427363IN
TrueFi: tfBUSD Token
0 ETH0.002819318.64742764
Approve161042552022-12-03 12:21:59533 days ago1670070119IN
TrueFi: tfBUSD Token
0 ETH0.0003744410.77142401
Liquid Exit161042452022-12-03 12:19:47533 days ago1670069987IN
TrueFi: tfBUSD Token
0 ETH0.0016724411.06189286
Liquid Exit161039662022-12-03 11:23:35533 days ago1670066615IN
TrueFi: tfBUSD Token
0 ETH0.0016234512.10722994
Liquid Exit160673222022-11-28 8:34:59538 days ago1669624499IN
TrueFi: tfBUSD Token
0 ETH0.0017426911.52835183
Liquid Exit159415142022-11-10 18:49:35556 days ago1668106175IN
TrueFi: tfBUSD Token
0 ETH0.0046199330.56198935
Liquid Exit158122152022-10-23 17:10:59574 days ago1666545059IN
TrueFi: tfBUSD Token
0 ETH0.0026009814.87509291
Liquid Exit157637942022-10-16 22:55:59581 days ago1665960959IN
TrueFi: tfBUSD Token
0 ETH0.0024357812.78767548
Liquid Exit157514832022-10-15 5:39:59582 days ago1665812399IN
TrueFi: tfBUSD Token
0 ETH0.002774614.56645434
Liquid Exit157216052022-10-11 1:32:47587 days ago1665451967IN
TrueFi: tfBUSD Token
0 ETH0.0072717933.96953914
Liquid Exit157194622022-10-10 18:22:47587 days ago1665426167IN
TrueFi: tfBUSD Token
0 ETH0.0076274335.63088943
Liquid Exit156856822022-10-06 1:07:59592 days ago1665018479IN
TrueFi: tfBUSD Token
0 ETH0.0025395911.86285089
Liquid Exit156759222022-10-04 16:20:47593 days ago1664900447IN
TrueFi: tfBUSD Token
0 ETH0.003563318.09189663
Approve155922642022-09-22 23:47:59605 days ago1663890479IN
TrueFi: tfBUSD Token
0 ETH0.000348936.11657403
Join155906112022-09-22 18:16:35605 days ago1663870595IN
TrueFi: tfBUSD Token
0 ETH0.0030723813.40143993
Join155637792022-09-18 23:44:23609 days ago1663544663IN
TrueFi: tfBUSD Token
0 ETH0.000854224.02657554
Liquid Exit155606892022-09-18 13:19:59609 days ago1663507199IN
TrueFi: tfBUSD Token
0 ETH0.001261095.72389245
Liquid Exit155606232022-09-18 13:06:35609 days ago1663506395IN
TrueFi: tfBUSD Token
0 ETH0.001517386.39028999
Approve155561452022-09-17 22:02:59610 days ago1663452179IN
TrueFi: tfBUSD Token
0 ETH0.000272514.77705487
Join155561392022-09-17 22:01:47610 days ago1663452107IN
TrueFi: tfBUSD Token
0 ETH0.001263975.51362384
View all transactions

Latest 1 internal transaction

Advanced mode:
Parent Transaction Hash Block From To Value
136235842021-11-16 0:48:05916 days ago1637023685  Contract Creation0 ETH
Loading...
Loading

Similar Match Source Code
This contract matches the deployed Bytecode of the Source Code for Contract 0x97cE06c3...6000072E5
The constructor portion of the code might be different and could alter the actual behaviour of the contract

Contract Name:
OwnedProxyWithReference

Compiler Version
v0.6.10+commit.00c0fcaf

Optimization Enabled:
Yes with 20000 runs

Other Settings:
default evmVersion, MIT license
/**
 *Submitted for verification at Etherscan.io on 2021-08-17
*/

/*
    .'''''''''''..     ..''''''''''''''''..       ..'''''''''''''''..
    .;;;;;;;;;;;'.   .';;;;;;;;;;;;;;;;;;,.     .,;;;;;;;;;;;;;;;;;,.
    .;;;;;;;;;;,.   .,;;;;;;;;;;;;;;;;;;;,.    .,;;;;;;;;;;;;;;;;;;,.
    .;;;;;;;;;,.   .,;;;;;;;;;;;;;;;;;;;;,.   .;;;;;;;;;;;;;;;;;;;;,.
    ';;;;;;;;'.  .';;;;;;;;;;;;;;;;;;;;;;,. .';;;;;;;;;;;;;;;;;;;;;,.
    ';;;;;,..   .';;;;;;;;;;;;;;;;;;;;;;;,..';;;;;;;;;;;;;;;;;;;;;;,.
    ......     .';;;;;;;;;;;;;,'''''''''''.,;;;;;;;;;;;;;,'''''''''..
              .,;;;;;;;;;;;;;.           .,;;;;;;;;;;;;;.
             .,;;;;;;;;;;;;,.           .,;;;;;;;;;;;;,.
            .,;;;;;;;;;;;;,.           .,;;;;;;;;;;;;,.
           .,;;;;;;;;;;;;,.           .;;;;;;;;;;;;;,.     .....
          .;;;;;;;;;;;;;'.         ..';;;;;;;;;;;;;'.    .',;;;;,'.
        .';;;;;;;;;;;;;'.         .';;;;;;;;;;;;;;'.   .';;;;;;;;;;.
       .';;;;;;;;;;;;;'.         .';;;;;;;;;;;;;;'.    .;;;;;;;;;;;,.
      .,;;;;;;;;;;;;;'...........,;;;;;;;;;;;;;;.      .;;;;;;;;;;;,.
     .,;;;;;;;;;;;;,..,;;;;;;;;;;;;;;;;;;;;;;;,.       ..;;;;;;;;;,.
    .,;;;;;;;;;;;;,. .,;;;;;;;;;;;;;;;;;;;;;;,.          .',;;;,,..
   .,;;;;;;;;;;;;,.  .,;;;;;;;;;;;;;;;;;;;;;,.              ....
    ..',;;;;;;;;,.   .,;;;;;;;;;;;;;;;;;;;;,.
       ..',;;;;'.    .,;;;;;;;;;;;;;;;;;;;'.
          ...'..     .';;;;;;;;;;;;;;,,,'.
                       ...............
*/

// https://github.com/trusttoken/smart-contracts
// Dependency file: @openzeppelin/contracts/GSN/Context.sol

// SPDX-License-Identifier: MIT

// pragma solidity ^0.6.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with GSN meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}


// Dependency file: contracts/common/Initializable.sol

// Copied from https://github.com/OpenZeppelin/openzeppelin-contracts-ethereum-package/blob/v3.0.0/contracts/Initializable.sol
// Added public isInitialized() view of private initialized bool.

// pragma solidity 0.6.10;

/**
 * @title Initializable
 *
 * @dev Helper contract to support initializer functions. To use it, replace
 * the constructor with a function that has the `initializer` modifier.
 * WARNING: Unlike constructors, initializer functions must be manually
 * invoked. This applies both to deploying an Initializable contract, as well
 * as extending an Initializable contract via inheritance.
 * WARNING: When used with inheritance, manual care must be taken to not invoke
 * a parent initializer twice, or ensure that all initializers are idempotent,
 * because this is not dealt with automatically as with constructors.
 */
contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private initializing;

    /**
     * @dev Modifier to use in the initializer function of a contract.
     */
    modifier initializer() {
        require(initializing || isConstructor() || !initialized, "Contract instance has already been initialized");

        bool isTopLevelCall = !initializing;
        if (isTopLevelCall) {
            initializing = true;
            initialized = true;
        }

        _;

        if (isTopLevelCall) {
            initializing = false;
        }
    }

    /// @dev Returns true if and only if the function is running in the constructor
    function isConstructor() private view returns (bool) {
        // extcodesize checks the size of the code stored in an address, and
        // address returns the current address. Since the code is still not
        // deployed when running a constructor, any checks on its code size will
        // yield zero, making it an effective way to detect if a contract is
        // under construction or not.
        address self = address(this);
        uint256 cs;
        assembly {
            cs := extcodesize(self)
        }
        return cs == 0;
    }

    /**
     * @dev Return true if and only if the contract has been initialized
     * @return whether the contract has been initialized
     */
    function isInitialized() public view returns (bool) {
        return initialized;
    }

    // Reserved storage space to allow for layout changes in the future.
    uint256[50] private ______gap;
}


// Dependency file: contracts/common/UpgradeableClaimable.sol

// pragma solidity 0.6.10;

// import {Context} from "@openzeppelin/contracts/GSN/Context.sol";

// import {Initializable} from "contracts/common/Initializable.sol";

/**
 * @title UpgradeableClaimable
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. Since
 * this contract combines Claimable and UpgradableOwnable contracts, ownership
 * can be later change via 2 step method {transferOwnership} and {claimOwnership}
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
contract UpgradeableClaimable is Initializable, Context {
    address private _owner;
    address private _pendingOwner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting a custom initial owner of choice.
     * @param __owner Initial owner of contract to be set.
     */
    function initialize(address __owner) internal initializer {
        _owner = __owner;
        emit OwnershipTransferred(address(0), __owner);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view returns (address) {
        return _owner;
    }

    /**
     * @dev Returns the address of the pending owner.
     */
    function pendingOwner() public view returns (address) {
        return _pendingOwner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Modifier throws if called by any account other than the pendingOwner.
     */
    modifier onlyPendingOwner() {
        require(msg.sender == _pendingOwner, "Ownable: caller is not the pending owner");
        _;
    }

    /**
     * @dev Allows the current owner to set the pendingOwner address.
     * @param newOwner The address to transfer ownership to.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _pendingOwner = newOwner;
    }

    /**
     * @dev Allows the pendingOwner address to finalize the transfer.
     */
    function claimOwnership() public onlyPendingOwner {
        emit OwnershipTransferred(_owner, _pendingOwner);
        _owner = _pendingOwner;
        _pendingOwner = address(0);
    }
}


// Dependency file: contracts/proxy/ImplementationReference.sol

// pragma solidity 0.6.10;

// import {UpgradeableClaimable} from "contracts/common/UpgradeableClaimable.sol";

/**
 * @title ImplementationReference
 * @dev This contract is made to serve a simple purpose only.
 * To hold the address of the implementation contract to be used by proxy.
 * The implementation address, is changeable anytime by the owner of this contract.
 */
contract ImplementationReference is UpgradeableClaimable {
    address public implementation;

    /**
     * @dev Event to show that implementation address has been changed
     * @param newImplementation New address of the implementation
     */
    event ImplementationChanged(address newImplementation);

    /**
     * @dev Set initial ownership and implementation address
     * @param _implementation Initial address of the implementation
     */
    constructor(address _implementation) public {
        UpgradeableClaimable.initialize(msg.sender);
        implementation = _implementation;
    }

    /**
     * @dev Function to change the implementation address, which can be called only by the owner
     * @param newImplementation New address of the implementation
     */
    function setImplementation(address newImplementation) external onlyOwner {
        implementation = newImplementation;
        emit ImplementationChanged(newImplementation);
    }
}


// Root file: contracts/proxy/OwnedProxyWithReference.sol

// solhint-disable const-name-snakecase
pragma solidity 0.6.10;

// import {ImplementationReference} from "contracts/proxy/ImplementationReference.sol";

/**
 * @title OwnedProxyWithReference
 * @dev This contract combines an upgradeability proxy with basic authorization control functionalities
 * Its structure makes it easy for a group of contracts alike, to share an implementation and to change it easily for all of them at once
 */
contract OwnedProxyWithReference {
    /**
     * @dev Event to show ownership has been transferred
     * @param previousOwner representing the address of the previous owner
     * @param newOwner representing the address of the new owner
     */
    event ProxyOwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Event to show ownership transfer is pending
     * @param currentOwner representing the address of the current owner
     * @param pendingOwner representing the address of the pending owner
     */
    event NewPendingOwner(address currentOwner, address pendingOwner);

    /**
     * @dev Event to show implementation reference has been changed
     * @param implementationReference address of the new implementation reference contract
     */
    event ImplementationReferenceChanged(address implementationReference);

    // Storage position of the owner and pendingOwner and implementationReference of the contract
    // This is made to ensure, that memory spaces do not interfere with each other
    bytes32 private constant proxyOwnerPosition = 0x6279e8199720cf3557ecd8b58d667c8edc486bd1cf3ad59ea9ebdfcae0d0dfac; //keccak256("trueUSD.proxy.owner");
    bytes32 private constant pendingProxyOwnerPosition = 0x8ddbac328deee8d986ec3a7b933a196f96986cb4ee030d86cc56431c728b83f4; //keccak256("trueUSD.pending.proxy.owner");
    bytes32 private constant implementationReferencePosition = keccak256("trueFiPool.implementation.reference"); //keccak256("trueFiPool.implementation.reference");

    /**
     * @dev the constructor sets the original owner of the contract to the sender account.
     * @param _owner Initial owner of the proxy
     * @param _implementationReference initial ImplementationReference address
     */
    constructor(address _owner, address _implementationReference) public {
        _setUpgradeabilityOwner(_owner);
        _changeImplementationReference(_implementationReference);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyProxyOwner() {
        require(msg.sender == proxyOwner(), "only Proxy Owner");
        _;
    }

    /**
     * @dev Throws if called by any account other than the pending owner.
     */
    modifier onlyPendingProxyOwner() {
        require(msg.sender == pendingProxyOwner(), "only pending Proxy Owner");
        _;
    }

    /**
     * @dev Tells the address of the owner
     * @return owner the address of the owner
     */
    function proxyOwner() public view returns (address owner) {
        bytes32 position = proxyOwnerPosition;
        assembly {
            owner := sload(position)
        }
    }

    /**
     * @dev Tells the address of the owner
     * @return pendingOwner the address of the pending owner
     */
    function pendingProxyOwner() public view returns (address pendingOwner) {
        bytes32 position = pendingProxyOwnerPosition;
        assembly {
            pendingOwner := sload(position)
        }
    }

    /**
     * @dev Sets the address of the owner
     * @param newProxyOwner New owner to be set
     */
    function _setUpgradeabilityOwner(address newProxyOwner) internal {
        bytes32 position = proxyOwnerPosition;
        assembly {
            sstore(position, newProxyOwner)
        }
    }

    /**
     * @dev Sets the address of the owner
     * @param newPendingProxyOwner New pending owner address
     */
    function _setPendingUpgradeabilityOwner(address newPendingProxyOwner) internal {
        bytes32 position = pendingProxyOwnerPosition;
        assembly {
            sstore(position, newPendingProxyOwner)
        }
    }

    /**
     * @dev Allows the current owner to transfer control of the contract to a newOwner.
     * changes the pending owner to newOwner. But doesn't actually transfer
     * @param newOwner The address to transfer ownership to.
     */
    function transferProxyOwnership(address newOwner) external onlyProxyOwner {
        require(newOwner != address(0));
        _setPendingUpgradeabilityOwner(newOwner);
        emit NewPendingOwner(proxyOwner(), newOwner);
    }

    /**
     * @dev Allows the pendingOwner to claim ownership of the proxy
     */
    function claimProxyOwnership() external onlyPendingProxyOwner {
        emit ProxyOwnershipTransferred(proxyOwner(), pendingProxyOwner());
        _setUpgradeabilityOwner(pendingProxyOwner());
        _setPendingUpgradeabilityOwner(address(0));
    }

    /**
     * @dev Allows the proxy owner to change the contract holding address of implementation.
     * @param _implementationReference representing the address contract, which holds implementation.
     */
    function changeImplementationReference(address _implementationReference) public virtual onlyProxyOwner {
        _changeImplementationReference(_implementationReference);
    }

    /**
     * @dev Get the address of current implementation.
     * @return Returns address of implementation contract
     */
    function implementation() public view returns (address) {
        bytes32 position = implementationReferencePosition;
        address implementationReference;
        assembly {
            implementationReference := sload(position)
        }
        return ImplementationReference(implementationReference).implementation();
    }

    /**
     * @dev Fallback functions allowing to perform a delegatecall to the given implementation.
     * This function will return whatever the implementation call returns
     */
    fallback() external payable {
        proxyCall();
    }

    /**
     * @dev This fallback function gets called only when this contract is called without any calldata e.g. send(), transfer()
     * This would also trigger receive() function on called implementation
     */
    receive() external payable {
        proxyCall();
    }

    /**
     * @dev Performs a low level call, to the contract holding all the logic, changing state on this contract at the same time
     */
    function proxyCall() internal {
        address impl = implementation();

        assembly {
            let ptr := mload(0x40)
            calldatacopy(ptr, 0, calldatasize())
            let result := delegatecall(gas(), impl, ptr, calldatasize(), 0, 0)
            returndatacopy(ptr, 0, returndatasize())

            switch result
                case 0 {
                    revert(ptr, returndatasize())
                }
                default {
                    return(ptr, returndatasize())
                }
        }
    }

    /**
     * @dev Function to internally change the contract holding address of implementation.
     * @param _implementationReference representing the address contract, which holds implementation.
     */
    function _changeImplementationReference(address _implementationReference) internal virtual {
        bytes32 position = implementationReferencePosition;
        assembly {
            sstore(position, _implementationReference)
        }

        emit ImplementationReferenceChanged(address(_implementationReference));
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_implementationReference","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"implementationReference","type":"address"}],"name":"ImplementationReferenceChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"currentOwner","type":"address"},{"indexed":false,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"NewPendingOwner","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"ProxyOwnershipTransferred","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[{"internalType":"address","name":"_implementationReference","type":"address"}],"name":"changeImplementationReference","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimProxyOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingProxyOwner","outputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxyOwner","outputs":[{"internalType":"address","name":"owner","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferProxyOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

Deployed Bytecode

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

Deployed Bytecode Sourcemap

9934:7279:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15932:11;:9;:11::i;:::-;9934:7279;;15646:11;:9;:11::i;12501:183::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;12816:211;;;;;;;;;;;;;:::i;14754:178::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14754:178:0;;;;:::i;15073:337::-;;;;;;;;;;;;;:::i;14277:254::-;;;;;;;;;;;;;:::i;13952:230::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;13952:230:0;;;;:::i;16105:555::-;16146:12;16161:16;:14;:16::i;:::-;16146:31;;16231:4;16225:11;16271:14;16268:1;16263:3;16250:36;16364:1;16361;16345:14;16340:3;16334:4;16327:5;16314:52;16403:16;16400:1;16395:3;16380:40;16443:6;16467:78;;;;16606:16;16601:3;16594:29;16467:78;16509:16;16504:3;16497:29;12501:183;11072:66;12651:15;;12627:50::o;12816:211::-;11234:66;12994:15;;12963:57::o;14754:178::-;12096:12;:10;:12::i;:::-;12082:26;;:10;:26;;;12074:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14868:56:::1;14899:24;14868:30;:56::i;:::-;14754:178:::0;:::o;15073:337::-;15120:7;15140:16;11410:48;;;;;;;;;;;;;;;;;;;15140:50;;15201:31;15300:8;15294:15;15267:42;;15361:23;15337:63;;;:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;15337:65:0;;-1:-1:-1;;;15073:337:0;:::o;14277:254::-;12316:19;:17;:19::i;:::-;12302:33;;:10;:33;;;12294:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14395:19:::1;:17;:19::i;:::-;14355:60;;14381:12;:10;:12::i;:::-;14355:60;;;;;;;;;;;;14426:44;14450:19;:17;:19::i;:::-;14426:23;:44::i;:::-;14481:42;14520:1;14481:30;:42::i;:::-;14277:254::o:0;13952:230::-;12096:12;:10;:12::i;:::-;12082:26;;:10;:26;;;12074:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14045:22:::1;::::0;::::1;14037:31;;;::::0;::::1;;14079:40;14110:8;14079:30;:40::i;:::-;14135:39;14151:12;:10;:12::i;:::-;14135:39;::::0;;::::1;::::0;;::::1;::::0;;;;::::1;;::::0;::::1;::::0;;;;;;;;;::::1;13952:230:::0;:::o;16880:330::-;16982:16;11410:48;;;;;;;;;;;;;;;;;;;17067:42;;;17137:65;;;;;;;11410:48;;-1:-1:-1;17137:65:0;;-1:-1:-1;17137:65:0;;;;;;;;16880:330;;:::o;13145:197::-;11072:66;13293:31;13278:57::o;13473:225::-;11234:66;13642:38;13627:64::o

Swarm Source

ipfs://4414d87863f7493cba07450f067e5798740d25895d8a515f930224351ce21951

Block Transaction Difficulty Gas Used Reward
View All Blocks Produced

Block Uncle Number Difficulty Gas Used Reward
View All Uncles
Loading...
Loading
Loading...
Loading

OVERVIEW

TrueFi is a DeFi protocol for uncollateralized lending powered by the TRU token. TRU Stakers to assess the creditworthiness of the loans

Validator Index Block Amount
View All Withdrawals

Transaction Hash Block Value Eth2 PubKey Valid
View All Deposits
Loading...
Loading
[ Download: CSV Export  ]
[ Download: CSV Export  ]

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.