DEV Community: Emmanuel (Emmo00)

Building x402 Clients on Celo: A Getting-Started Guide

Emmanuel (Emmo00) — Wed, 22 Jul 2026 02:26:44 +0000

How to make your code (or your agent) pay an HTTP endpoint automatically by signing a stablecoin micropayment on Celo and retrieving the resource in a single flow.

What is x402, from the client's side?

x402 allows a program to pay for an HTTP resource the moment it needs it with no accounts, API keys, or credit cards on file. When you request a protected URL, the server responds with 402 Payment Required and explains how to pay. Your client signs a payment and retries the request to receive the data. For an autonomous agent, this means discovering a priced endpoint and paying a fraction of a cent for it without requiring a human to configure billing beforehand.

This guide covers the client side on Celo, which offers cheap gas fees, fast finality, and widely held stablecoins like USDT and USDC. If you are building the endpoint itself, check out my companion guide, Building x402 Servers on Celo.

The Flow

You send a GET request to the protected URL. The server replies with an HTTP 402 status and a base64-encoded PAYMENT-REQUIRED response header (along with an empty {} body). Decoding the header reveals { x402Version, error, resource, accepts: [...] }.
The accepts[] array lists the payment options accepted by the server. Each item specifies a { scheme, network, amount, asset, payTo, maxTimeoutSeconds, extra }.
Your client selects one option, signs an EIP-3009 authorization (a signed off-chain message rather than an on-chain transaction from your wallet), and retries the request including an X-PAYMENT header.
A facilitator submits the transfer on-chain and pays the gas fee. You receive an HTTP 200 status along with a base64-encoded PAYMENT-RESPONSE header containing the settlement transaction hash.

Prerequisites

Before starting, make sure you have:

Node.js 20 or higher.
A funded wallet on Celo containing the stablecoin you plan to spend (such as Celo USDT). You do not need native CELO for gas.
Your wallet's private key provided via an environment variable (never hardcoded in source code).

Install the required packages:

npm install @x402/core @x402/evm @x402/fetch viem

@x402/core: Provides the x402Client.
@x402/evm: Provides the exact EVM scheme (registerExactEvmScheme).
@x402/fetch: Provides wrapFetchWithPayment, which converts standard fetch into a payment-aware request handler.
viem: Utility for generating a signer from a private key.

Inspect Before You Code

Before writing client code, you can inspect an endpoint's exact configuration (including its accepts[] array, supported networks, assets, and prices) using the x402 Inspector:

[https://x402-inspector.vercel.app/?url=](https://x402-inspector.vercel.app/?url=)<x402endpoint>

You can point the inspector at the live Chess Puzzles API on Celo as a working example (each call costs a fraction of a cent):

[https://x402-inspector.vercel.app/?url=https://api.chesspuzzles.xyz/puzzles?count=1](https://x402-inspector.vercel.app/?url=https://api.chesspuzzles.xyz/puzzles?count=1)

The inspector decodes the 402 challenge and lets you make real payments directly from a browser wallet, making it the fastest way to understand and debug endpoints.

Celo Token Constants

const CELO_NETWORK = "eip155:42220";                                // CAIP-2 chain id
const CELO_USDT    = "0x48065fbbe25f71c9282ddf5e1cd6d6a887483d5e";     // 6 decimals, EIP-3009 (proxy)
// USDT's EIP-712 domain: name = "Tether USD", version = "1"

An endpoint's accepts[] array often lists several options across different blockchains. For example:

[0] Base USDC (eip155:8453): The wrong chain for a Celo-only wallet.
[1] Celo USDC (eip155:42220)
[2] Celo USDT (eip155:42220, asset 0x48065…): Target this option if your wallet holds USDT.

The single most important habit: always select the option matching the network and asset your wallet is actually funded with. Do not assume accepts[0] is the correct choice. Selecting the wrong network option is the primary reason funded wallets fail to settle payments.

The Complete Client (Node + viem)

const { privateKeyToAccount } = require("viem/accounts");
const { x402Client } = require("@x402/core/client");
const { registerExactEvmScheme } = require("@x402/evm/exact/client");
const { wrapFetchWithPayment, decodePaymentResponseHeader } = require("@x402/fetch");

const CELO_NETWORK = "eip155:42220";
const CELO_USDT = "0x48065fbbe25f71c9282ddf5e1cd6d6a887483d5e";
const TARGET_URL = process.argv[2] || "https://api.chesspuzzles.xyz/puzzles?count=1";

// Read the key from the environment: never hardcode a private key.
const privateKey = process.env.AGENT_WALLET;
if (!privateKey) {
  console.error("AGENT_WALLET env is required (0x-prefixed private key).");
  process.exit(1);
}
const account = privateKeyToAccount(privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`);

// Selector signature: (version, requirements) => requirement.
// Prefer Celo USDT; fall back to any Celo option; last resort accepts[0].
function selectCeloUsdt(_version, requirements) {
  const usdt = requirements.find(
    (r) => r.network === CELO_NETWORK && String(r.asset).toLowerCase() === CELO_USDT,
  );
  return usdt || requirements.find((r) => r.network === CELO_NETWORK) || requirements[0];
}

// Decode the real error from the base64 PAYMENT-REQUIRED response header.
function decodePaymentRequiredError(response) {
  const header = response.headers.get("payment-required");
  if (!header) return null;
  try {
    const decoded = JSON.parse(Buffer.from(header, "base64").toString("utf8"));
    return decoded && decoded.error ? String(decoded.error) : null; // e.g. "insufficient_funds"
  } catch { return null; }
}

// CRITICAL: the selector goes in the x402Client CONSTRUCTOR (see Pitfall #1).
const client = new x402Client(selectCeloUsdt);
registerExactEvmScheme(client, { signer: account, networks: [CELO_NETWORK] });
const fetchWithPayment = wrapFetchWithPayment(globalThis.fetch, client);

(async () => {
  console.log(`Paying ${TARGET_URL} from ${account.address} (Celo USDT)…`);
  // Wrap in new URL(): a bare string can throw "Failed to parse URL" on Node 20+.
  const res = await fetchWithPayment(new URL(TARGET_URL), { method: "GET" });

  if (!res.ok) {
    const serverError = decodePaymentRequiredError(res);
    console.error(`FAILED status=${res.status} serverError=${serverError || "(none)"}`);
    process.exit(1);
  }

  const settle = decodePaymentResponseHeader(res.headers.get("payment-response") || "");
  const data = await res.json().catch(() => null);
  console.log(`SETTLED tx=${(settle && settle.transaction) || "(none)"}`);
  console.log("response:", JSON.stringify(data));
})().catch((err) => console.error("THREW:", String(err && (err.message || err))));

Run the client:

AGENT_WALLET=0x... node pay-x402-celo.js https://api.chesspuzzles.xyz/puzzles?count=1

On success, the script logs the settlement transaction hash. On failure, it outputs the decoded server error. This gives you a complete, functional x402 client on Celo.

Two Pitfalls That Cost Me Hours

When I first implemented x402 on Celo, I encountered two subtle issues. Both presented as a properly funded wallet failing to pay, and both had non-obvious causes. Understanding these pitfalls will save you time.

Pitfall #1: The selector MUST be passed to the `x402Client` constructor

This bug causes a funded wallet to fail with an insufficient_funds error:

// ❌ BROKEN: The option is IGNORED, and the client defaults to accepts[0] (Base USDC).
const client = new x402Client();
wrapFetchWithPayment(fetch, client, { paymentRequirementsSelector: selectCeloUsdt });

// ✅ CORRECT: The selector explicitly controls which asset and network are paid.
const client = new x402Client(selectCeloUsdt);
wrapFetchWithPayment(fetch, client);

When the selector is ignored, the client attempts to pay accepts[0], which defaults to Base USDC on `eip155:8453. A Celo-only wallet holds no balance on Base, causing the facilitator to return insufficient_funds` even if your wallet holds Celo USDT. Adding more funds to Celo will not fix this; the solution is passing your selector directly to the constructor.

Note the function signature difference:

Constructor / x402HTTPClient signature: (version, requirements) => requirement
The wrapFetchWithPayment options argument expects (requirements), but using this path can cause selection issues.

Pitfall #2: Read the actual error from the `PAYMENT-REQUIRED` header

When a payment retry fails, the HTTP response body is usually an empty object {}. The actual error details are stored inside the base64-encoded PAYMENT-REQUIRED response header. Always decode this header when debugging failures (the decodePaymentRequiredError helper function above handles this).

If you receive an unresolved 402 with error: "insufficient_funds", treat it as a temporary failure rather than a fatal error. It indicates the payment did not settle (due to network mismatches, empty balances, or temporary facilitator issues), and retrying later may succeed. If you are unsure, paste your endpoint into the inspector to compare decoded requirements with what your client selected:

[https://x402-inspector.vercel.app/?url=](https://x402-inspector.vercel.app/?url=)<x402endpoint>

Other Gotchas Worth Knowing

Node 20+ fetch handling: Passing a raw string URL to wrapped fetch can throw a Failed to parse URL error. Wrap string URLs using new URL(TARGET_URL).
Atomic token units: Celo USDT uses 6 decimal places, so amount: "10000" represents 0.01 USDT.
No CELO required for gas: The facilitator covers transaction gas fees. Your wallet only needs sufficient stablecoin balances. You can verify token balances with viem by querying balanceOf and decimals on the token contract at [https://forno.celo.org](https://forno.celo.org).
Object-style asset declarations: Some servers define asset as an object { address, decimals, eip712: { name, version } } with empty extra fields. The client library expects asset to be a string address with EIP-712 parameters inside extra. If signature generation fails to locate the domain, normalize each accepts[] entry so asset contains the address string and extra contains { name, version }.

Paying from a Browser Wallet (ethers)

The same client libraries function in browser environments; you simply adapt the signer to use an injected EIP-1193 wallet provider. The selection function must still be passed to the x402Client constructor.

const signer = {
  address,
  async signTypedData({ domain, types, message }) {
    const t = { ...types }; delete t.EIP712Domain; // ethers rejects EIP712Domain
    return ethersSigner.signTypedData(domain, t, message);
  },
  async readContract({ address: to, abi, functionName, args = [] }) { /* provider.call */ },
};
const client = new x402Client(selectRequirements); // (version, options) => option
registerExactEvmScheme(client, { signer });
const http = new x402HTTPClient(client);
const paymentRequired = http.getPaymentRequiredResponse(getHeader, parsedBody);
const payload = await http.createPaymentPayload(paymentRequired);
const headers = http.encodePaymentSignatureHeader(payload);
// retry the original request with `headers` merged in

Skip the Trial and Error: Grab the Skills

To simplify client integration, I packaged my Celo x402 learnings into reusable agent skills. If you build with an AI coding assistant (such as Claude Code), you can install them directly:

GitHub Repository: https://github.com/Emmo00/agent-skills

npx skills add emmo00/agent-skills

This library provides pre-configured skills for building x402 clients and servers on Celo, ensuring your development workflow automatically handles constructor selector placement, EIP-712 domains, and header error decoding.

Where to Go Next

Build the server side: Read my companion guide, Building x402 Servers on Celo.
Inspect endpoints: Test endpoints using the x402 Inspector.
Reference implementation: Test your client against the live Chess Puzzles API on Celo.

x402 streamlines API access by replacing user registration, API keys, and credit cards with a single signed HTTP request. On Celo, low gas fees, widespread stablecoin adoption, and gasless user transactions provide an ideal environment for building autonomous client applications.

Building x402 Servers on Celo: A Getting-Started Guide

Emmanuel (Emmo00) — Wed, 22 Jul 2026 02:18:47 +0000

How to put an HTTP endpoint behind a stablecoin paywall so any agent can pay per request with no accounts, API keys, or invoices.

What is x402?

x402 revives the long-dormant HTTP 402 Payment Required status code and turns it into a real payment protocol. The concept is simple: a client requests a protected resource, the server replies that payment is required with instructions on how to pay, the client signs a payment and retries, and the server returns the requested resource.

There are no signups, API keys, or monthly subscriptions. A single HTTP request becomes an instant paid transaction.

An autonomous agent can discover a priced endpoint, pay a fraction of a cent, and retrieve its data, all without a human needing to create an account first.

This guide walks you through building the server side on Celo, where transactions are fast, cheap, and stablecoins (such as USDT and USDC) are widely used. If you want to build the paying side, check out my companion guide, Building x402 Clients on Celo.

The Mental Model

An x402 server handles three main steps on any protected route:

Challenge: If a request arrives without a valid payment, respond with a 402 status code and a PAYMENT-REQUIRED header. The decoded JSON header contains an accepts[] array listing the payment options you accept, including the network, asset, price, and your receiving wallet address.
Verify & Settle: If the request includes a signed payment in the X-PAYMENT header, verify it and settle it through a facilitator (a service that submits the on-chain transfer and pays the network gas fee). On success, run your real route handler and return a PAYMENT-RESPONSE header with the settlement transaction hash.
Run it through middleware: You do not need to build this payment flow from scratch. The @x402/express package provides paymentMiddleware that handles challenge, verification, and settlement automatically. You simply provide a map of routes to accepts[] options and a resource server that routes network requests to the correct facilitator.

Your server never holds the payer's private key and never pays gas fees. The facilitator handles all on-chain work, while your wallet simply acts as the payTo recipient address.

Prerequisites

Before starting, make sure you have:

Node.js 20 or higher running an Express app.
A receiving wallet address on Celo (this is your payTo address that collects payments; it does not sign transactions).
Access to a Celo facilitator (an HTTP facilitator URL and API key). Celo's ecosystem provides these, or you can self-host x402-rs.

Install the required packages:

npm install @x402/express @x402/evm @x402/core @coinbase/cdp-sdk

@x402/express: Handles paymentMiddleware and x402ResourceServer.
@x402/evm: Provides ExactEvmScheme for exact-amount payments on EVM-compatible chains.
@x402/core: Provides HTTPFacilitatorClient for self-hosted or third-party facilitators.
@coinbase/cdp-sdk: (Optional) Required only if you also want to accept Base USDC via Coinbase's hosted facilitator.

If you are using TypeScript and these packages lack built-in type definitions, add a small declaration file to keep your compiler happy:

// x402-shims.d.ts
declare module "@x402/express" { export const paymentMiddleware: any; export const x402ResourceServer: any; }
declare module "@x402/evm/exact/server" { export const ExactEvmScheme: any; }
declare module "@x402/core/server" { export const HTTPFacilitatorClient: any; }
declare module "@coinbase/cdp-sdk/x402" { export const createCdpFacilitatorClient: any; }

Step 1: Connect Your Facilitators

Each blockchain network requires a facilitator to verify and settle payments. Celo uses an HTTP facilitator configured via URL. If you also choose to accept USDC on Base, you can use Coinbase's hosted CDP facilitator.

import { HTTPFacilitatorClient } from "@x402/core/server";
import { createCdpFacilitatorClient } from "@coinbase/cdp-sdk/x402";

// Celo (eip155:42220): third-party or self-hosted HTTP facilitator using an API key
const celoFacilitatorClient = new HTTPFacilitatorClient({
  url: process.env.X402_CELO_FACILITATOR_URL,
  async createAuthHeaders() {
    const headers = { "X-API-Key": process.env.CELO_FACILITATOR_API_KEY };
    return { verify: headers, settle: headers, supported: headers };
  },
});

// Base (eip155:8453): optional Coinbase-hosted facilitator (reads CDP creds from env)
const baseFacilitatorClient = createCdpFacilitatorClient();

Keep all sensitive credentials (API keys, CDP credentials, and wallet addresses) inside environment variables rather than your codebase. Additionally, wrap your payment setup in a configuration check so a misconfigured server returns a helpful error instead of crashing:

Go to x402.celo.org to get a Celo x402 facilitator URL and API key.

const payTo = process.env.X402_PAY_TO_ADDRESS;
if (!payTo || !process.env.X402_CELO_FACILITATOR_URL || !process.env.CELO_FACILITATOR_API_KEY) {
  res.status(503).json({ error: "x402 payment endpoint is not configured on this server" });
  return;
}

Step 2: Declare What You Accept

The core of your server setup is a mapping from route paths to an accepts[] array, paired with a resource server that routes each network to its corresponding facilitator.

import { paymentMiddleware, x402ResourceServer } from "@x402/express";
import { ExactEvmScheme } from "@x402/evm/exact/server";

// Dynamic price: compute atomic units for this request.
// All these stablecoins use 6 decimals, so $0.10 = 100,000 atomic units.
const units  = getRequestedUnits(req);            // your per-request quantity
const usd    = units * PRICE_PER_UNIT_USD;        // e.g., 0.10 * count
const atomic = String(Math.round(usd * 1e6));     // "100000"

return paymentMiddleware(
  {
    "GET /": {
      accepts: [
        // Base USDC: human-readable price strings work fine for the CDP facilitator
        { scheme: "exact", price: formatUsd(usd), network: "eip155:8453", payTo },

        // Celo USDC: MUST use the flat wire shape (see Pitfall #1)
        {
          scheme: "exact",
          price: { amount: atomic, asset: "0xcEBA9300f2b948710d2653dD7B07f33A8B32118C", extra: { name: "USDC", version: "2" } },
          network: "eip155:42220",
          payTo,
        },

        // Celo USDT: flat wire shape with the correct EIP-712 domain
        {
          scheme: "exact",
          price: { amount: atomic, asset: "0x48065fbbe25f71c9282ddf5e1cd6d6a887483d5e", extra: { name: "Tether USD", version: "1" } },
          network: "eip155:42220",
          payTo,
        },
      ],
      description: "Your resource",
      mimeType: "application/json",
    },
  },
  new x402ResourceServer([baseFacilitatorClient, celoFacilitatorClient])
    .register("eip155:8453", new ExactEvmScheme())
    .register("eip155:42220", new ExactEvmScheme()),
)(req, res, next);

Offering multiple options in accepts[] allows callers to pay using whichever stablecoin they hold. The client chooses one option, and your resource server delegates settlement to the registered facilitator for that network.

Celo Token Constants

Copy these exact contract addresses and EIP-712 domain parameters:

Celo USDT: 0x48065fbbe25f71c9282ddf5e1cd6d6a887483d5e | extra: { name: "Tether USD", version: "1" }
Celo USDC: 0xcEBA9300f2b948710d2653dD7B07f33A8B32118C | extra: { name: "USDC", version: "2" }

Important: The extra.name and extra.version fields must match the token's on-chain EIP-712 DOMAIN_SEPARATOR exactly. If they differ, payment signatures will fail to recover, causing settlement errors. Note that Celo USDT is a proxy contract whose domain version is "1", not "2".

Two Pitfalls That Cost Me Hours

When I first implemented x402 on Celo, two subtle issues caused unexpected errors. Reviewing them now will save you debugging time.

Pitfall #1: The Celo facilitator requires a flat wire shape

The x402-rs facilitator expects the asset field to be a plain string address, with EIP-712 domain details placed in extra. Passing an object-style asset causes the facilitator to reject the transaction with an invalid_format error, even if the 402 challenge looks correct.

// ❌ REJECTED by the Celo facilitator (invalid_format)
price: { amount, asset: { address: "0x4806…", decimals: 6, eip712: { name: "Tether USD", version: "1" } } }

// ✅ ACCEPTED: flat string asset + domain in extra
price: { amount, asset: "0x48065fbbe25f71c9282ddf5e1cd6d6a887483d5e", extra: { name: "Tether USD", version: "1" } }

Declare the AssetAmount explicitly with a string amount in atomic units. Avoid passing raw price strings like "$0.10" directly for Celo; calculate the atomic integer value beforehand to ensure clarity.

Pitfall #2: Calculating price per request in atomic units

If your API charges by usage quantity (such as item counts or data size), calculate the price inside the request middleware rather than globally at startup:

function unitPriceUsd(): number {
  const v = Number.parseFloat(process.env.X402_PRICE_USD_PER_UNIT ?? "");
  return Number.isFinite(v) && v > 0 ? v : 0.1;   // safe default
}

Standard stablecoins like USDC and USDT on Celo use 6 decimals, meaning $1.00 equals 1,000,000 atomic units (usd * 1e6).
Always configure prices via environment variables with a safe fallback value to prevent accidental zero-pricing.
Pass the calculated atomic amount into every entry in your accepts[] array.

Mount this combined logic on your Express routes after standard parameter validation:

app.use("/resource", validateParams, x402Middleware, resourceRouter);

Make Your Paywall Discoverable to AI Agents

Autonomous agents read API documentation to determine how to pay. You can make your server agent-friendly by publishing a GET /llms.txt file that outlines:

The authentication flow (402 response -> decode PAYMENT-REQUIRED header -> sign -> retry with X-PAYMENT).
The header requirement structure (noting that the response body remains empty {}).
Supported networks, stablecoin assets, and atomic unit calculations.
Your expected request parameters and response schemas.

Providing machine-readable documentation enables AI agents to pay and access your API automatically.

Test and Debug Your Endpoint

Once your server is running, test it using the x402 Inspector. This tool decodes your 402 challenge, displays the accepts[] array, and allows you to execute end-to-end test payments from a browser wallet:

[https://x402-inspector.vercel.app/?url=](https://x402-inspector.vercel.app/?url=)<your-endpoint-url>

For a working reference implementation, inspect and query the live Chess Puzzles API on Celo:

[https://x402-inspector.vercel.app/?url=https://api.chesspuzzles.xyz/puzzles?count=1](https://x402-inspector.vercel.app/?url=https://api.chesspuzzles.xyz/puzzles?count=1)

Skip the Trial and Error: Grab the Skills

To simplify integration, I packaged my Celo x402 learnings into reusable agent skills. If you use an AI coding assistant (such as Claude Code), you can install them directly:

GitHub Repository: https://github.com/Emmo00/agent-skills

npx skills add emmo00/agent-skills

This library provides pre-configured skills for building x402 servers and clients on Celo, ensuring your development environment automatically handles flat wire shapes, EIP-712 domains, and facilitator client setup.

Where to Go Next

Build the paying client: Read my companion guide, Building x402 Clients on Celo.
Inspect endpoints: Test your setup using the x402 Inspector.
Reference code: Test against the live Chess Puzzles API on Celo.

x402 streamlines API monetization by replacing complex signup forms and key management with instant signed HTTP payments. Combined with Celo's fast block times and low transaction costs, it offers a seamless way to monetize services for human users and AI agents alike.

How to Use Claude Code and OpenAI Codex for Free with FreeModel.dev

Emmanuel (Emmo00) — Sun, 28 Jun 2026 16:04:11 +0000

If you've wanted to use Claude Code or OpenAI Codex without paying for expensive API usage, FreeModel.dev provides an easy way to do it. You simply create an account, generate an API key, and point the official CLI tools to FreeModel's API endpoint.

As a bonus, if you sign up using my referral link, both of us receive $10 in API credits after you verify your account.

👉 Sign up here: https://freemodel.dev/invite/FRE-0b7baf97

Why Use FreeModel.dev?

FreeModel.dev acts as an API provider compatible with official AI developer tools, allowing you to use:

Claude Code
OpenAI Codex CLI
VS Code extensions
Your own applications

Instead of paying immediately for API usage, new users can receive free credits through referrals.

Referral Bonus

When you create an account through my referral link and verify your account via phone or Telegram, both of us receive:

🎁 $10 in API credits
✅ No expiration
✅ No limit on referrals
✅ Works with any email provider

Referral link:

https://freemodel.dev/invite/FRE-0b7baf97

Credits are usually added within about a minute after verification.

Installing Claude Code

The setup uses the official Anthropic Claude Code CLI.

Step 1: Install Git Bash (Windows)

Git Bash is recommended because it handles paths and shell commands more reliably than Command Prompt.

Download Git for Windows and install it using the default options.

Step 2: Install Node.js

Claude Code requires Node.js 18 or newer.

Verify your version:

node --version

If your version is below 18, install the latest LTS release from Node.js.

Step 3: Create a FreeModel API Key

After signing into FreeModel:

Open API Keys
Click Create Key
Give it a name
Copy the key somewhere safe

Treat this key like a password.

Step 4: Install Claude Code

Install the official CLI:

npm install -g @anthropic-ai/claude-code

Restart your terminal afterwards.

Step 5: Configure Claude

Create the file:

C:\Users\<your-user>\.claude\settings.json

If the .claude folder doesn't exist, simply run:

claude

once, then close it.

Now create settings.json:

{
  "env": {
    "ANTHROPIC_API_KEY": "YOUR_API_KEY",
    "ANTHROPIC_BASE_URL": "https://cc.freemodel.dev",
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
  },
  "permissions": {
    "allow": [],
    "deny": []
  },
  "apiKeyHelper": "echo 'YOUR_API_KEY'"
}

Replace both instances of:

YOUR_API_KEY

with your actual FreeModel API key.

Step 6: Launch Claude

Restart your terminal and run:

claude

If everything is configured correctly, you'll see the Claude Code welcome screen and can start chatting with Claude immediately.

Installing OpenAI Codex

FreeModel also supports the official OpenAI Codex CLI.

Step 1: Install Codex

Install using npm:

npm install -g @openai/codex

or Homebrew:

brew install codex

Step 2: Create the Configuration Directory

Delete any previous configuration and recreate it.

PowerShell:

Remove-Item -Recurse -Force ~\.codex -ErrorAction SilentlyContinue
New-Item -ItemType Directory ~\.codex

Step 3: Create an API Key

Generate an API key inside your FreeModel dashboard.

Step 4: Create auth.json

Inside:

C:\Users\<your-user>\.codex

Create:

{
  "OPENAI_API_KEY": "YOUR_API_KEY"
}

Replace YOUR_API_KEY with your key.

Step 5: Create config.toml

In the same folder, create:

model_provider = "freemodel"
model = "gpt-5.5"
model_reasoning_effort = "xhigh"
disable_response_storage = true
preferred_auth_method = "apikey"

[model_providers.freemodel]
name = "freemodel"
base_url = "https://api.freemodel.dev"
wire_api = "responses"

Step 6: Verify Installation

Restart your terminal.

Check that Codex is installed:

codex -V

If you see a version number, you're ready.

Step 7: Start Coding

Navigate into your project:

cd your-project

Launch Codex:

codex

You can also use the official VS Code extension.

Updating Claude Code

To update to the latest version:

npm install -g @anthropic-ai/claude-code

Uninstalling Claude Code

npm uninstall -g @anthropic-ai/claude-code

You can also delete:

~/.claude

%USERPROFILE%\.claude

to remove your configuration.

Troubleshooting

Claude won't start

Ensure Node.js is version 18+
Confirm your API key is correct
Make sure settings.json is inside the .claude folder
Restart your terminal after editing configuration files

Codex isn't using FreeModel

Double-check that config.toml contains:

base_url = "https://api.freemodel.dev"

and that auth.json contains your API key.

Earn More Free Credits

FreeModel's referral program has no referral limit.

Every verified friend earns both of you:

$10 API credits
Credits never expire
Works with any email provider

Use my referral link to get started:

👉 https://freemodel.dev/invite/FRE-0b7baf97

Once you've verified your account, you'll receive your credits and can begin using Claude Code or Codex without paying upfront.

🚀 From Student to Web3 Builder: My Journey, My Project, and Why It Matters

Emmanuel (Emmo00) — Fri, 25 Apr 2025 04:22:05 +0000

Hi, I’m Emmanuel Nwafor, a computer science student at the University of Nigeria, Nsukka — and a curious mind who fell in love with software development. Like not many others, I started with the basics of back-end development — arguably the best way to begin a software engineering journey — and eventually dabbled in other areas of tech.

[I also wanted to be a writer, so I hope you enjoy this piece].

I remember when I built my first API server with Node.js — that was when I realized I’d actually found something I liked doing. For once, I wasn’t overthinking my crush at the time. Turns out, I wasn’t sad, or lonely, or ugly😐 — I just needed to build.

Well, enough of the self-glazing 😅. Let’s talk about something else.

🌐 Why I Chose Web3

What pulled me into Web3 wasn’t just the buzz or the promise of pay that overwhelmingly surpassed what I was already making as a back-end web developer 👀.

I wanted to build cool stuff while creating ✨impact✨, and I feel Web3 provides a certain liberty for that. Impact is the keyword — and in my opinion, that’s what all of us ultimately want to make. Web3 enables individuals to create things that don’t need approval to exist and can’t be switched off by gatekeepers

[we might still be cooked in Web3 if one of these gatekeepers decides to switch off their servers, but we move #ReditIsTheOnlySourceOfTruth].

So far, so good. It’s been an interesting ride — full of learning, for sure.

[The amount of new vocabulary I had to learn just to grasp beginner-level blockchain concepts is alarming 🫠].

🧠 Learning from the Cipher Session

This journey accelerated when I joined the B<>rder/ess <> Metis Cipher Session, a mind-stretching experience hosted by [you guessed it] the B<>rder/ess team in collaboration with Metis and KarlaGod.

Here are some highlights of what I picked up:

Full-stack Solidity development skills — [Imagine if this wasn’t on the list 🙂]

We covered everything from smart contracts to front-end interactions. [Safe to say, I can add Solidity to my LinkedIn profile]
How to actually make money as a developer

Our tutor didn’t just focus on the tech — we also got real-world advice on how to monetize our skills, navigate the ecosystem, and think like builders, not just coders.
Clarity on the Web3 landscape, from KarlaGod herself🫡

Karla gave us the real sauce — how the space works, why community matters, and how to market your project and get funded. Step-by-step clarity. [I can't make this stuff up].

🔨 What I’m Building: [Blockchain-powered verification system that ensures transparent, tamper-proof records of land ownership (BPVSTETTPROLO)]

My project is called ✨LandRegistry✨ — a decentralized app that leverages blockchain technology to provide secure, transparent, and efficient land ownership verification.

👉 Check it out

The problem:

Land ownership disputes are way too common — especially in regions where records are handwritten, scattered across multiple offices, or worse, mysteriously “missing.”

People lose properties, get scammed, or spend years in court because a piece of paper said one thing, and some government staff or “land agent” said another.

The lack of a reliable, tamper-proof record system means trust is low, fraud is high, and verification is expensive, slow, and largely opaque.

The solution:

LandRegistry stores land ownership records directly on the blockchain — publicly verifiable, immutable, and timestamped.

Here’s what it offers:

Tamper-proof verification: Once a record is written, not even I can alter it. And that’s the whole point.
Open ownership: Every change in ownership is logged and visible. No shady backdoor deals.
Decentralized access: You don’t need to know someone in the ministry to verify or register land — you just need a wallet.
Cost-effective and secure: Cuts out intermediaries and reduces paperwork. No more photocopying a "C of O" ten times.

At its core, the project isn’t just about digitizing land ownership — it’s about restoring trust where it’s been broken for decades.

🗓️ Join Me for Demo Day!

I’ll be demoing LandRegistry on Friday, 4PM WAT, alongside other brilliant minds from the Cipher cohort.

Let’s shape the future of on-chain land ownership — one block at a time.

Self Guide for Deploying Laravel and React Applications on a VPS

Emmanuel (Emmo00) — Wed, 26 Feb 2025 20:48:34 +0000

This is a documentation of the steps I took in deploying my Laravel and React application to a VPS.

If you're reading along, I'm sure it'd be useful irrespective of the application stack.

1. Initial VPS Setup

Before deploying your applications, you need to prepare your server environment.

Update Your System

sudo apt update && sudo apt upgrade -y

Install Essential Dependencies

sudo apt install apache2 unzip curl git -y

2. Laravel Backend Deployment

Add ondrej/php PPA as a software repository.

sudo add-apt-repository ppa:ondrej/php # Press enter when prompted.
sudo apt update

Install PHP and Required Extensions

sudo apt install php php-cli php-mbstring php-xml php-bcmath php-tokenizer php-curl php-zip php-mysql -y

Install Composer

curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer

Set Up MySQL Database

sudo apt install mysql-server -y
sudo mysql_secure_installation

Create a database and user for your Laravel application:

sudo mysql -u root -p

Within the MySQL prompt:

CREATE DATABASE laravel_db;
CREATE USER 'laravel_user'@'localhost' IDENTIFIED BY 'your_strong_password';
GRANT ALL PRIVILEGES ON laravel_db.* TO 'laravel_user'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Deploy Your Laravel Application

cd /var/www
git clone https://github.com/your-username/your-laravel-project.git laravel
cd laravel
composer install
cp .env.example .env

Edit the .env file with your database credentials:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=laravel_db
DB_USERNAME=laravel_user
DB_PASSWORD=your_strong_password

Generate the application key and run migrations:

php artisan key:generate
php artisan migrate --seed
php artisan config:cache

Configure Apache for Laravel

Create a new Apache configuration file:

sudo nano /etc/apache2/sites-available/laravel.conf

Add the following configuration:

<VirtualHost *:80>
    ServerAdmin webmaster@yourdomain.com
    DocumentRoot /var/www/laravel/public
    ServerName api.yourdomain.com

    <Directory /var/www/laravel/public>
        AllowOverride All
        Require all granted
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/laravel_error.log
    CustomLog ${APACHE_LOG_DIR}/laravel_access.log combined
</VirtualHost>

Enable the site and required modules:

sudo a2ensite laravel.conf
sudo a2enmod rewrite
sudo systemctl restart apache2

Set Proper File Permissions

sudo chown -R www-data:www-data /var/www/laravel
sudo chmod -R 775 /var/www/laravel/storage /var/www/laravel/bootstrap/cache

3. React Frontend Deployment

Step 1: Build Your React Application

On your local development machine:

npm run build

Step 2: Transfer the Build to Your VPS

Using SCP:

scp -r build/ username@your-vps-ip:/var/www/react

Alternatively, you could clone your repository and build directly on the server (I'd recommend the former especially if deploying with a CICD pipeline):

cd /var/www
git clone https://github.com/your-username/your-react-project.git react
cd react
npm install
npm run build

Step 3: Configure Apache for React

Create a new Apache configuration:

sudo nano /etc/apache2/sites-available/react.conf

Add the following:

<VirtualHost *:80>
    ServerAdmin webmaster@yourdomain.com
    DocumentRoot /var/www/react/build
    ServerName yourdomain.com

    <Directory /var/www/react/build>
        Options Indexes FollowSymLinks
        AllowOverride All
        Require all granted

        # This configuration ensures that React Router works correctly
        RewriteEngine on
        RewriteCond %{REQUEST_FILENAME} !-f
        RewriteCond %{REQUEST_FILENAME} !-d
        RewriteRule ^ index.html [L]
    </Directory>

    ErrorLog ${APACHE_LOG_DIR}/react_error.log
    CustomLog ${APACHE_LOG_DIR}/react_access.log combined
</VirtualHost>

Enable the site:

sudo a2ensite react.conf
sudo systemctl restart apache2

4. Secure Your Applications with SSL

For production applications, SSL is essential. Let's Encrypt provides free SSL certificates:

sudo apt install certbot python3-certbot-apache -y
sudo certbot --apache -d yourdomain.com -d api.yourdomain.com

Follow the prompts to complete the SSL setup.

5. Set Up Process Management for Laravel

Configure Supervisor for Queue Workers

sudo apt install supervisor -y
sudo nano /etc/supervisor/conf.d/laravel-worker.conf

Add the following configuration:

[program:laravel-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /var/www/laravel/artisan queue:work --tries=3 --sleep=3
autostart=true
autorestart=true
user=www-data
numprocs=2
redirect_stderr=true
stdout_logfile=/var/log/laravel-worker.log

Activate the configuration:

sudo supervisorctl reread
sudo supervisorctl update
sudo supervisorctl start laravel-worker:*

Set Up Laravel Scheduler

crontab -e

Add this line:

* * * * * cd /var/www/laravel && php artisan schedule:run >> /dev/null 2>&1

6. Advanced Configuration

Set Up a Load Balancer (Optional)

For high-traffic applications, consider setting up Nginx as a load balancer in front of Apache:

sudo apt install nginx -y

Create a configuration file:

sudo nano /etc/nginx/sites-available/loadbalancer

Add:

upstream backend {
    server 127.0.0.1:8080;
    # Add more servers if you have multiple instances
}

server {
    listen 80;
    server_name yourdomain.com;

    location / {
        proxy_pass http://backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Configure Redis for Caching (Optional)

sudo apt install redis-server -y

Update your Laravel .env file:

CACHE_DRIVER=redis
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379

7. Maintenance and Updates

Automating Laravel Updates

Create a simple script:

sudo nano /usr/local/bin/update-laravel

Add:

#!/bin/bash
cd /var/www/laravel
git pull
composer install --no-dev
php artisan migrate --force
php artisan config:cache
php artisan route:cache
php artisan view:cache
sudo chown -R www-data:www-data /var/www/laravel

Make it executable:

sudo chmod +x /usr/local/bin/update-laravel

Monitoring Your Application

Install monitoring tools:

sudo apt install htop net-tools -y

8. Troubleshooting

Common Laravel Issues

500 Internal Server Error
- Check Laravel logs: tail -f /var/www/laravel/storage/logs/laravel.log
- Check Apache logs: tail -f /var/log/apache2/laravel_error.log
Permission Issues
- Run: sudo chown -R www-data:www-data /var/www/laravel

Common React Issues

White Screen / Not Loading
- Check browser console for errors
- Verify .htaccess file in build directory
API Connection Issues
- Ensure your .env file in React has the correct API URL

Conclusion

You've now successfully deployed both your Laravel backend and React frontend on a single VPS.

Remember to regularly back up your database and application files, keep your server updated with security patches, and monitor your application's performance as your user base grows.

Up until now we have done the deployment manually, but you should definitely consider setting up a CICD pipeline for easy, automated deployment. GitHub Actions is a good recommendation.

Happy coding!👍🏻

Learning a new language/framework

Emmanuel (Emmo00) — Sun, 30 Jun 2024 19:43:26 +0000

I recently took up an internship role where I had to use a programming language and framework I was unfamiliar with. The role involved using Laravel as the backend framework and I had to learn it. Laravel is a PHP framework for building web applications.
In this post, I'd like to outline some steps I took from being clueless to contributing to the codebase within 2 months.
Don't be alarmed if this timeframe seems too short, this is probably, as I'll talk about in a minute, because I have had a little experience in programming and backend development before then. If you don't fall into this category or you are a total beginner in your field, these tips should still be helpful to you as a developer. Hang tight, let's explore.

Having a good programming background

A really smart guy once said, "People need to start learning programming instead of programming languages". I agree with this saying. Programming languages are just tools software developers use to implement their solutions. The underlying way of thinking and problem-solving are still required no matter the number of languages you know.
Knowing a lot of programming languages, although impressive, doesn't mean the person can apply these concepts to build cool and helpful software, especially in this age of rising use of AI tools and companions.

Understanding concepts like Variables, Data types, control flow, data structures, algorithms, programming paradigms like Object Oriented Programming (OOP) and Functional programming, Design patterns, Testing, concurrency and parallelism, and error handling is a good start. In the real world, or even now, we apply and implement most of these without consciously/intentionally thinking about them.

Learn the language first

I've heard people say "I'm good with React, but I have issues with JavaScript". This shouldn't be the case. One should be very familiar with a language and how it works before learning any of its frameworks.
Some key questions to ask when learning a new language may include:

What does the general Syntax look?
What are the provided/built-in Data Types?
How do I declare Variables?
Provided Operators.
How to implement Control Flows
How to declare Function
Manual Memory Management?
How to run my programs? Compiled or Interpreted?
Is it a Static or Dynamic Type language?
What Paradigm does it belong?

Of course, You'll notice answers to these questions for any programming language you choose are not the same. You might also get a "Not Quite" or "It depends" answer from some of these in some languages, and understanding these "It depends" scenarios is key.

For example, answering the question "How do I run my Java Program". You can run your Java program by first compiling it to bytecode with the java compiler: javac MyCode.java, then running the generated .class file with java MyCode. Despite the compilation step, java is "Not Quite" a compiled language. Java is considered both compiled and interpreted. It compiles to bytecode, then the bytecode is interpreted with the Java Virtual Machine (JVM).

Most of the knowledge you gain in this stage is transferable to other programming languages.

Build Projects

This is a very important step in the process. Building projects is a way for you to exercise the knowledge you've acquired. It also allows you to experiment with the language or framework, which gives you a more in-depth knowledge of the language.
It is okay to start small as no one expects you to build anything too complex as you start, you are only advised to take up challenges.

Introducing Frameworks/Libraries

After getting a grasp of the language through the docs/tutorials and building projects, it's time to choose a framework.
Frameworks are pre-written blocks of code that programmers can incorporate into their projects to save time and effort. Frameworks and libraries make implementation of common tasks very easy because of the provided abstraction.

Choosing a framework to learn can be hard and confusing as you're new to the space, so here are some tips:

Start with a Popular one: Learning a popular framework with a vast community and resources makes it easier to find help and learning materials.
Experiment: Once you're comfortable with one framework, consider exploring others in different domains to broaden your skillset and knowledge.
Focus on Core Programming Concepts: Regardless of the framework, a solid understanding of programming fundamentals is crucial. The ability to learn new frameworks becomes easier as your programming foundation strengthens.

Start learning the framework

Before diving into the framework, ensure you have a good grasp of the programming language it's built on. This will make understanding the framework's syntax and concepts much smoother.

Finding the right resources to learn the chosen framework is not always easy, but I always recommend the Official framework documentation. Most frameworks have comprehensive documentation that covers everything from basic concepts to advanced features. Start here to get a solid understanding of the framework's core principles and functionalities.
Other sources for learning about a framework include Tutorials (e.g. YouTube Videos, Blogs, and Articles), Video Courses (like Udemy or Coursera), and Forums.

Do not waste time in this stage before moving to the next step so you don't get stuck in "Tutorial Hell".

Notice the Key concepts

Don't try to learn everything at once. Prioritize understanding of the framework's core functionalities, architecture, and design patterns. This foundational knowledge will be essential as you build more complex projects.

Build Projects

Yet again, Build projects. Don't wait until you're an expert to start building. Look for small project ideas that allow you to practice the framework's concepts. This will solidify your learning and boost your confidence.

Speaking of taking challenges, allow me to introduce the HNG internship program. HNG is a company with a mission — we work with the very best techies to help them enhance their skills through our HNG internship program and build their network. HNG Internship is a fast-paced boot camp for learning digital skills. It's focused on advanced learners and those with some pre-knowledge, and it gets people into shape for job offers. To register for this program, click here.

I hope these tips were helpful. Remember, growth takes time and dedication so set realistic goals, take breaks and you can also find a study buddy to help you in your journey. Stay consistent friends🙋‍♂️.

The difference between '||' and '??' in JavaScript.

Emmanuel (Emmo00) — Fri, 12 Apr 2024 16:20:23 +0000

Today, we are going to look at the behavior of two operators in JavaScript - the Logical OR Operator (||) and the Nullish Coalescing Operator (??). These operators are usually confused or misunderstood, so let's get right to it.

They are usually used in writing one-liner "hotwires" (providing default values or fallbacks) and while they might seem similar, they serve different purposes and behave differently, especially in the context of handling null or undefined values in JavaScript.

Logical OR Operator `||`

The logical OR operator || is a binary operator that returns the first truthy value it encounters or the last value if none are truthy.
JavaScript considers a value that is not among the following truthy:

false
0
'' (empty string)
null
undefined
NaN

It is used to test whether at least one of the operands is truthy. if the left-hand operand is truthy, it is returned. If it is falsy, the right-hand operand is evaluated and returned.

Example

let name = "Emmanuel";
let defaultName = "Guest";
let displayName = name || defaultName; // Emmanuel

the name variable is not falsy, so the displayName is evaluated to "Emmanuel". Now consider this:

let name = "";
let defaultName = "Guest";
let displayName = name || defaultName; // Guest

In this example, since name is an empty string (which is falsy), the || operator evaluates defaultName and assigns it to displayName.

Nullish Coalescing Operator (??)

The nullish coalescing operator (??) is also a logical operator that returns its right-hand side operand when its left-hand side operand is null or undefined, and otherwise returns its left-hand side operand. Unlike the || operator, it does not consider other falsy values (false, 0, '', NaN) as triggering the fallback.

Example

let age = 0;
let defaultAge = 18;
let userAge = age ?? defaultAge; // 0

In this example, even though age is 0 (which is considered falsy), the ?? operator does not consider it as a trigger for the fallback because 0 is not null or undefined. Therefore, userAge is assigned the value of age, which is 0.

In summary, the || operator is used to test whether at least one of the operands is truthy, while the ?? operator is used to provide a default value for a variable, but only considers null or undefined as falsy.

What is the point of using recursive functions when writing code?

Emmanuel (Emmo00) — Fri, 05 Apr 2024 14:29:43 +0000

Have you ever heard of recursion in programming? It's a cool technique where a function can call itself! It might sound a bit mind-bending at first, but once you understand how it works, it can be an incredibly helpful and interesting to implement in your programs.

Recursive functions are divided into 3 parts:

Base case
logic
Calling itself

Consider this implementation of the factorial(!) function:

function factorial(n) {
    if (n <= 1) { // base case.
        return 1;
    }
    return n * factorial(n - 1); // call itself. (combined with the logic)
}

A base case is a crucial component of a recursive function. It is responsible for preventing the function from calling itself repeatedly, which could result in a stack overflow error. Without a base case, the function would keep calling itself infinitely.

The logic is the part of the function that solves the most basic unit of the bigger problem you are trying to solve with recursion.

Finally, the recursive function has to call itself. That's what recursion is all about.

Now the advantages: ?!?!?!?

Readability: Recursive functions can often be more readable and easier to understand than iterative(loop) functions, especially for problems that have a natural recursive structure.

Conciseness: Recursive functions can be more concise than iterative ones, as they don't require explicit loop variables and increment operations

Modularity: Recursive functions can be more modular than iterative ones, as they can often be divided into smaller subproblems that can be solved recursively.

Tail-recursion optimization: Some programming languages can optimize tail-recursive functions, which can lead to better performance than iterative functions.

Tree-like data structures: Recursive functions are particularly well-suited to tree-like data structures, as they can easily traverse the structure using recursive calls.

However, recursion is not always the best way to implement a solution, here's why:

Space complexity: Recursive functions can sometimes have higher space complexity than iterative functions, as each recursive call adds a new stack frame to the call stack.

Stack overflow: Recursive functions can lead to stack overflow errors if the recursion depth becomes too large. This can be mitigated by using tail recursion or by using an iterative solution.

In conclusion, recursion in programming is a fascinating technique that opens up new avenues for solving problems. By allowing functions to call themselves, recursion offers a powerful approach to tackling complex tasks with elegance and simplicity.
However, it's crucial to recognize that recursion isn't always the optimal solution.

How to use Black and pre-commit for auto text-formatting on commit [setup] [python]

Emmanuel (Emmo00) — Fri, 29 Mar 2024 00:36:07 +0000

Hello👋.

Today we are going to look at how to setup Black (a python code formatter) and pre-commit (a package for handling git hooks in python) to automatically format you code on commit.

All the Code used in this article can be found on this GitHub repo here

Benefits

Setting up your project with this (automatic code formatting on every commit) can be very useful and helpful especially when setting up a GitHub repository you expect other contributors. This enforces coding formatting and fosters consistency in coding style.

Let's get right to it

Installing Black and pre-commit

First of all, we need to install these packages to our projects. You can use the following command to install them:

pip install black pre-commit

You might also need to add these packages to your requirements.txt file so other contributors can install the need packages by running pip install -r requirements.txt. You can do this by running pip freeze, and the coping the output to your requirements.txt file.

Configure pre-commit

The next step is configuring pre-commit. To do this, create a file called .pre-commit-config.yaml:

touch .pre-commit-config.yaml

Then copy the following configurations to this file.

repos:
  - repo: https://github.com/psf/black
    rev: 22.3.0
    hooks:
      - id: black
        args: [--line-length=88]
        language_version: python3.11

This tells Pre-Commit to use Black version 22.3.0 and format all Python files with a line length of 88 characters (you can adjust this to your preference).

Run pre-commit

Now we have our configurations ready, make sure that the current folder you are in is a git/github project (With the .git folder)
Now, run the following command:

pre-commit install

This installs pre-commit hooks to .git\hooks\pre-commit.

Note: you need an internet commit for the first commit you make. This is to enable pre-commit initialize the environment for black, but once the environment is setup, it'd be reused.

$ git commit -m "add pre-commit configuration"
[INFO] Initializing environment for https://github.com/psf/black.      
[INFO] Installing environment for https://github.com/psf/black.        
[INFO] Once installed this environment will be reused.
[INFO] This may take a few minutes...
black................................................(no files to check)Skipped
[main 6e21eab] add pre-commit configuration
 1 file changed, 7 insertions(+)

That's it, you are ready to use the automatic code formatter. Just create a python file, run git add ., and then run git commit -m "Commit message". You'd notice that black attempts to format the file you just created. If you get the following message:

black....................................................................Failed
- hook id: black
- files were modified by this hook

reformatted test.py

All done! \u2728 \U0001f370 \u2728
1 file reformatted.

Just run git add and git commit again.

Enjoy autoformatted code from now on😅. Bye👋

Closures 🫂 Memoisation

Emmanuel (Emmo00) — Fri, 22 Mar 2024 21:34:13 +0000

In functional programming, closure refers to the ability of a function to access and utilize variables from its lexical scope, even after that scope has finished executing. Now, Lexical scope basically refers to the environment/location a variable is defined/declared within the source code.

Closures (forever) remember the scope they were declared in for as long as they exist.

In the above example, the code uses a closure to create a function object that provides controlled access to a private variable. The get method allows you to retrieve the value, and the set method allows you to update it.

This may sound obvious, but it can be very useful in implementing a technique called "memoisation"

Memoization is an optimization technique used in computer science to improve the performance of programs. It's especially useful for improving the performance of functions that are computationally expensive and called multiple times with the same inputs.

Memoisation can basically be described as when expensive operations are run early, and their results cached for later use in the program.

In the above example, the function square_memoise uses memoization by avoiding unnecessary computations for repeated function calls with the same arguments, potentially improving performance.

In conclusion, closures and memoization are powerful tools that enhance the capabilities of functional programming. Closures provide a way to create private variables within functions, leading to better data encapsulation and code organization. Memoization, on the other hand, optimizes program performance by caching the results of expensive calculations, preventing redundant work. By understanding and utilizing these techniques, you can write cleaner, more efficient, and maintainable code.

DEV Community: Emmanuel (Emmo00)

Building x402 Clients on Celo: A Getting-Started Guide

What is x402, from the client's side?

The Flow

Prerequisites

Inspect Before You Code

Celo Token Constants

The Complete Client (Node + viem)

Two Pitfalls That Cost Me Hours

Pitfall #1: The selector MUST be passed to the x402Client constructor

Pitfall #2: Read the actual error from the PAYMENT-REQUIRED header

Other Gotchas Worth Knowing

Paying from a Browser Wallet (ethers)

Skip the Trial and Error: Grab the Skills

Where to Go Next

Building x402 Servers on Celo: A Getting-Started Guide

What is x402?

The Mental Model

Prerequisites

Step 1: Connect Your Facilitators

Step 2: Declare What You Accept

Celo Token Constants

Two Pitfalls That Cost Me Hours

Pitfall #1: The Celo facilitator requires a flat wire shape

Pitfall #2: Calculating price per request in atomic units

Make Your Paywall Discoverable to AI Agents

Test and Debug Your Endpoint

Skip the Trial and Error: Grab the Skills

Where to Go Next

How to Use Claude Code and OpenAI Codex for Free with FreeModel.dev

Why Use FreeModel.dev?

Referral Bonus

Installing Claude Code

Step 1: Install Git Bash (Windows)

Step 2: Install Node.js

Step 3: Create a FreeModel API Key

Step 4: Install Claude Code

Step 5: Configure Claude

Step 6: Launch Claude

Installing OpenAI Codex

Step 1: Install Codex

Step 2: Create the Configuration Directory

Step 3: Create an API Key

Step 4: Create auth.json

Step 5: Create config.toml

Step 6: Verify Installation

Step 7: Start Coding

Updating Claude Code

Uninstalling Claude Code

Troubleshooting

Claude won't start

Codex isn't using FreeModel

Earn More Free Credits

🚀 From Student to Web3 Builder: My Journey, My Project, and Why It Matters

🌐 Why I Chose Web3

🧠 Learning from the Cipher Session

🔨 What I’m Building: [Blockchain-powered verification system that ensures transparent, tamper-proof records of land ownership (BPVSTETTPROLO)]

The problem:

The solution:

🗓️ Join Me for Demo Day!

Self Guide for Deploying Laravel and React Applications on a VPS

1. Initial VPS Setup

Update Your System

Install Essential Dependencies

2. Laravel Backend Deployment

Add ondrej/php PPA as a software repository.

Install PHP and Required Extensions

Install Composer

Set Up MySQL Database

Deploy Your Laravel Application

Configure Apache for Laravel

Set Proper File Permissions

3. React Frontend Deployment

Step 1: Build Your React Application

Step 2: Transfer the Build to Your VPS

Step 3: Configure Apache for React

4. Secure Your Applications with SSL

5. Set Up Process Management for Laravel

Configure Supervisor for Queue Workers

Set Up Laravel Scheduler

Pitfall #1: The selector MUST be passed to the `x402Client` constructor

Pitfall #2: Read the actual error from the `PAYMENT-REQUIRED` header

Logical OR Operator `||`