Skills showmethemoney-pro

Name: showmethemoney-pro
Author: openclaw

execute the paid showmethemoney premium action through the merchant backend. use when the user wants to unlock or run the protected showmethemoney capability, and stablepay payment should be used before retrying the backend action.

install

source · Clone the upstream repo

git clone https://github.com/openclaw/skills

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/openclaw/skills "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/bubblevan/showmethemoney-pro" ~/.claude/skills/openclaw-skills-showmethemoney-pro && rm -rf "$T"

OpenClaw · Install into ~/.openclaw/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/openclaw/skills "$T" && mkdir -p ~/.openclaw/skills && cp -r "$T/skills/bubblevan/showmethemoney-pro" ~/.openclaw/skills/openclaw-skills-showmethemoney-pro && rm -rf "$T"

manifest: skills/bubblevan/showmethemoney-pro/SKILL.md

ShowMeTheMoney Pro

Execute the protected ShowMeTheMoney premium action only after merchant-backend verification and StablePay payment succeed.

Fixed merchant settings

Use these defaults for this skill:

skill_name:
```
ManualDemoSkill2
```

skill_did:

did:solana:6vhFRAY7FBruLdvtztAUfne1F77aFsVCHhwPuu4JAoox

default_price_usdc:
```
1.00
```
currency:
```
USDC
```
stablepay_gateway_base_url:
```
https://ai.wenfu.cn
```
merchant_backend_base_url:
```
http://127.0.0.1:8787
```
premium_action_endpoint:
```
/execute
```

Prefer values returned by the backend or StablePay

402 Payment Required

response when available. Use the defaults above only as fallback.

Preconditions

Before using this skill:

Call
```
stablepay_runtime_status
```
.
If no local wallet exists, create or bind one.
If no backend DID is registered, call
```
stablepay_register_local_did
```
.
If payment limits are missing, call
```
stablepay_configure_payment_limits
```
.

Do not require

stablepay_build_payment_policy

unless another workflow explicitly depends on it.

Main workflow

When the user asks to use the premium ShowMeTheMoney capability:

Resolve the current buyer DID from
```
stablepay_runtime_status
```
.

Call the merchant backend premium endpoint:

GET http://127.0.0.1:8787/execute?agent_did=<buyer_did>

Treat the merchant backend as the source of truth.
If the backend returns
```
200
```
, return the protected result.
If the backend returns
```
402 Payment Required
```
:
- read the payment requirement from the backend response
- prefer the returned
```
skill_did
```
  ,
```
skill_name
```
  ,
```
price
```
  ,
```
currency
```
  ,
```
message
```
  , and
```
payment_endpoint
```
- call
```
stablepay_pay_via_gateway
```
If payment succeeds, retry the same
```
/execute
```
request once.
If the retry still does not return
```
200
```
, explain that the premium action is still locked or verification failed.

Premium action contract

Use this request for the premium action:

method:
```
GET
```
endpoint:
```
http://127.0.0.1:8787/execute
```
required query parameter:
```
agent_did
```

Optional query parameters may be used when helpful:

```
q
```
```
prompt
```

These optional values are forwarded to the backend as request text for the premium action.

Expected backend behavior

The backend should:

receive the premium request
verify purchase state via StablePay
return
```
402
```
when the user has not purchased the skill
return
```
200
```
only after verification succeeds
return a merchant-generated proof token in the premium result

Treat the backend response as the final authority.

Success criteria

A successful premium response should include a backend-generated result such as:

protected_result.kind = merchant-generated-proof

```
protected_result.proof.display_token
```
```
access.verified_by_backend = true
```

This proof token is the strongest evidence that the premium capability was unlocked through backend verification, not guessed or simulated locally.

Payment rules

When payment is required:

Use
```
stablepay_pay_via_gateway
```
.
Use the requirement returned by the backend when present.
Respect local payment limits already configured in the StablePay plugin.
Never claim payment succeeded unless StablePay returns a successful result.
Retry the premium action only once after a successful payment.

What not to use as proof of access

Never treat any of the following as proof that the premium action is unlocked:

local plugin state
wallet existence
DID registration alone
local payment policy alone
raw Solana balance checks
a previous purchase attempt without successful backend verification

Only the merchant backend may decide that access is unlocked.

Scope limits

This skill is only for the protected premium action exposed by:

```
GET /execute?agent_did=<buyer_did>
```

Do not treat these routes as the main premium workflow:

```
/developer/revenue
```
```
/developer/sales
```
```
/agent/balance
```
```
/agent/transactions
```

Those are debugging or operator-facing routes, not the premium capability itself.

Safety

Never expose private keys, mnemonic material, decrypted local state, API keys, or merchant secrets.
Never bypass backend verification.
Never invent payment success.
Never claim premium access is unlocked unless the backend returns success.
Never return fabricated proof tokens.