Verified on BNB Smart Chain Mainnet

PlugPoint Protocol
Whitepaper v1.0

An open game-point and atomic revenue-sharing gateway for AI-generated games, independent studios, and community servers.

Mainnet specification · Chain ID 56 · Fixed initial supply 1,000,000,000 PLUG · Published 18 November 2026

Chapter 1

Vision and the problem PlugPoint solves

Independent games, AI-built experiences, and community servers often face the same bottleneck: payment integration is expensive, platform rules are fragmented, and settlement can take weeks. Conventional distribution channels may charge 30%–50% when payment, publishing, and promotion fees are combined.

PlugPoint separates the game economy from any single storefront. Developers register a game permissionlessly, receive an on-chain App ID, accept one interoperable utility point, and settle each purchase directly to the configured creator wallet. There is no internal account balance for the platform to hold and no manual payout queue.

Permissionless

Any wallet can register a game without an approval committee.

Atomic

Creator, treasury, and burn settlement occur in one confirmed transaction.

Auditable

Supply, game volume, events, reserves, and contract code are public on BSC.

Chapter 2

Dual-channel capital loop

PlugPoint uses two complementary channels. The official Vendor gives players deterministic inventory-backed access to PLUG at the current on-chain rate. The public PancakeSwap V2 pair gives creators and holders an open market exit to BSC USDT.

PLAYER IN

Official Vendor

USDT is transferred directly to the protocol treasury while pre-funded PLUG inventory is delivered to the player. Current rate: 1 USDT = 10 PLUG.

⇄
CREATOR OUT

PancakeSwap V2

Creators can swap earned PLUG against the public PLUG/USDT pool. Quotes are market-driven and subject to reserve depth, price impact, and slippage.

The Vendor rate is an owner-configurable contract parameter, not a fiat peg or redemption promise. The AMM price can diverge from the Vendor reference rate.

Chapter 3

Token economics and 80 / 15 / 5 settlement

PLUG has an initial fixed supply of 1,000,000,000 tokens, 18 decimals, zero transfer tax, and no mint function. Each Gateway spend divides the exact amount atomically.

80%
15%
5%
Creator settlement

Sent directly to the game payout wallet. No platform custody or payout period.

Protocol share

Sent to the platform treasury for operations and liquidity maintenance.

Permanent burn

Destroyed through burnFrom, reducing totalSupply permanently.

S = player spend

C = S − (S × 0.15) − (S × 0.05)

P = S × 0.15

B = S × 0.05

Tn = T0 − ΣB

Creator share is computed as the exact rounding remainder, so creator + platform + burn always equals the submitted amount.

If the burn rate remains 5%, cumulative spend can be estimated as (1,000,000,000 − totalSupply) ÷ 0.05.

Burn reduces outstanding token supply and therefore lowers nominal future obligations; it does not create USDT by itself. Actual cash-out capacity comes from PancakeSwap reserves and treasury policy, which must be measured separately.

Chapter 4

Mainnet contracts and security design

The following addresses are the canonical BNB Smart Chain Mainnet deployment. Integrations must pin Chain ID 56 and verify events only from these contracts.

RoleAddressEvidence
PLUG Token0x39801De9D63234D3Cb1344b9df46727001085F4FBscScan ↗
PlugPointVendor0xa5B85f726eFFc7513CA67f8984F8b3cd9C88CE70Verified code ↗
PlugPointGateway0x0ADD4F526A4e512EAfF46208B45FF298A78a8c09Verified code ↗
BSC-USD (USDT)0x55d398326f99059fF775485246999027B3197955BscScan ↗
PancakeSwap V2 Pair0x5099f26E4E83C3C315c7aAA30b40a52a50BbB8b0Pair ↗

Pair creation transaction: 0x272d572927162c8b599f59542f9f53ffcd5e53de969e879f35c8b2b8f8c6f9a8 ↗

Confirmed block: 134154981

Initial pool: 30 PLUG + 3 USDT

Security properties and administrator powers

  • Token supply is fixed at deployment; the token exposes no mint function and applies no transfer tax.
  • Gateway uses ReentrancyGuard, Pausable, SafeERC20, a 25% platform-fee cap, and a 10% burn cap.
  • Vendor transfers USDT directly to treasury and can sell only PLUG already held in its inventory.
  • Operational roles are address-separated: treasury and LP deployer are distinct. Off-chain cold-storage practices cannot be proven by contracts alone.
Administrator disclosure: the Vendor owner can change its rate and treasury, pause sales, and withdraw unsold inventory. The Gateway owner can change fees within hard caps, change treasury, and pause spending. Users should monitor these settings on-chain.

Chapter 5

Game developer 3-minute quickstart

The deployed ABI uses registerGame and spendPoints. Functions named registerApp or spend do not exist on the canonical Gateway. Parse confirmed events instead of predicting an App ID or trusting a pending transaction.

Step 1 — Solidity interfaces

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

interface IERC20Minimal {
    function approve(address spender, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
}

interface IPlugPointGateway {
    event GameRegistered(
        uint256 indexed appId,
        address indexed owner,
        address payoutWallet,
        string metadataUri
    );

    event PointsSpent(
        uint256 indexed appId,
        address indexed player,
        uint256 totalAmount,
        uint256 creatorShare,
        uint256 platformShare,
        uint256 burnedAmount,
        string orderId
    );

    function registerGame(address payoutWallet, string calldata metadataUri)
        external returns (uint256 appId);

    function spendPoints(uint256 appId, uint256 amount, string calldata orderId)
        external;
}

Step 2 — Register and charge with ethers.js v6

import { BrowserProvider, Contract, parseUnits } from "ethers";

const CHAIN_ID = 56n;
const PLUG = "0x39801De9D63234D3Cb1344b9df46727001085F4F";
const GATEWAY = "0x0ADD4F526A4e512EAfF46208B45FF298A78a8c09";

const erc20Abi = [
  "function allowance(address,address) view returns (uint256)",
  "function approve(address,uint256) returns (bool)"
];
const gatewayAbi = [
  "function registerGame(address,string) returns (uint256)",
  "function games(uint256) view returns (address,address,string,bool,uint256)",
  "function spendPoints(uint256,uint256,string)",
  "event GameRegistered(uint256 indexed appId,address indexed owner,address payoutWallet,string metadataUri)",
  "event PointsSpent(uint256 indexed appId,address indexed player,uint256 totalAmount,uint256 creatorShare,uint256 platformShare,uint256 burnedAmount,string orderId)"
];

async function contracts() {
  if (!window.ethereum) throw new Error("EVM wallet not found");
  const provider = new BrowserProvider(window.ethereum);
  await provider.send("eth_requestAccounts", []);
  const network = await provider.getNetwork();
  if (network.chainId !== CHAIN_ID) throw new Error("Switch to BSC Mainnet");
  const signer = await provider.getSigner();
  return {
    signer,
    plug: new Contract(PLUG, erc20Abi, signer),
    gateway: new Contract(GATEWAY, gatewayAbi, signer)
  };
}

export async function registerMyGame(payoutWallet, metadataUri) {
  const { gateway } = await contracts();
  const tx = await gateway.registerGame(payoutWallet, metadataUri);
  const receipt = await tx.wait();
  for (const log of receipt.logs) {
    try {
      const event = gateway.interface.parseLog(log);
      if (event?.name === "GameRegistered") return event.args.appId;
    } catch {}
  }
  throw new Error("Confirmed transaction has no GameRegistered event");
}

export async function spendPlug(appId, amountPlug, orderId) {
  const { signer, plug, gateway } = await contracts();
  const player = await signer.getAddress();
  const amount = parseUnits(amountPlug, 18);
  const game = await gateway.games(appId);
  if (!game[3]) throw new Error("Game is inactive");

  if ((await plug.allowance(player, GATEWAY)) < amount) {
    await (await plug.approve(GATEWAY, amount)).wait();
  }
  const tx = await gateway.spendPoints(appId, amount, orderId);
  return await tx.wait();
}

Step 3 — Verify settlement in a web3.js backend

import Web3 from "web3";

const web3 = new Web3("https://bsc-dataseed.binance.org/");
const gatewayAddress = "0x0ADD4F526A4e512EAfF46208B45FF298A78a8c09";
const pointsSpentAbi = [{
  type: "event", name: "PointsSpent", anonymous: false,
  inputs: [
    { indexed: true, name: "appId", type: "uint256" },
    { indexed: true, name: "player", type: "address" },
    { indexed: false, name: "totalAmount", type: "uint256" },
    { indexed: false, name: "creatorShare", type: "uint256" },
    { indexed: false, name: "platformShare", type: "uint256" },
    { indexed: false, name: "burnedAmount", type: "uint256" },
    { indexed: false, name: "orderId", type: "string" }
  ]
}];
const gateway = new web3.eth.Contract(pointsSpentAbi, gatewayAddress);

export async function verifyPayment(txHash, expected) {
  const receipt = await web3.eth.getTransactionReceipt(txHash);
  if (!receipt?.status || receipt.to?.toLowerCase() !== gatewayAddress.toLowerCase()) {
    throw new Error("Not a confirmed Gateway transaction");
  }
  const events = await gateway.getPastEvents("PointsSpent", {
    fromBlock: receipt.blockNumber,
    toBlock: receipt.blockNumber
  });
  const paid = events.find((event) =>
    event.transactionHash.toLowerCase() === txHash.toLowerCase() &&
    event.returnValues.appId === String(expected.appId) &&
    event.returnValues.player.toLowerCase() === expected.player.toLowerCase() &&
    event.returnValues.orderId === expected.orderId
  );
  if (!paid) throw new Error("Matching PointsSpent event not found");
  return paid.returnValues; // persist txHash + logIndex as an idempotency key
}
Production checklist

Require Chain ID 56, wait for confirmations appropriate to item value, verify the canonical Gateway address and every event field, enforce uniqueness on orderId and transactionHash:logIndex, and handle chain reorganizations before delivering valuable items.

Chapter 6

Risk disclosure and disclaimer

  • PLUG is designed as a utility game point. This document is technical information, not investment, legal, tax, or financial advice, and does not promise profit or redemption.
  • The initial PancakeSwap pool was created with 30 PLUG and 3 USDT. That is shallow liquidity: even modest trades can produce material price impact. Always inspect the live quote and slippage; split larger swaps.
  • Smart contracts, RPC providers, wallets, frontends, administrator keys, stablecoins, and AMMs each carry technical or operational risk. Verified source code does not eliminate all vulnerabilities.
  • Developers are responsible for local consumer, gaming, tax, sanctions, privacy, and virtual-asset compliance. Valuable randomness requires an audited commit-reveal or VRF design; the website demo is not verifiable randomness.

LICENSE & COPYRIGHT

Copyright ownership and platform disclaimer

Brand & content copyright

The PlugPoint name, visual identity, website interface design, and Whitepaper are copyrighted by PlugPoint Protocol. They may not be reproduced without authorization or used for impersonation, phishing, or deceptive websites.

Developer SDK license

Under the MIT License, external game developers may freely use, modify, and integrate the PlugPointGateway and PlugPointVendor contract interfaces and official example code into commercial or non-commercial game projects.

Third-party IP & independent liability

PlugPoint is a neutral on-chain point-settlement protocol. Intellectual-property rights in third-party games, servers, and digital content remain with their respective creators. Each creator bears sole responsibility for content compliance and copyright disputes; PlugPoint Protocol assumes no joint or derivative liability for third-party content.