SqueekMiningLink to this section

struct MiningPosition {
    uint64 activeWeight;   // mining power earning now
    uint64 pendingWeight;  // full replacement power from pendingRound; 0 if none
    uint40 pendingRound;   // SqueekCore round the pending power starts earning; 0 if none
    uint48 nextMergeBlock; // completed Squeek block height at which a merge is allowed
    uint8 level;           // 0 means no live position
    uint256 lastIndex;     // reward index the credit was last caught up to
    uint256 accruedScaled; // unclaimed credit in SQK base units × 2^128
}

struct MiningState {
    uint256 minted;                      // SQK base units ever funded
    uint256 paid;                        // SQK base units ever claimed
    uint256 totalWeight;                 // active mining power across all positions
    uint256 rewardIndex;                 // cumulative scaled reward per unit of power
    uint64 closedThroughBlock;           // Squeek block height funding has passed
    uint64 lastActivationRound;          // round of the last applied power change
    uint256 weightActivationCursor;      // next queued activation to apply
    uint256 weightActivationCount;       // activations ever queued
    bool bootstrapped;
    uint64 processedThroughRound;        // last SqueekCore round funded
    uint64 closedCumulativeWork;         // SqueekCore endpoint at that round
    uint96 closedCumulativeBlockUnits;
    uint32 closedWorkPerThousandBlocks;
}

struct MiningConfiguration {
    address core;
    bytes32 streamId;
    address governance;
    address token;
    address genesisCollection;           // the Squeeks collection
    uint64 genesisTimestamp;
    uint16 genesisMaxSupply;
    uint64 maxWorkPerRound;
    uint64 minimumTimelockDelay;
    uint128 supplyCap;
    uint8 genesisMaximumLevel;
    uint32 initialWorkPerThousandBlocks;
}

struct MiningLevel { uint64 weight; uint64 cooldownBlocks; }

struct MiningCollectionPolicy {
    address nft;
    uint16 maxSupply;
    uint8 maximumLevel;
    MiningLevel[] levels;                // index 0 is level 1
}

struct MiningAccounting {
    uint256 closedResidual;              // scaled rounding leftovers from past weight epochs
    uint256 openResidual;                // scaled leftovers in the current epoch
    uint256 miningBalance;               // SQK base units SqueekMining holds
    uint256 trackedCustody;              // minted − paid, in SQK base units
}

struct MiningWeightActivation { uint64 round; uint192 addedWeight; }

struct MiningLaunchConfig {
    address core;
    bytes32 streamId;
    address governance;
    uint64 minimumTimelockDelay;
    uint64[] levelWeights;
    uint64[] cooldownBlocks;
}

function claim(MiningCollection collection, uint256[] tokenIds) external returns (uint256 paid);

function merge(MiningCollection collection, uint256 survivorId, uint256 donorId) external;

function checkpoint() external;

function position(MiningCollection collection, uint256 tokenId) external view returns (MiningPosition);

function claimable(MiningCollection collection, uint256[] tokenIds) external view returns (uint256 amount);

function checkpointStatus() external view returns (bool corePaused, uint64 nextRound, bool roundSettled);

function state() external view returns (MiningState);

function configuration() external view returns (MiningConfiguration);

function collectionPolicy(MiningCollection collection) external view returns (MiningCollectionPolicy policy);

function weightForLevel(MiningCollection collection, uint8 level) external view returns (uint64);

function cooldownBlocks(MiningCollection collection, uint8 level) external view returns (uint64);

function weightActivation(uint256 index) external view returns (MiningWeightActivation);

function accounting() external view returns (MiningAccounting result);

function REWARD_PER_BLOCK() external view returns (uint256);           // 5,600 × 10^18 SQK base units
function SUPPLY_CAP() external view returns (uint256);                 // 2,100,000,000 × 10^18
function MAX_CLAIMS() external view returns (uint256);                 // 32 IDs per claim
function MAX_CHECKPOINT_ACTIVATIONS() external view returns (uint256); // 32 power changes per checkpoint
function MAX_LEVELS() external view returns (uint256);                 // 10
function SCALE() external view returns (uint256);                      // 2^128, the scaled-credit unit

function core() external view returns (address);
function bootstrapAuthority() external view returns (address);
function proxyAdmin() external view returns (address admin);
function implementationCodeAddress() external view returns (address);
function implementationCodeVersion() external pure returns (uint64);
function implementationStorageLayoutDigest() external pure returns (bytes32);

function onMint(uint256 tokenId) external;

function initialize(MiningLaunchConfig config) external;

function completeBootstrap(address token_, address genesisNft) external;

event MiningInitialized(address indexed core, bytes32 indexed streamId, address governance);
event MiningBootstrapped(address indexed token, address indexed collection);
event CollectionPolicyUpdated(MiningCollection indexed collection, address nft, uint8 maximumLevel, uint64[] levelWeights, uint64[] cooldownBlocks);
event PositionRegistered(MiningCollection indexed collection, uint256 indexed tokenId, uint64 firstRound, uint128 weight, uint64 nextMergeBlock);
event PositionsMerged(MiningCollection indexed collection, uint256 indexed survivor, uint256 indexed donor, uint8 level, uint64 effectiveRound, uint64 nextMergeBlock, uint128 activeWeight, uint128 pendingWeight, uint256 accruedScaled);
event WeightActivated(uint64 indexed round, uint256 totalWeight, uint256 rewardIndex);
event Checkpointed(uint64 indexed afterRound, uint64 indexed throughRound, uint64 completedBlocks, uint64 cumulativeWork, uint96 cumulativeBlockUnits, uint256 amount, uint256 minted, uint64 lastActivationRound, uint256 totalWeight, uint256 rewardIndex);
event RewardsClaimed(address indexed owner, MiningCollection indexed collection, uint256 amount, uint256 remainderScaled, uint256[] tokenIds);
event Initialized(uint64 version);

Q = 1_000_000_000
intervalBlocks = floor(endBlockUnits / Q) - floor(startBlockUnits / Q)
nominalReward  = intervalBlocks * 5_600 ether
remaining      = supplyCap - minted
reward         = totalWeight == 0 ? 0 : min(nominalReward, remaining)

// read-mining.ts
import { parseAbi } from "viem";
import { blockNumber, client, required } from "./setup";
import { verifyGraph } from "./verify";

const { mining } = await verifyGraph();
const SQUEEKS = 0;
const abi = parseAbi([
  "function state() view returns ((uint256 minted, uint256 paid, uint256 totalWeight, uint256 rewardIndex, uint64 closedThroughBlock, uint64 lastActivationRound, uint256 weightActivationCursor, uint256 weightActivationCount, bool bootstrapped, uint64 processedThroughRound, uint64 closedCumulativeWork, uint96 closedCumulativeBlockUnits, uint32 closedWorkPerThousandBlocks))",
  "function position(uint8 collection, uint256 tokenId) view returns ((uint64 activeWeight, uint64 pendingWeight, uint40 pendingRound, uint48 nextMergeBlock, uint8 level, uint256 lastIndex, uint256 accruedScaled))",
  "function claimable(uint8 collection, uint256[] tokenIds) view returns (uint256)",
  "function checkpointStatus() view returns (bool corePaused, uint64 nextRound, bool roundSettled)",
]);
const tokenId = BigInt(required("TOKEN_ID"));
const read = { address: mining, abi, blockNumber } as const;
const [state, position, claimable, [corePaused, nextRound, roundSettled]] = await Promise.all([
  client.readContract({ ...read, functionName: "state" }),
  client.readContract({ ...read, functionName: "position", args: [SQUEEKS, tokenId] }),
  client.readContract({ ...read, functionName: "claimable", args: [SQUEEKS, [tokenId]] }),
  client.readContract({ ...read, functionName: "checkpointStatus" }),
]);
if (position.level === 0) throw new Error("No live position for this token ID");
console.log({
  processedThroughRound: state.processedThroughRound,
  level: position.level,
  activeWeight: position.activeWeight,
  pending: position.pendingRound === 0 ? null : { round: position.pendingRound, weight: position.pendingWeight },
  nextMergeBlock: position.nextMergeBlock,
  claimableBaseUnits: claimable,
  checkpoint: { corePaused, nextRound, roundSettled },
});