PulseChain Explorer - BlockScout

Contract Address

Is Yul contract

No

Yes

Contract Name

Include nightly builds

No

Yes

Compiler

EVM Version

Optimization

No

Yes

Optimization runs

Enter the Solidity Contract Code

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

/**
 * @title PBt.sol - Perpetual Bitcoin Tracker NFT (ERC721)
 * @author PB Team
 * @notice Non-transferable ERC721 that tracks each purchase as a unique NFT.
 * Stores purchase metadata: buy price, unlock history, recovery/inheritance data.
 * Only Vault can mint/burn. Users cannot trade PBt (non-transferable).
 * Burned when position fully redeemed (dust threshold reached).
 */

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Burnable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

// ============================================================================
// INTERFACES
// ============================================================================

interface IVault {
    // Marker interface - just to verify Vault can call mint/burn
}

// ============================================================================
// PBt CONTRACT
// ============================================================================

/**
 * @title PBt - Perpetual Bitcoin Tracker NFT
 * @dev ERC721 non-transferable NFT. Each purchase = 1 PBt with unique ID.
 * Tracks buy price, unlock tranches, recovery/inheritance addresses, and dust.
 */
contract PBt is ERC721, ERC721Burnable, ReentrancyGuard {
    address public immutable DEPLOYER;

// ========================================================================
    // IMMUTABLE STATE (after lockVault() called)
    // ========================================================================

address public VAULT;           // Immutable after lockVault()
    bool public vaultLocked;        // Prevents re-locking

// ========================================================================
    // DATA STRUCTURES
    // ========================================================================

/**
     * @notice Complete purchase metadata stored in each PBt NFT
     */
    struct PBtMetadata {
        // Purchase info
        address owner;                          // Original buyer (immutable)
        uint256 buyPrice;                       // Entry price in USD cents (immutable)
        uint256 buyBlockNumber;                 // Block when purchase occurred (immutable)
        uint256 buyTimestamp;                   // Timestamp when purchased (immutable)

// Allocation info
        uint256 allocatedPB;                    // Total PB allocated to this position
        uint256 allocatedPBc;                   // Total PBc allocated to this position
        uint256 paidoutPB;                      // PB already paid out via unlocks
        uint256 paidoutPBc;                     // PBc already redeemed

// Unlock history
        uint256[] unlockedAmounts;              // Amount unlocked at each tranche
        uint256[] unlockBlockNumbers;           // Block number of each unlock
        uint256[] unlockTimestamps;             // Timestamp of each unlock
        uint256[] unlockPrices;                 // Price at time of unlock

// Dust tracking
        uint256 dustRemaining;                  // Last bit of PBc that couldn't be swapped
        bool isDustBurned;                      // Flag: position fully liquidated

// Recovery/Inheritance
        address recoveryAddress;                // Fallback recovery address
        address inheritanceAddress;             // Succession override address
        bool recoveryActivated;                 // One-time recovery flag
        bool inheritanceActivated;              // One-time inheritance flag
    }

// ========================================================================
    // MUTABLE STATE
    // ========================================================================

mapping(uint256 => PBtMetadata) public pbtMetadata;      // tokenId → metadata
    mapping(address => uint256[]) public userTokenIds;       // user → array of owned tokenIds

// ========================================================================
    // EVENTS
    // ========================================================================

event PBtMinted(
        uint256 indexed tokenId,
        address indexed owner,
        uint256 allocatedPB,
        uint256 allocatedPBc,
        uint256 buyPrice
    );

event UnlockRecorded(
        uint256 indexed tokenId,
        uint256 indexed unlockIndex,
        uint256 unlockedAmount,
        uint256 unlockPrice
    );

event DustRecorded(
        uint256 indexed tokenId,
        uint256 dustAmount
    );

event PBtBurned(
        uint256 indexed tokenId,
        uint256 finalDust
    );

event RecoveryAddressUpdated(
        uint256 indexed tokenId,
        address indexed recoveryAddress
    );

event InheritanceAddressUpdated(
        uint256 indexed tokenId,
        address indexed inheritanceAddress
    );

event RecoveryActivated(
        uint256 indexed tokenId,
        address indexed newOwner
    );

event InheritanceActivated(
        uint256 indexed tokenId,
        address indexed newOwner
    );

// ========================================================================
    // CONSTRUCTOR
    // ========================================================================

/**
     * @notice Deploy PBt tracker NFT
     * VAULT will be set via lockVault() after deployment
     */
    constructor() ERC721("Perpetual Bitcoin Tracker", "PBt") {
        DEPLOYER = msg.sender;
        // VAULT set via lockVault()
    }

/**
     * @notice Lock VAULT address permanently (one-time only)
     * @param _vault Vault contract address
     */
    function lockVault(address _vault) external {
        require(msg.sender == DEPLOYER, "Only deployer");
        require(!vaultLocked, "Vault already locked");
        require(VAULT == address(0), "Vault already set");
        require(_vault != address(0), "Invalid vault");
        
        VAULT = _vault;
        vaultLocked = true;
    }

// ========================================================================
    // MINT FUNCTION (Vault-Only)
    // ========================================================================

/**
     * @notice Mint new tracker NFT for a purchase
     * Only Vault can call this during presale allocation or regular buy
     *
     * @param to Recipient (buyer) address
     * @param tokenId Unique NFT ID (from Vault's counter)
     * @param buyPrice Entry price in USD cents (immutable)
     * @param allocatedPB Total PB for this purchase
     * @param allocatedPBc Total PBc for this purchase
     */
    function mint(
        address to,
        uint256 tokenId,
        uint256 buyPrice,
        uint256 allocatedPB,
        uint256 allocatedPBc
    ) external onlyVault nonReentrant {
        require(to != address(0), "Invalid recipient");
        require(buyPrice > 0, "Invalid buy price");
        require(allocatedPB > 0, "Invalid PB allocation");
        require(allocatedPBc > 0, "Invalid PBc allocation");

// Mint the NFT
        _mint(to, tokenId);

// Create metadata
        pbtMetadata[tokenId] = PBtMetadata({
            owner: to,
            buyPrice: buyPrice,
            buyBlockNumber: block.number,
            buyTimestamp: block.timestamp,
            allocatedPB: allocatedPB,
            allocatedPBc: allocatedPBc,
            paidoutPB: 0,
            paidoutPBc: 0,
            unlockedAmounts: new uint256[](0),
            unlockBlockNumbers: new uint256[](0),
            unlockTimestamps: new uint256[](0),
            unlockPrices: new uint256[](0),
            dustRemaining: 0,
            isDustBurned: false,
            recoveryAddress: address(0),
            inheritanceAddress: address(0),
            recoveryActivated: false,
            inheritanceActivated: false
        });

// Track ownership
        userTokenIds[to].push(tokenId);

emit PBtMinted(tokenId, to, allocatedPB, allocatedPBc, buyPrice);
    }

// ========================================================================
    // UNLOCK FUNCTIONS (Vault-Only)
    // ========================================================================

/**
     * @notice Record an unlock tranche
     * Called by Vault after successful unlock execution
     *
     * @param tokenId PBt ID
     * @param unlockedAmount PB amount unlocked
     * @param unlockPrice Price at unlock trigger
     */
    function recordUnlock(
        uint256 tokenId,
        uint256 unlockedAmount,
        uint256 unlockPrice
    ) external onlyVault nonReentrant {
        require(_exists(tokenId), "PBt does not exist");
        require(unlockedAmount > 0, "Invalid unlock amount");
        require(unlockPrice > 0, "Invalid unlock price");

PBtMetadata storage meta = pbtMetadata[tokenId];

// Verify we're not over-allocating
        uint256 newPaidout = meta.paidoutPB + unlockedAmount;
        require(newPaidout <= meta.allocatedPB, "Unlock exceeds allocation");

// Record the unlock
        meta.paidoutPB = newPaidout;
        meta.unlockedAmounts.push(unlockedAmount);
        meta.unlockBlockNumbers.push(block.number);
        meta.unlockTimestamps.push(block.timestamp);
        meta.unlockPrices.push(unlockPrice);

emit UnlockRecorded(tokenId, meta.unlockedAmounts.length - 1, unlockedAmount, unlockPrice);
    }

/**
     * @notice Record dust (remainder PBc that couldn't be fully converted)
     * Called by Vault when position reaches dust threshold
     *
     * @param tokenId PBt ID
     * @param dustAmount Final dust amount in wei
     */
    function recordDust(uint256 tokenId, uint256 dustAmount) external onlyVault {
        require(_exists(tokenId), "PBt does not exist");

PBtMetadata storage meta = pbtMetadata[tokenId];
        meta.dustRemaining = dustAmount;

emit DustRecorded(tokenId, dustAmount);
    }

// ========================================================================
    // BURN FUNCTION (Vault-Only)
    // ========================================================================

/**
     * @notice Burn tracker NFT when position fully redeemed
     * Called by Vault when dust threshold reached and position closed
     *
     * @param tokenId PBt ID to burn
     */
    function burnTracker(uint256 tokenId) external onlyVault {
        require(_exists(tokenId), "PBt does not exist");

PBtMetadata storage meta = pbtMetadata[tokenId];
        meta.isDustBurned = true;

address owner = ownerOf(tokenId);
        _removeTokenFromUser(owner, tokenId);

// Burn the NFT
        _burn(tokenId);

emit PBtBurned(tokenId, meta.dustRemaining);
    }

// ========================================================================
    // RECOVERY/INHERITANCE FUNCTIONS (Vault-Only)
    // ========================================================================

/**
     * @notice Set recovery address for a position
     * Called by Vault after user password-protection setup
     *
     * @param tokenId PBt ID
     * @param recoveryAddress Fallback recipient
     */
    function setRecoveryAddress(uint256 tokenId, address recoveryAddress) external onlyVault {
        require(_exists(tokenId), "PBt does not exist");
        require(recoveryAddress != address(0), "Invalid recovery address");

pbtMetadata[tokenId].recoveryAddress = recoveryAddress;

emit RecoveryAddressUpdated(tokenId, recoveryAddress);
    }

/**
     * @notice Set inheritance address for a position
     * Called by Vault after user password-protection setup
     *
     * @param tokenId PBt ID
     * @param inheritanceAddress Succession override
     */
    function setInheritanceAddress(uint256 tokenId, address inheritanceAddress) external onlyVault {
        require(_exists(tokenId), "PBt does not exist");
        require(inheritanceAddress != address(0), "Invalid inheritance address");

pbtMetadata[tokenId].inheritanceAddress = inheritanceAddress;

emit InheritanceAddressUpdated(tokenId, inheritanceAddress);
    }

/**
     * @notice Activate recovery (transfer ownership to recovery address)
     * Called by Vault after password verification and inactivity period
     *
     * @param tokenId PBt ID
     */
    function activateRecovery(uint256 tokenId) external onlyVault nonReentrant {
        require(_exists(tokenId), "PBt does not exist");

PBtMetadata storage meta = pbtMetadata[tokenId];
        require(meta.recoveryAddress != address(0), "No recovery address set");
        require(!meta.recoveryActivated, "Recovery already activated");

address oldOwner = meta.owner;
        address newOwner = meta.recoveryAddress;

// Update metadata (ownership + activation flag)
        meta.owner = newOwner;
        meta.recoveryActivated = true;

// Update user token list
        _removeTokenFromUser(oldOwner, tokenId);

// Burn old NFT (ERC721 ledger: oldOwner loses it)
        _burn(tokenId);

// Remint NFT with same tokenId to new owner (ERC721 ledger: newOwner receives it)
        // All metadata is preserved in pbtMetadata[tokenId]
        _mint(newOwner, tokenId);
        userTokenIds[newOwner].push(tokenId);

emit RecoveryActivated(tokenId, newOwner);
    }

/**
     * @notice Activate inheritance (transfer ownership to inheritance address)
     * Called by Vault after password verification
     * Takes precedence over recovery
     *
     * @param tokenId PBt ID
     */
    function activateInheritance(uint256 tokenId) external onlyVault nonReentrant {
        require(_exists(tokenId), "PBt does not exist");

PBtMetadata storage meta = pbtMetadata[tokenId];
        require(meta.inheritanceAddress != address(0), "No inheritance address set");
        require(!meta.inheritanceActivated, "Inheritance already activated");

address oldOwner = meta.owner;
        address newOwner = meta.inheritanceAddress;

// Update metadata (ownership + activation flag)
        meta.owner = newOwner;
        meta.inheritanceActivated = true;

// Update user token list
        _removeTokenFromUser(oldOwner, tokenId);

// Burn old NFT (ERC721 ledger: oldOwner loses it)
        _burn(tokenId);

// Remint NFT with same tokenId to new owner (ERC721 ledger: newOwner receives it)
        // All metadata is preserved in pbtMetadata[tokenId]
        _mint(newOwner, tokenId);
        userTokenIds[newOwner].push(tokenId);

emit InheritanceActivated(tokenId, newOwner);
    }

// ========================================================================
    // VIEW FUNCTIONS
    // ========================================================================

/**
     * @notice Get complete metadata for a PBt
     * @param tokenId PBt ID
     * @return Metadata struct
     */
    function getMetadata(uint256 tokenId) external view returns (PBtMetadata memory) {
        require(_exists(tokenId), "PBt does not exist");
        return pbtMetadata[tokenId];
    }

/**
     * @notice Get all unlock history for a position
     * @param tokenId PBt ID
     * @return unlockedAmounts Array of unlock amounts
     * @return unlockBlockNumbers Array of unlock block numbers
     * @return unlockTimestamps Array of unlock timestamps
     * @return unlockPrices Array of unlock prices
     */
    function getUnlockHistory(uint256 tokenId)
        external
        view
        returns (
            uint256[] memory unlockedAmounts,
            uint256[] memory unlockBlockNumbers,
            uint256[] memory unlockTimestamps,
            uint256[] memory unlockPrices
        )
    {
        require(_exists(tokenId), "PBt does not exist");

PBtMetadata memory meta = pbtMetadata[tokenId];
        return (
            meta.unlockedAmounts,
            meta.unlockBlockNumbers,
            meta.unlockTimestamps,
            meta.unlockPrices
        );
    }

/**
     * @notice Get all PBt tokens owned by a user
     * @param user User address
     * @return Array of token IDs
     */
    function getUserTokenIds(address user) external view returns (uint256[] memory) {
        return userTokenIds[user];
    }

/**
     * @notice Get number of PBt tokens owned by a user
     * @param user User address
     * @return Count
     */
    function getUserTokenCount(address user) external view returns (uint256) {
        return userTokenIds[user].length;
    }

/**
     * @notice Check if a PBt exists
     * @param tokenId PBt ID
     * @return True if exists
     */
    function exists(uint256 tokenId) external view returns (bool) {
        return _exists(tokenId);
    }

// ========================================================================
    // TRANSFER RESTRICTIONS (Non-Transferable)
    // ========================================================================

/**
     * @notice Override burn to prevent direct user burning
     * Only Vault can burn PBt via burnTracker() function
     */
    function burn(uint256 tokenId) public override {
        revert("PBt: Use Vault for burning");
    }

/**
     * @notice Override transfer to prevent user-to-user trades
     * PBt cannot be transferred between users (non-transferable)
     */
    // `transfer` is not part of ERC721 interface; prevent accidental usage by reverting

/**
     * @notice Override transferFrom to prevent user-to-user trades
     * Only Vault can transfer PBt internally (via recovery/inheritance)
     */
    function transferFrom(address, address, uint256) public override {
        revert("PBt: Non-transferable");
    }

/**
     * @notice Override safeTransferFrom to prevent user-to-user trades
     */
    function safeTransferFrom(address, address, uint256) public override {
        revert("PBt: Non-transferable");
    }

/**
     * @notice Override safeTransferFrom to prevent user-to-user trades
     */
    function safeTransferFrom(address, address, uint256, bytes memory) public override {
        revert("PBt: Non-transferable");
    }

/**
     * @notice Override approve to prevent approval attacks
     */
    function approve(address, uint256) public override {
        revert("PBt: Cannot approve");
    }

/**
     * @notice Override setApprovalForAll to prevent approval attacks
     */
    function setApprovalForAll(address, bool) public override {
        revert("PBt: Cannot approve");
    }

// ========================================================================
    // INTERNAL HELPER FUNCTIONS
    // ========================================================================

/**
     * @notice Remove token from user's list (helper for recovery/inheritance)
     * @param user User address
     * @param tokenId Token to remove
     */
    function _removeTokenFromUser(address user, uint256 tokenId) internal {
        uint256[] storage tokens = userTokenIds[user];
        for (uint256 i = 0; i < tokens.length; i++) {
            if (tokens[i] == tokenId) {
                // Swap with last element and pop
                tokens[i] = tokens[tokens.length - 1];
                tokens.pop();
                return;
            }
        }
    }

/**
     * @notice Check if token exists (internal helper)
     * @param tokenId Token ID
     * @return True if exists
     */
    function _exists(uint256 tokenId) internal view override returns (bool) {
        return super._exists(tokenId);
    }

// ========================================================================
    // ACCESS CONTROL
    // ========================================================================

modifier onlyVault() {
        require(msg.sender == VAULT, "Only Vault can call");
        _;
    }

// ========================================================================
    // METADATA OVERRIDES
    // ========================================================================

/**
     * @notice Return tokenURI with JSON metadata and image
     */
    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        require(_exists(tokenId), "PBt does not exist");
        
        return string(
            abi.encodePacked(
                "data:application/json;utf8,{",
                '"name":"PB Tracker #', _toString(tokenId), '",',
                '"description":"Perpetual Bitcoin Position Tracker NFT. Visit perpetualbitcoin.io for details.",',
                '"image":"https://azure-rational-salmon-152.mypinata.cloud/ipfs/bafybeiclvfm6pqd4rozhffhewfndebxv3s6f2z5t3xsmirchyda3lg7e54/PBt.png"',
                "}"
            )
        );
    }
    
    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);
    }
}

Try to fetch constructor arguments automatically

No

Yes

ABI-encoded Constructor Arguments (if required by the contract)

New Solidity Smart Contract Verification

Contract Libraries