Bridging PeakeCoin (PEK) from Hive Engine to Polygon — A Rough-Draft That Works

I hit a wall trying to use Hive Engine’s built-in swap flow after PEK was already live. So I rolled up my sleeves and built a lightweight, custodial bridge to get PEK moving between Hive Engine → Polygon. It’s intentionally simple, rate-limited by my on-hand liquidity, and designed to be audited at a glance. This is a rough draft — but it works.

Repo: https://github.com/PaulMoon410/hiveengine_polygon
Polygon token (custom token for wallets):

• Name: PeakeCoin
• Symbol: PEK
• Contract: 0x6fc99183BF5997AC774c8827E4eA96a67F477d5f
• Decimals: 18

---

TL;DR (User Flow)

1. On Hive Engine: send PEK to peakecoin.matic and put your Polygon address as the memo (must look like 0x... and be exactly 42 characters).
2. On Polygon: you’ll receive PEK (ERC-20) at that address. Add the custom token in MetaMask (Polygon network) or any EVM wallet that supports custom tokens using the contract above.
3. This is rate-limited / liquidity-limited by design. Liquidity is small while testing to guard against abuse.

---

How the Bridge Works (Under the Hood)

1) A monitor tails Hive Engine transfers

A Python script polls Hive Engine’s history to find incoming PEK transfers to peakecoin.matic. It writes each valid transfer to a JSONL log for the distributor to pick up. It also includes simple CLI helpers to check recent history or specific blocks.

• History query filters for symbol == "PEK" and transfer operations.
• Streaming mode prints polls with timestamps and writes transactions to pek_transactions.jsonl with deduping.
• Extras: latest shows the latest block; blocks dumps a range for debugging.

2) A distributor sends token transfers on Polygon

A second Python script watches pek_transactions.jsonl, validates each entry, and if the memo is a valid Polygon address, sends an ERC-20 transfer from the bridge wallet to that address. Amounts are converted to 18 decimals (× 1e18) to match the PEK ERC-20. Confirmed txids are recorded to a processed set (pol_dist_processed.txt) so nothing gets double-paid.

• RPC / Wallet: connects to a Polygon RPC, reads the private key from polygon_private_key.txt, and signs/sends raw transactions.
• Guardrails:
  • Skips if memo isn’t a 0x-address or wrong length.
  • Waits for on-chain receipt; only then marks as processed.
  • Sleeps between items to avoid spamming the network.

3) A tiny “orchestrator” runs both at once

A short launcher spins up two threads: one for the monitor and one for the distributor, prefixing the output so you can tail both in one terminal.

---

Quickstart (Developer / Operator)

Requirements: Python 3.10+, install web3 and requests. Keep your Polygon key safe.

1. Clone:
   $ git clone https://github.com/PaulMoon410/hiveengine_polygon
   $ cd hiveengine_polygon

2. (Optional) Virtualenv:
   $ python -m venv .venv
   $ source .venv/bin/activate (Windows: .venv\Scripts\activate)

3. Install deps:
   $ pip install -r requirements.txt
   (or: $ pip install web3 requests)

4. Provide your Polygon private key:
   $ echo "YOUR_PRIVATE_KEY" > polygon_private_key.txt
   $ chmod 600 polygon_private_key.txt

5. Launch both services (monitor + distributor):
   $ python pek_pol.py

Run separately if you prefer:

• Window A (monitor): $ python monitor_peakecoin.py monitor --poll 10
• Window B (distributor): $ python pol_dist.py

Note: Amount handling uses 18 decimals: quantity × 1e18.

---

Using the Bridge (User Guide)

1. In your Hive wallet, transfer PEK to peakecoin.matic.

   • Memo must be your Polygon address (e.g., 0x185d...95c9). If the memo isn’t a valid 0x address of length 42, it will be skipped.

2. In MetaMask (Polygon) or a compatible wallet, Add Token:

   • Contract: 0x6fc99183BF5997AC774c8827E4eA96a67F477d5f
   • Symbol: PEK
   • Decimals: 18

3. Wait for the bot to detect your transfer and send the matching PEK (ERC-20). The script waits for confirmation before marking your Hive tx as processed.

Note: Liquidity is limited while testing to throttle abuse and ensure stability. Large transfers may not clear until there’s enough on the Polygon side.

---

Architecture at a Glance

• Hive Engine Ingest: monitor_peakecoin.py → polls history, filters symbol/op, logs JSONL.
• Distributor: pol_dist.py → validates, converts amount to 18 decimals, sends ERC-20 transfer, persists processed txids.
• Supervisor: pek_pol.py → launches both with prefixed output for easy ops.

---

Trust, Risks, and Guardrails (Read This)

• Custodial & Trusted: This design does not lock/burn on Hive; it relies on the operator’s Polygon wallet to deliver PEK. Until we wire up a fully trust-minimized flow, you are trusting the distributor to run honestly and continuously.
• Validation: Memos must be valid Polygon addresses. No address in memo = no payout.
• Replay Protection: Every processed Hive txid is stored in pol_dist_processed.txt. If a Polygon tx fails, it isn’t marked processed and can be retried.
• Rate Limiting: Small liquidity and paced processing prevent surge abuse while we iterate.
• Key Management: Polygon private key is read from polygon_private_key.txt. Lock this file down (0600). Consider env-vars or a keystore in the next revision.

---

Roadmap

• Better Safety:

  • Daily caps per address; min/max per tx; allowlist/denylist toggles.
  • Secrets in a keystore; metrics/health checks.

• Swap UX:

  • Simple web page: paste Polygon address → instructions + live status.

• Reverse Direction (Polygon → Hive):

  • Watch Polygon transfers in → queue → issue PEK on Hive to sender (or memo’d Hive user).
  • Add proofs and a ledger for bidirectional accounting.

• Trust Minimization:

  • Lock/mint semantics, proofs of burn/lock, multisig bridge wallet, auditable escrow.

---

FAQ

Q: Why memo=address?
A: It makes the user’s intent explicit and keeps parsing trivial. The distributor only pays if the memo looks like a proper 0x address.

Q: Decimals on Polygon?
A: ERC-20 uses 18 decimals; quantities are multiplied by 1e18 before sending.

Q: Can I use Atomic Wallet?
A: If your wallet supports Polygon custom tokens, you can track PEK by adding the contract above. MetaMask on Polygon definitely works.

Q: What happens if my Polygon tx fails?
A: The script waits for a receipt; if it’s not successful, that Hive txid isn’t marked processed, so it can be retried later.

---

Final Notes

This is a pragmatic bridge to unblock movement while we design something more robust. If you test it, start small, double-check the memo address, and share any edge cases you hit. I’ll keep improving the code and liquidity as we go.