Contract 0xfe817b00f2cd0e062a5f66067e9a9ef789144cbf 1

 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x44ff1f46f665725cd0c602a31263b95934e9759924f9a61f1557bcca8f9c5cdcConvert514742032022-11-26 16:53:515 days 17 hrs ago0x38ab1c0e1c3a185594792f7fd7212eeb563f044c IN  0xfe817b00f2cd0e062a5f66067e9a9ef789144cbf0 FTM0.1192437
0x276c5f3470cda31dd93a44de561a8ee89305eaa541eaeddca5883a457a6d1d34Convert509850132022-11-16 18:12:3815 days 16 hrs ago0x38ab1c0e1c3a185594792f7fd7212eeb563f044c IN  0xfe817b00f2cd0e062a5f66067e9a9ef789144cbf0 FTM0.107893799189
0x1b08bcea9ecd30f0f9c9adbfc7dcf8173063ee28c42f27563b4dbd343a09d78dConvert509849872022-11-16 18:12:0215 days 16 hrs ago0x38ab1c0e1c3a185594792f7fd7212eeb563f044c IN  0xfe817b00f2cd0e062a5f66067e9a9ef789144cbf0 FTM0.037585695301
0x5f4468e6754e3bb555c24913e7b034896161ff3c2463f901d0d4a2e64c81f411Convert509849542022-11-16 18:10:3015 days 16 hrs ago0x38ab1c0e1c3a185594792f7fd7212eeb563f044c IN  0xfe817b00f2cd0e062a5f66067e9a9ef789144cbf0 FTM5.749706887574
0x676c048724f29c7ec0ff938fc468b02b109ff11bc737e99c6b670c84212eb5f3Convert509849252022-11-16 18:08:5615 days 16 hrs ago0x38ab1c0e1c3a185594792f7fd7212eeb563f044c IN  0xfe817b00f2cd0e062a5f66067e9a9ef789144cbf0 FTM3.1080935778
0x22ef16b8a388eea7338ccd3b71ffcefb4ebac2d60093cc0805e2cba20417f471Convert509849162022-11-16 18:08:2315 days 16 hrs ago0x38ab1c0e1c3a185594792f7fd7212eeb563f044c IN  0xfe817b00f2cd0e062a5f66067e9a9ef789144cbf0 FTM3.0557972948
0x1b466945f8f8b94cabb52c4180fbf1d9660eb962c3dc6d2f09bc82e271b454a7Convert509849092022-11-16 18:07:5515 days 16 hrs ago0x38ab1c0e1c3a185594792f7fd7212eeb563f044c IN  0xfe817b00f2cd0e062a5f66067e9a9ef789144cbf0 FTM3.081895258162
0x910cadf333e9bc0a7f1961b48b60e40d26be239c14b433d30ae50f92b1db2ec6Convert509848852022-11-16 18:06:5915 days 16 hrs ago0x38ab1c0e1c3a185594792f7fd7212eeb563f044c IN  0xfe817b00f2cd0e062a5f66067e9a9ef789144cbf0 FTM0.0377404805
0x156c0a393cc5f0fe05a9e7e437261eb19fb7d0eb6ed5ed50241cbf36e15b612aConvert509848782022-11-16 18:06:5215 days 16 hrs ago0x38ab1c0e1c3a185594792f7fd7212eeb563f044c IN  0xfe817b00f2cd0e062a5f66067e9a9ef789144cbf0 FTM0.03826199
0x75ff2f3d102e22f9ed41de0c6ec39a0b4c6a1b04d7a4878a8e6570ea88a58909Convert509848482022-11-16 18:06:1615 days 16 hrs ago0x38ab1c0e1c3a185594792f7fd7212eeb563f044c IN  0xfe817b00f2cd0e062a5f66067e9a9ef789144cbf0 FTM0.042600994
0xf2c9394c2a8a63f7137c364e1982fe9ad97c05f6ff3b6303d42cebe8be019c36Convert509848422022-11-16 18:06:0715 days 16 hrs ago0x38ab1c0e1c3a185594792f7fd7212eeb563f044c IN  0xfe817b00f2cd0e062a5f66067e9a9ef789144cbf0 FTM0.04075546
0x9a324d51056823540cac8988f1134f3e6b42f186202efaff3ef35d2698869c4dConvert509848362022-11-16 18:05:5515 days 16 hrs ago0x38ab1c0e1c3a185594792f7fd7212eeb563f044c IN  0xfe817b00f2cd0e062a5f66067e9a9ef789144cbf0 FTM0.042916376
0xf1be4d31343f7b5a45831ac48df1254ee3aa86cbeb9d2c46e4e4e3b6d1f831fbConvert509848242022-11-16 18:05:3615 days 16 hrs ago0x38ab1c0e1c3a185594792f7fd7212eeb563f044c IN  0xfe817b00f2cd0e062a5f66067e9a9ef789144cbf0 FTM0.025468197
0x84e2879c64e40b58fd8b7a8c583acc1f3ddbcb4d23131d6d8b8cd16750b215f6Transfer Ownersh...371096952022-04-28 0:48:55218 days 9 hrs ago0xc7f8d87734ab2cbf70030ac8aa82abfe3e8126cb IN  0xfe817b00f2cd0e062a5f66067e9a9ef789144cbf0 FTM0.00795935723
0x10f168d7acf1f6739f344331eff927932af37725840a1c01a15150df4cc7e3490x60806040371043852022-04-27 23:15:22218 days 11 hrs ago0xc7f8d87734ab2cbf70030ac8aa82abfe3e8126cb IN  Create: ProxyUpgradeableOwnable0 FTM0.096448978177
[ Download CSV Export 
Latest 1 internal transaction
Parent Txn Hash Block From To Value
0x10f168d7acf1f6739f344331eff927932af37725840a1c01a15150df4cc7e349371043852022-04-27 23:15:22218 days 11 hrs ago 0xc7f8d87734ab2cbf70030ac8aa82abfe3e8126cb  Contract Creation0 FTM
[ Download CSV Export 
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.

Contract Source Code Verified (Exact Match)

Contract Name:
ProxyUpgradeableOwnable

Compiler Version
v0.8.12+commit.f00d7308

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion
File 1 of 12 : ProxyUpgradeableOwnable.sol
// SPDX-License-Identifier: BUSL-1.1
// For further clarification please see https://license.premia.legal

pragma solidity ^0.8.0;

import {Proxy} from "@solidstate/contracts/proxy/Proxy.sol";
import {SafeOwnable, OwnableStorage} from "@solidstate/contracts/access/SafeOwnable.sol";
import {ProxyUpgradeableOwnableStorage} from "./ProxyUpgradeableOwnableStorage.sol";

contract ProxyUpgradeableOwnable is Proxy, SafeOwnable {
    using ProxyUpgradeableOwnableStorage for ProxyUpgradeableOwnableStorage.Layout;
    using OwnableStorage for OwnableStorage.Layout;

    constructor(address implementation) {
        OwnableStorage.layout().setOwner(msg.sender);
        ProxyUpgradeableOwnableStorage.layout().implementation = implementation;
    }

    receive() external payable {}

    /**
     * @inheritdoc Proxy
     */
    function _getImplementation() internal view override returns (address) {
        return ProxyUpgradeableOwnableStorage.layout().implementation;
    }

    /**
     * @notice get address of implementation contract
     * @return implementation address
     */
    function getImplementation() external view returns (address) {
        return _getImplementation();
    }

    /**
     * @notice set address of implementation contract
     * @param implementation address of the new implementation
     */
    function setImplementation(address implementation) external onlyOwner {
        ProxyUpgradeableOwnableStorage.layout().implementation = implementation;
    }
}

File 2 of 12 : Proxy.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { AddressUtils } from '../utils/AddressUtils.sol';

/**
 * @title Base proxy contract
 */
abstract contract Proxy {
    using AddressUtils for address;

    /**
     * @notice delegate all calls to implementation contract
     * @dev reverts if implementation address contains no code, for compatibility with metamorphic contracts
     * @dev memory location in use by assembly may be unsafe in other contexts
     */
    fallback() external payable virtual {
        address implementation = _getImplementation();

        require(
            implementation.isContract(),
            'Proxy: implementation must be contract'
        );

        assembly {
            calldatacopy(0, 0, calldatasize())
            let result := delegatecall(
                gas(),
                implementation,
                0,
                calldatasize(),
                0,
                0
            )
            returndatacopy(0, 0, returndatasize())

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

    /**
     * @notice get logic implementation address
     * @return implementation address
     */
    function _getImplementation() internal virtual returns (address);
}

File 3 of 12 : SafeOwnable.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { Ownable, OwnableStorage } from './Ownable.sol';
import { SafeOwnableInternal } from './SafeOwnableInternal.sol';
import { SafeOwnableStorage } from './SafeOwnableStorage.sol';

/**
 * @title Ownership access control based on ERC173 with ownership transfer safety check
 */
abstract contract SafeOwnable is Ownable, SafeOwnableInternal {
    using OwnableStorage for OwnableStorage.Layout;
    using SafeOwnableStorage for SafeOwnableStorage.Layout;

    function nomineeOwner() public view virtual returns (address) {
        return SafeOwnableStorage.layout().nomineeOwner;
    }

    /**
     * @inheritdoc Ownable
     * @dev ownership transfer must be accepted by beneficiary before transfer is complete
     */
    function transferOwnership(address account)
        public
        virtual
        override
        onlyOwner
    {
        SafeOwnableStorage.layout().setNomineeOwner(account);
    }

    /**
     * @notice accept transfer of contract ownership
     */
    function acceptOwnership() public virtual onlyNomineeOwner {
        OwnableStorage.Layout storage l = OwnableStorage.layout();
        emit OwnershipTransferred(l.owner, msg.sender);
        l.setOwner(msg.sender);
        SafeOwnableStorage.layout().setNomineeOwner(address(0));
    }
}

File 4 of 12 : ProxyUpgradeableOwnableStorage.sol
// SPDX-License-Identifier: BUSL-1.1
// For further clarification please see https://license.premia.legal

pragma solidity ^0.8.0;

library ProxyUpgradeableOwnableStorage {
    bytes32 internal constant STORAGE_SLOT =
        keccak256("premia.contracts.storage.ProxyUpgradeableOwnable");

    struct Layout {
        address implementation;
    }

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }
}

File 5 of 12 : AddressUtils.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { UintUtils } from './UintUtils.sol';

library AddressUtils {
    using UintUtils for uint256;

    function toString(address account) internal pure returns (string memory) {
        return uint256(uint160(account)).toHexString(20);
    }

    function isContract(address account) internal view returns (bool) {
        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    function sendValue(address payable account, uint256 amount) internal {
        (bool success, ) = account.call{ value: amount }('');
        require(success, 'AddressUtils: failed to send value');
    }

    function functionCall(address target, bytes memory data)
        internal
        returns (bytes memory)
    {
        return
            functionCall(target, data, 'AddressUtils: failed low-level call');
    }

    function functionCall(
        address target,
        bytes memory data,
        string memory error
    ) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, error);
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return
            functionCallWithValue(
                target,
                data,
                value,
                'AddressUtils: failed low-level call with value'
            );
    }

    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory error
    ) internal returns (bytes memory) {
        require(
            address(this).balance >= value,
            'AddressUtils: insufficient balance for call'
        );
        return _functionCallWithValue(target, data, value, error);
    }

    function _functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory error
    ) private returns (bytes memory) {
        require(
            isContract(target),
            'AddressUtils: function call to non-contract'
        );

        (bool success, bytes memory returnData) = target.call{ value: value }(
            data
        );

        if (success) {
            return returnData;
        } else if (returnData.length > 0) {
            assembly {
                let returnData_size := mload(returnData)
                revert(add(32, returnData), returnData_size)
            }
        } else {
            revert(error);
        }
    }
}

File 6 of 12 : UintUtils.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title utility functions for uint256 operations
 * @dev derived from https://github.com/OpenZeppelin/openzeppelin-contracts/ (MIT license)
 */
library UintUtils {
    bytes16 private constant HEX_SYMBOLS = '0123456789abcdef';

    function toString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return '0';
        }

        uint256 temp = value;
        uint256 digits;

        while (temp != 0) {
            digits++;
            temp /= 10;
        }

        bytes memory buffer = new bytes(digits);

        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }

        return string(buffer);
    }

    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return '0x00';
        }

        uint256 length = 0;

        for (uint256 temp = value; temp != 0; temp >>= 8) {
            unchecked {
                length++;
            }
        }

        return toHexString(value, length);
    }

    function toHexString(uint256 value, uint256 length)
        internal
        pure
        returns (string memory)
    {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = '0';
        buffer[1] = 'x';

        unchecked {
            for (uint256 i = 2 * length + 1; i > 1; --i) {
                buffer[i] = HEX_SYMBOLS[value & 0xf];
                value >>= 4;
            }
        }

        require(value == 0, 'UintUtils: hex length insufficient');

        return string(buffer);
    }
}

File 7 of 12 : Ownable.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { IERC173 } from './IERC173.sol';
import { OwnableInternal } from './OwnableInternal.sol';
import { OwnableStorage } from './OwnableStorage.sol';

/**
 * @title Ownership access control based on ERC173
 */
abstract contract Ownable is IERC173, OwnableInternal {
    using OwnableStorage for OwnableStorage.Layout;

    /**
     * @inheritdoc IERC173
     */
    function owner() public view virtual returns (address) {
        return OwnableStorage.layout().owner;
    }

    /**
     * @inheritdoc IERC173
     */
    function transferOwnership(address account) public virtual onlyOwner {
        OwnableStorage.layout().setOwner(account);
        emit OwnershipTransferred(msg.sender, account);
    }
}

File 8 of 12 : SafeOwnableInternal.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { SafeOwnableStorage } from './SafeOwnableStorage.sol';

abstract contract SafeOwnableInternal {
    using SafeOwnableStorage for SafeOwnableStorage.Layout;

    modifier onlyNomineeOwner() {
        require(
            msg.sender == SafeOwnableStorage.layout().nomineeOwner,
            'SafeOwnable: sender must be nominee owner'
        );
        _;
    }
}

File 9 of 12 : SafeOwnableStorage.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

library SafeOwnableStorage {
    struct Layout {
        address nomineeOwner;
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.SafeOwnable');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }

    function setNomineeOwner(Layout storage l, address nomineeOwner) internal {
        l.nomineeOwner = nomineeOwner;
    }
}

File 10 of 12 : IERC173.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @title Contract ownership standard interface
 * @dev see https://eips.ethereum.org/EIPS/eip-173
 */
interface IERC173 {
    event OwnershipTransferred(
        address indexed previousOwner,
        address indexed newOwner
    );

    /**
     * @notice get the ERC173 contract owner
     * @return conract owner
     */
    function owner() external view returns (address);

    /**
     * @notice transfer contract ownership to new account
     * @param account address of new owner
     */
    function transferOwnership(address account) external;
}

File 11 of 12 : OwnableInternal.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import { OwnableStorage } from './OwnableStorage.sol';

abstract contract OwnableInternal {
    using OwnableStorage for OwnableStorage.Layout;

    modifier onlyOwner() {
        require(
            msg.sender == OwnableStorage.layout().owner,
            'Ownable: sender must be owner'
        );
        _;
    }
}

File 12 of 12 : OwnableStorage.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

library OwnableStorage {
    struct Layout {
        address owner;
    }

    bytes32 internal constant STORAGE_SLOT =
        keccak256('solidstate.contracts.storage.Ownable');

    function layout() internal pure returns (Layout storage l) {
        bytes32 slot = STORAGE_SLOT;
        assembly {
            l.slot := slot
        }
    }

    function setOwner(Layout storage l, address owner) internal {
        l.owner = owner;
    }
}

Settings
{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nomineeOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"implementation","type":"address"}],"name":"setImplementation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000a75b0237d88a967a36fac58d8740f183f75bedda

-----Decoded View---------------
Arg [0] : implementation (address): 0xa75b0237d88a967a36fac58d8740f183f75bedda

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000a75b0237d88a967a36fac58d8740f183f75bedda


Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Validator ID :
0 FTM

Amount Staked
0

Amount Delegated
0

Staking Total
0

Staking Start Epoch
0

Staking Start Time
0

Proof of Importance
0

Origination Score
0

Validation Score
0

Active
0

Online
0

Downtime
0 s
Address Amount claimed Rewards Created On Epoch Created On
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.