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.
Any wallet can register a game without an approval committee.
Creator, treasury, and burn settlement occur in one confirmed transaction.
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.
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.
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.
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.
Sent directly to the game payout wallet. No platform custody or payout period.
Sent to the platform treasury for operations and liquidity maintenance.
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.
| Role | Address | Evidence |
|---|---|---|
| PLUG Token | 0x39801De9D63234D3Cb1344b9df46727001085F4F | BscScan ↗ |
| PlugPointVendor | 0xa5B85f726eFFc7513CA67f8984F8b3cd9C88CE70 | Verified code ↗ |
| PlugPointGateway | 0x0ADD4F526A4e512EAfF46208B45FF298A78a8c09 | Verified code ↗ |
| BSC-USD (USDT) | 0x55d398326f99059fF775485246999027B3197955 | BscScan ↗ |
| PancakeSwap V2 Pair | 0x5099f26E4E83C3C315c7aAA30b40a52a50BbB8b0 | Pair ↗ |
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.
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
}
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.