ETH Price: $3,758.12 (+2.71%)
Gas: 5 Gwei

Contract

0x6002b1dcB26E7B1AA797A17551C6F487923299d7
 

More Info

Private Name Tags

TokenTracker

Multichain Info

No addresses found
Transaction Hash
Method
Block
From
To
Value
Liquid Exit195956002024-04-06 8:49:4745 days ago1712393387IN
TrueFi: tfUSDT Token
0 ETH0.001765512.18688324
Liquid Exit195313242024-03-28 8:09:1154 days ago1711613351IN
TrueFi: tfUSDT Token
0 ETH0.0033208925.98898847
Approve194816832024-03-21 7:54:2361 days ago1711007663IN
TrueFi: tfUSDT Token
0 ETH0.0008118523.35403115
Approve182924432023-10-06 15:46:23228 days ago1696607183IN
TrueFi: tfUSDT Token
0 ETH0.0007020519.09688747
Approve171833582023-05-03 23:09:59384 days ago1683155399IN
TrueFi: tfUSDT Token
0 ETH0.0024575270.69375077
Approve170085792023-04-09 5:06:59409 days ago1681016819IN
TrueFi: tfUSDT Token
0 ETH0.0007018420.1893978
Approve169388952023-03-30 8:32:35418 days ago1680165155IN
TrueFi: tfUSDT Token
0 ETH0.0009572927.5376546
Approve165220232023-01-30 20:27:11477 days ago1675110431IN
TrueFi: tfUSDT Token
0 ETH0.0007828222.51902338
Liquid Exit162912982022-12-29 15:26:11509 days ago1672327571IN
TrueFi: tfUSDT Token
0 ETH0.0022674715.65186924
Join162680652022-12-26 9:34:23512 days ago1672047263IN
TrueFi: tfUSDT Token
0 ETH0.0016689110.47747968
Liquid Exit162009052022-12-17 0:42:35522 days ago1671237755IN
TrueFi: tfUSDT Token
0 ETH0.0022879315.79182656
Approve161979642022-12-16 14:50:11522 days ago1671202211IN
TrueFi: tfUSDT Token
0 ETH0.000835424.03146231
Approve161839932022-12-14 16:01:23524 days ago1671033683IN
TrueFi: tfUSDT Token
0 ETH0.0009038326
Liquid Exit161756422022-12-13 11:59:35525 days ago1670932775IN
TrueFi: tfUSDT Token
0 ETH0.0021622914.92460514
Liquid Exit161408412022-12-08 15:19:47530 days ago1670512787IN
TrueFi: tfUSDT Token
0 ETH0.0021139914.59127454
Liquid Exit161407902022-12-08 15:09:35530 days ago1670512175IN
TrueFi: tfUSDT Token
0 ETH0.0022626615.61736949
Liquid Exit161351952022-12-07 20:24:35531 days ago1670444675IN
TrueFi: tfUSDT Token
0 ETH0.0020030315.67551386
Liquid Exit161346952022-12-07 18:44:11531 days ago1670438651IN
TrueFi: tfUSDT Token
0 ETH0.0024742217.07765564
Liquid Exit161342032022-12-07 17:05:35531 days ago1670432735IN
TrueFi: tfUSDT Token
0 ETH0.0029231320.17612151
Liquid Exit161340302022-12-07 16:30:59531 days ago1670430659IN
TrueFi: tfUSDT Token
0 ETH0.0023182816
Liquid Exit161339532022-12-07 16:15:23531 days ago1670429723IN
TrueFi: tfUSDT Token
0 ETH0.0019408813.39640578
Liquid Exit161315292022-12-07 8:02:47531 days ago1670400167IN
TrueFi: tfUSDT Token
0 ETH0.0020878414.4095535
Liquid Exit161207852022-12-05 19:51:11533 days ago1670269871IN
TrueFi: tfUSDT Token
0 ETH0.0023180916
Join160924112022-12-01 20:42:23537 days ago1669927343IN
TrueFi: tfUSDT Token
0 ETH0.0020609715
Join160789222022-11-29 23:27:35539 days ago1669764455IN
TrueFi: tfUSDT Token
0 ETH0.0014522210.56856486
View all transactions

Latest 1 internal transaction

Advanced mode:
Parent Transaction Hash Block From To Value
126532002021-06-17 17:13:551069 days ago1623950035  Contract Creation0 ETH
Loading...
Loading

Similar Match Source Code
This contract matches the deployed Bytecode of the Source Code for Contract 0xA991356d...4F8f1c742
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-05-20
*/

/**
 *Submitted for verification at Etherscan.io on 2021-05-05
*/

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

// https://github.com/trusttoken/smart-contracts
// 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;
    }
}

/**
 * @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;
}

/**
 * @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);
    }
}

/**
 * @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);
    }
}

/**
 * @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

9005:7279:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15003:11;:9;:11::i;:::-;9005:7279;;14717:11;:9;:11::i;11572:183::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;11887:211;;;;;;;;;;;;;:::i;13825:178::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;13825:178:0;;;;:::i;14144:337::-;;;;;;;;;;;;;:::i;13348:254::-;;;;;;;;;;;;;:::i;13023:230::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;13023:230:0;;;;:::i;15176:555::-;15217:12;15232:16;:14;:16::i;:::-;15217:31;;15302:4;15296:11;15342:14;15339:1;15334:3;15321:36;15435:1;15432;15416:14;15411:3;15405:4;15398:5;15385:52;15474:16;15471:1;15466:3;15451:40;15514:6;15538:78;;;;15677:16;15672:3;15665:29;15538:78;15580:16;15575:3;15568:29;11572:183;10143:66;11722:15;;11698:50::o;11887:211::-;10305:66;12065:15;;12034:57::o;13825:178::-;11167:12;:10;:12::i;:::-;11153:26;;:10;:26;;;11145:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13939:56:::1;13970:24;13939:30;:56::i;:::-;13825:178:::0;:::o;14144:337::-;14191:7;14211:16;10481:48;;;;;;;;;;;;;;;;;;;14211:50;;14272:31;14371:8;14365:15;14338:42;;14432:23;14408:63;;;:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14408:65:0;;-1:-1:-1;;;14144:337:0;:::o;13348:254::-;11387:19;:17;:19::i;:::-;11373:33;;:10;:33;;;11365:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13466:19:::1;:17;:19::i;:::-;13426:60;;13452:12;:10;:12::i;:::-;13426:60;;;;;;;;;;;;13497:44;13521:19;:17;:19::i;:::-;13497:23;:44::i;:::-;13552:42;13591:1;13552:30;:42::i;:::-;13348:254::o:0;13023:230::-;11167:12;:10;:12::i;:::-;11153:26;;:10;:26;;;11145:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13116:22:::1;::::0;::::1;13108:31;;;::::0;::::1;;13150:40;13181:8;13150:30;:40::i;:::-;13206:39;13222:12;:10;:12::i;:::-;13206:39;::::0;;::::1;::::0;;::::1;::::0;;;;::::1;;::::0;::::1;::::0;;;;;;;;;::::1;13023:230:::0;:::o;15951:330::-;16053:16;10481:48;;;;;;;;;;;;;;;;;;;16138:42;;;16208:65;;;;;;;10481:48;;-1:-1:-1;16208:65:0;;-1:-1:-1;16208:65:0;;;;;;;;15951:330;;:::o;12216:197::-;10143:66;12364:31;12349:57::o;12544:225::-;10305:66;12713:38;12698:64::o

Swarm Source

ipfs://94e783569eec156e98e953577f0d664ef4b8dbb78a527b28d8ec46d0ac4e64be

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.