Ryan Berckmans ryanberckmans

🚨 This guide has moved 🚨

The OpenClaw guide is now maintained as a proper repository with better structure and actionable examples.

New location: https://github.com/digitalknk/openclaw-runbook

⚠️ The gist version will no longer be updated. The repo includes:

Streamlined narrative guide
Copy-paste example templates
VPS setup instructions

Setup Claude Code

You are setting up Claude Code globally on this machine. This captures best practices from agentic coding workflows.

Step 0: Check Existing Setup

First, check what's already configured:

ls ~/.claude/commands/ 2&gt;/dev/null

Repo Setup

You are setting up this repository for agentic coding with Claude Code.

Step 0: Check Existing Setup & Context

First, check what's already configured in this repo:

ls -la CLAUDE.md .cursorrules 2&gt;/dev/null

This gist was deprecated and promoted into a real repository!

Please see: https://github.com/wmitsuda/one-liner-archive

NFT Proxy

Overview / Goal

Proxy your NFT into a provable ERC-721 ownership format that can live in a different wallet from the proxied NFT. The proxied NFT can prove ownership while maintaining safety from the true asset by living in a different wallet. This proxied NFT can then be used safely for whitelists and other functions where signing a transaction may be connsidered "dangerous". This proxied NFT in theory could also be safely leased to other users in a way that NFTs can not be be done today.

Motivation

Many high end NFT collections that are have both significant underlying financial value and emotional value to users have become besieged by scammers and hackers. Part of the value in holding one of these NFTs is showing it off and being part of the community. However, in order to provably show it off you must expose your wallet to sign messages. Given the nascent UX in web3, it's not always easy to discern what is a trusted UX from an untrusted. And given that, there "should be a better way"

Anonymous: a proof-of-unique-human system

Anonymous is a coordination game for global proof-of-unique-human, through monthly pseudonym events that last 15 minutes, where every single person on Earth is randomly paired together with another person, 1-on-1, to verify that the other is a human being, in a pseudo-anonymous context. The proof-of-unique-human is that you are with the same person for the whole event. The proof-of-unique-human is untraceable from month to month, much like cash. True anonymity.

When you register for Anonymous, you use register(). You need a “registrationToken” that you got if you were verified in the last event. You can see one be deducted from your account with registrationToken[msg.sender]--. The purpose of the registration tokens is that you can easily mix them, so that your personhood is not traceable from month to month.

function register() public scheduler {

require(isReg(msg.sender) == false && data[schedule].tokens[1

	// @author original POC by @z0age


	library pureConsole {

	/*********************
	* string + uint256
	********************/

	function log(string memory errorMessage, uint256 value) internal pure {

	// SPDX-License-Identifier: MIT
	pragma solidity >=0.8.19;

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

	abstract contract BaseScript is Script {
	/// @dev Included to enable compilation of the script without a $MNEMONIC environment variable.
	string internal constant TEST_MNEMONIC = "test test test test test test test test test test test junk";

	/// @dev Needed for the deterministic deployments.

	FROM hayd/alpine-deno:1.10.1
	WORKDIR /src/app

	ADD deps.ts ./
	RUN ["deno", "cache", "deps.ts"]

	ADD *.ts ./
	RUN ["deno", "cache", "mod.ts"]

	ENTRYPOINT ["deno", "run", "--unstable", "--allow-net", "--allow-hrtime", "--allow-env", "--cached-only", "--no-check", "mod.ts"]

	export async function tryGetRevertReason(to: string, from: string, data: string): Promise<string \| undefined> {
	const provider = ethers.getDefaultProvider();
	const tx = { to, from, data };
	try {
	await provider.estimateGas(tx);
	} catch {
	const value = await provider.call(tx);
	return hexDataLength(value) % 32 === 4 && hexDataSlice(value, 0, 4) === '0x08c379a0'
	? defaultAbiCoder.decode(['string'], hexDataSlice(value, 4))
	: undefined;