potato-tipper

Skill for AI agents to setup the Potato Tipper on a Universal Profile on LUKSO (requires private key), and learn to build innovative tip-on-follow solutions.

Safety Notice

This listing is from the official public ClawHub registry. Review SKILL.md and referenced scripts before running.

Copy this and send it to your AI assistant to learn

Install skill "potato-tipper" with this command: npx skills add CJ42/potato-tipper

Potato Tipper - OpenClaw Skill

Use this skill for anything technical around the Potato Tipper contracts repo:

  • 📖 reading/understanding the Potato Tipper protocol
  • ⚙️ setup + configure the Potato Tipper on your Universal Profile on LUKSO UP configuration
  • ❓ permissions troubleshooting when setting up
  • 💡building new tipping systems using ideas from the Potato Tipper

What it is (1-paragraph mental model)

The Potato Tipper protocol is an LSP1 Universal Receiver Delegate on LUKSO that automatically tips $POTATO tokens to new followers.

PotatoTipper is an LSP1 Universal Receiver Delegate that reacts to LSP26 follow/unfollow notifications and transfers LSP7 $POTATO tokens from the followed user's 🆙 to the new follower 🆙 (when eligible). Per-user settings live in ERC725Y storage under a dedicated data key, and the contract provides self-documenting helper views for config keys.

What this skill provides

  • Understand architecture and LUKSO/LSP integrations (LSP1, LSP7, LSP26, ERC725Y) similar to the Potato Tipper
  • Be aware of security and known limitations with this pattern
  • Configure a Universal Profile with the required permissions and data keys
  • Learn to build innovative integrations using the tip-on-follow pattern.
  • Includes TypeScript (wagmi/viem/ethers + erc725.js) and Solidity code examples.

Deployed addresses

See references/addresses.md for all contract addresses on LUKSO Mainnet and Testnet (PotatoTipper, $POTATO token, LSP26 registry, RPC endpoints, explorers).

Quick workflows

1) Get oriented (repo map)

Read references/repo-overview.md for the file map + contract responsibilities.

2) Configure a user's 🆙 to use PotatoTipper (one-click)

This uses a Foundry script that performs the full setup in a single batchCalls transaction.

Step 1: Create the file script/SetupPotatoTipper.s.sol inside the Potato Tipper contracts repo:

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.28;

import {Script} from "forge-std/Script.sol";
import {console2} from "forge-std/console2.sol";

interface ILSP0 {
    function batchCalls(uint256[] calldata values, bytes[] calldata payloads) external returns (bytes[] memory);
}

interface IERC725Y {
    function setDataBatch(bytes32[] calldata keys, bytes[] calldata values) external;
}

interface ILSP7 {
    function authorizeOperator(address operator, uint256 amount, bytes calldata data) external;
}

/// @title Setup PotatoTipper via LSP0 batchCalls
/// @notice One-click setup: connect PotatoTipper + set settings + authorize budget
/// @dev Run with: forge script script/SetupPotatoTipper.s.sol:SetupPotatoTipper --rpc-url <rpc> --broadcast
///
/// Required env vars:
/// - PRIVATE_KEY: EOA controller key (must have ADDUNIVERSALRECEIVERDELEGATE + CALL permissions on UP)
/// - UP_ADDRESS: Universal Profile address to configure
/// - POTATO_TIPPER_ADDRESS: PotatoTipper contract address
/// - POTATO_TOKEN_ADDRESS: $POTATO LSP7 token address
/// - TIP_AMOUNT: Amount to tip per follower (in wei, e.g., "1000000000000000000" = 1 POTATO)
/// - MIN_FOLLOWERS: Minimum follower count for eligibility (e.g., "5")
/// - MIN_POTATO_BALANCE: Minimum POTATO balance for eligibility (in wei, e.g., "100000000000000000000" = 100 POTATO)
/// - TIPPING_BUDGET: Total POTATO authorized for tipping (in wei, e.g., "1000000000000000000000" = 1000 POTATO)
contract SetupPotatoTipper is Script {
    bytes32 constant LSP1DELEGATE_ON_FOLLOW_DATA_KEY = 0x0cfc51aec37c55a4d0b1000071e02f9f05bcd5816ec4f3134aa2e5a916669537;
    bytes32 constant LSP1DELEGATE_ON_UNFOLLOW_DATA_KEY = 0x0cfc51aec37c55a4d0b100009d3c0b4012b69658977b099bdaa51eff0f0460f4;
    bytes32 constant POTATO_TIPPER_SETTINGS_KEY = 0xd1d57abed02d4c2d7ce00000e8211998bb257be214c7b0997830cd295066cc6a;

    function run() external {
        address upAddress = vm.envAddress("UP_ADDRESS");
        address potatoTipperAddress = vm.envAddress("POTATO_TIPPER_ADDRESS");
        address potatoTokenAddress = vm.envAddress("POTATO_TOKEN_ADDRESS");
        uint256 tipAmount = vm.envUint("TIP_AMOUNT");
        uint256 minFollowers = vm.envUint("MIN_FOLLOWERS");
        uint256 minPotatoBalance = vm.envUint("MIN_POTATO_BALANCE");
        uint256 tippingBudget = vm.envUint("TIPPING_BUDGET");

        console2.log("=== PotatoTipper Setup ===");
        console2.log("UP Address:", upAddress);
        console2.log("PotatoTipper:", potatoTipperAddress);
        console2.log("POTATO Token:", potatoTokenAddress);
        console2.log("Tip Amount (wei):", tipAmount);
        console2.log("Min Followers:", minFollowers);
        console2.log("Min POTATO Balance (wei):", minPotatoBalance);
        console2.log("Tipping Budget (wei):", tippingBudget);
        console2.log("");

        bytes32[] memory dataKeys = new bytes32[](3);
        dataKeys[0] = POTATO_TIPPER_SETTINGS_KEY;
        dataKeys[1] = LSP1DELEGATE_ON_FOLLOW_DATA_KEY;
        dataKeys[2] = LSP1DELEGATE_ON_UNFOLLOW_DATA_KEY;

        bytes[] memory dataValues = new bytes[](3);
        dataValues[0] = abi.encode(tipAmount, minFollowers, minPotatoBalance);
        dataValues[1] = abi.encodePacked(potatoTipperAddress);
        dataValues[2] = abi.encodePacked(potatoTipperAddress);

        bytes[] memory payloads = new bytes[](2);
        payloads[0] = abi.encodeCall(IERC725Y.setDataBatch, (dataKeys, dataValues));

        bytes memory authorizeCalldata = abi.encodeCall(
            ILSP7.authorizeOperator, (potatoTipperAddress, tippingBudget, "")
        );
        payloads[1] = abi.encodeWithSignature(
            "execute(uint256,address,uint256,bytes)", 0, potatoTokenAddress, 0, authorizeCalldata
        );

        uint256[] memory values = new uint256[](2);
        values[0] = 0;
        values[1] = 0;

        vm.startBroadcast(vm.envUint("PRIVATE_KEY"));

        console2.log("Broadcasting batchCalls to UP...");
        ILSP0(upAddress).batchCalls(values, payloads);

        vm.stopBroadcast();

        console2.log("");
        console2.log("=== Setup Complete ===");
        console2.log("PotatoTipper is now connected to the UP!");
        console2.log("Settings configured:");
        console2.log("  - Tip amount:", tipAmount, "wei");
        console2.log("  - Min followers:", minFollowers);
        console2.log("  - Min POTATO balance:", minPotatoBalance, "wei");
        console2.log("Tipping budget authorized:", tippingBudget, "wei");
    }
}

Step 2: Run the setup via the shell wrapper:

TIP_AMOUNT=42000000000000000000 \
MIN_FOLLOWERS=5 \
MIN_POTATO_BALANCE=100000000000000000000 \
TIPPING_BUDGET=1000000000000000000000 \
PRIVATE_KEY=0x... \
./skills/potato-tipper/scripts/setup_potato_tipper.sh luksoTestnet 0xYourUPAddress

This single transaction:

  • Connects LSP1 delegates (follow + unfollow)
  • Sets tip settings
  • Authorizes tipping budget

Manual setup details: references/config-and-data-keys.md
Script implementation: references/foundry-batch-setup.md

5) Permissions (connect / disconnect)

  • To connect: controller needs ADDUNIVERSALRECEIVERDELEGATE permission
  • To disconnect: controller needs CHANGEUNIVERSALRECEIVERDELEGATE permission
  • If setup fails with a permission error, this is the most likely cause

Full troubleshooting + UP Browser Extension steps: references/permissions.md

6) LSP1 implementation requirement

A smart contract MUST implement the LSP1UniversalReceiver interface (and report _INTERFACEID_LSP0 via ERC165) to be eligible to receive tips. The PotatoTipper checks supportsInterface(_INTERFACEID_LSP0) on the follower address and rejects EOAs.

When the $POTATO token transfer happens, it calls universalReceiver(...) on both sender and recipient 🆙. If the recipient contract does not implement LSP1, the transfer reverts (caught by the PotatoTipper's try/catch).

Code examples

TypeScript (wagmi / viem / ethers + erc725.js)

Full examples for encoding data keys, connecting/disconnecting from a dApp, and setting tip settings: → references/typescript-examples.md

Solidity

  • Setting up PotatoTipper for a 🆙 from a smart contract
  • Implementing LSP1 to receive tips in a custom contract
  • Using loadTipSettingsRaw + decodeTipSettings free functions from any contract → references/solidity-examples.md

Guardrails / gotchas

  • Only 🆙 (LSP0) followers are eligible (EOAs rejected).
  • Follow/unfollow calls MUST come from the LSP26 Follower Registry — contract re-validates registry state.
  • Uses try/catch around LSP7 transfers → returns user-friendly status messages, never reverts.
  • "Existing followers" (before installation) are deliberately excluded from tips.
  • Settings values (tipAmount, minimumPotatoBalance) are in wei (18 decimals).

Design patterns + innovative integrations

  • Tip-on-Follow hook pattern + self-documenting ERC725Y config: references/learn-notes.md
  • Expansion ideas (NFT badges, tiered rewards, cross-protocol composability, marketing primitives): references/innovative-integrations.md
  • Follow→tip event order (debugging): references/event-flow.md
  • One-click setup / batching notes: references/foundry-batch-setup.md
  • Security posture + known limitations: references/security-and-limitations.md

Bundled resources

references/

  • repo-overview.md — file map + contract responsibilities
  • addresses.md — deployed addresses on Mainnet + Testnet
  • config-and-data-keys.md — the 3 config keys + encoding/decoding
  • permissions.md — required LSP6 permissions (ADD/CHANGE UNIVERSALRECEIVERDELEGATE)
  • typescript-examples.md — wagmi, viem, ethers + erc725.js code
  • solidity-examples.md — setup contract, LSP1 receiver, settings reader
  • learn-notes.md — design patterns (Tip-on-Follow + self-documenting config)
  • innovative-integrations.md — expansion ideas for new integrations
  • event-flow.md — follow→tip event emission order (debug)
  • foundry-batch-setup.md — batching / one-click setup notes
  • security-and-limitations.md — known limitations + security design

scripts/

  • setup_potato_tipper.sh — shell wrapper that clones the repo + runs the Foundry setup script

assets/

  • assets/abis/UniversalProfile.abi.json — minimal UP ABI for setData/setDataBatch + reads
  • assets/abis/LSP7DigitalAsset.abi.json — minimal LSP7 ABI incl. authorizeOperator
  • assets/abis/PotatoTipper.abi.json — minimal PotatoTipper ABI (events + a few views)
  • assets/abis/KeyManager.abi.json — minimal KeyManager ABI (execute/executeBatch)

Source Transparency

This detail page is rendered from real SKILL.md content. Trust labels are metadata-based hints, not a safety guarantee.

Open Registry RecordOpen in ClawHub

Related Skills

Related by shared tags or category signals.

Automation

Cypress Agent Skill

Production-grade Cypress E2E and component testing — selectors, network stubbing, auth, CI parallelization, flake elimination, Page Object Model, and TypeScr...

Registry SourceRecently Updated
0135
KahlilR23
Automation

Ichiro-Mind

Ichiro-Mind: The ultimate unified memory system for AI agents. 4-layer architecture (HOT→WARM→COLD→ARCHIVE) with neural graph, vector search, experience lear...

Registry SourceRecently Updated
1128
hudul
Automation

Reddit Engagement

Create and execute robust Reddit engagement workflows (create post, add comment, upvote) using browser accessibility-tree semantics instead of brittle DOM id...

Registry SourceRecently Updated
0121
Alvinperson