import { sqlite } from "https://esm.town/v/stevekrouse/sqlite"; const SCHEMA_VERSION = 9; // Increased due to transaction handling improvement const KEY = new URL(import.meta.url).pathname.split("/").at(-1); const TABLE_NAME = `${KEY}_wallets_${SCHEMA_VERSION}`; // accounts start with this much money const startingBalance = 100; interface ApiResponse { status: number; body: any; headers?: Record; } function normalizeAddress(address: string): string { return address.toLowerCase(); } async function initializeDatabase() { await sqlite.execute(` CREATE TABLE IF NOT EXISTS ${TABLE_NAME} ( address TEXT PRIMARY KEY, balance INTEGER NOT NULL DEFAULT 0 ) `); } async function getBalance(address: string): Promise { const normalizedAddress = normalizeAddress(address); const result = await sqlite.execute( `SELECT balance FROM ${TABLE_NAME} WHERE address = ?`, [normalizedAddress], ); if (result.rows.length === 0) { await incrementBalance(normalizedAddress, startingBalance); return startingBalance; } return result.rows[0].balance; } async function setBalance(address: string, amount: number) { const normalizedAddress = normalizeAddress(address); await sqlite.execute( `INSERT INTO ${TABLE_NAME} (address, balance) VALUES (?, ?) ON CONFLICT (address) DO UPDATE SET balance = ?`, [normalizedAddress, amount, amount], ); } async function incrementBalance(address: string, amount: number) { const normalizedAddress = normalizeAddress(address); await sqlite.execute( `INSERT INTO ${TABLE_NAME} (address, balance) VALUES (?, ?) ON CONFLICT (address) DO UPDATE SET balance = balance + ?`, [normalizedAddress, amount, amount], ); } async function decrementBalance(address: string, amount: number) { await incrementBalance(address, -amount); } async function getAllAccounts(): Promise<{ address: string; balance: number }[]> { const result = await sqlite.execute(`SELECT address, balance FROM ${TABLE_NAME}`); return result.rows.map(row => ({ address: String(row.address), balance: Number(row.balance) })); } async function mint(address: string, amount: number) { await incrementBalance(address, amount); } function generateInstructions(baseUrl: string): string { return ` Token Trading Account Emulator

Token Trading Account Emulator

This endpoint emulates a token trading account. You can check balances, send tokens, and receive tokens.

Checking Balance

To check the balance of an address, use the following curl command:

curl "${baseUrl}/balance?address=user1"

Sending Tokens

To send tokens, use the following curl command:

curl -X POST ${baseUrl}/send \\
     -H "Content-Type: application/json" \\
     -d '{
       "from": "user1",
       "to": "user2",
       "amount": 5
     }'

Listing All Accounts

To list all active accounts and their balances, use the following curl command:

curl "${baseUrl}/accounts"

Minting Tokens*

Requires Chairman Authorization

To mint new tokens, use the following curl command:

curl -X POST ${baseUrl}/mint \\
     -H "Content-Type: application/json" \\
     -H "Authorization: Bearer CHAIRMAN_PASSWORD" \\
     -d '{
       "address": "user2",
       "amount": 1000
     }'

Notes

New addresses are automatically created with a balance of 100 tokens.
Sending tokens requires sufficient balance in the sender's account.
Addresses are case-insensitive. "user1" and "USER1" refer to the same account.
Minting new tokens requires the chairman's password.

View source: Val Town

`; } function handleHome(baseUrl: string): ApiResponse { return { status: 200, body: generateInstructions(baseUrl), headers: { "Content-Type": "text/html" }, }; } async function handleBalance(address: string | null): Promise { if (!address) { return { status: 400, body: { error: "Address is required" }, }; } const balance = await getBalance(address); return { status: 200, body: { balance }, }; } async function handleSend(data: any): Promise { const { from, to, amount } = data; if (!from || !to || amount === undefined) { return { status: 400, body: { error: "From, to, and amount are required" }, }; } if (typeof amount !== "number" || amount <= 0) { return { status: 400, body: { error: "Amount must be a positive number" }, }; } const senderBalance = await getBalance(from); if (senderBalance < amount) { return { status: 400, body: { error: "Insufficient balance" }, }; } // TODO would be nice to wrap in a txn await decrementBalance(from, amount); await incrementBalance(to, amount); const newSenderBalance = await getBalance(from); const newRecipientBalance = await getBalance(to); return { status: 200, body: { message: "Transaction successful", sender: { address: normalizeAddress(from), balance: newSenderBalance }, recipient: { address: normalizeAddress(to), balance: newRecipientBalance }, amount: amount, }, }; } async function handleAccounts(): Promise { const accounts = await getAllAccounts(); return { status: 200, body: { accounts }, }; } async function handleMint(data: any, authHeader: string | null): Promise { const { address, amount } = data; if (!address || amount === undefined) { return { status: 400, body: { error: "Address and amount are required" }, }; } if (typeof amount !== "number" || amount <= 0) { return { status: 400, body: { error: "Amount must be a positive number" }, }; } if (!authHeader || authHeader !== `Bearer ${Deno.env.get("CHAIRMAN_PASSWORD")}`) { console.warn("Invalid chairman authorization:", authHeader) return { status: 403, body: { error: "Invalid chairman authorization" }, }; } await mint(address, amount); const newBalance = await getBalance(address); return { status: 200, body: { message: "Minting successful", address: normalizeAddress(address), amountMinted: amount, newBalance: newBalance, }, }; } function handleFavicon(): ApiResponse { return { status: 204, body: null, }; } function handleNotFound(): ApiResponse { return { status: 404, body: { error: "Not found" }, }; } function logRequestResponse(req: Request, res: ApiResponse) { console.log(`Request: ${req.method} ${req.url}`); console.log(`Response: Status ${res.status}, Body:`, res.body); } export default async function(req: Request): Promise { await initializeDatabase(); const url = new URL(req.url); const path = url.pathname; let response: ApiResponse; switch (true) { case req.method === "GET" && path === "/": response = handleHome(url.origin); break; case req.method === "GET" && path === "/balance": response = await handleBalance(url.searchParams.get("address")); break; case req.method === "POST" && path === "/send": response = await handleSend(await req.json()); break; case req.method === "GET" && path === "/accounts": response = await handleAccounts(); break; case req.method === "POST" && path === "/mint": response = await handleMint(await req.json(), req.headers.get("Authorization")); break; case req.method === "GET" && path === "/favicon.ico": response = handleFavicon(); break; default: response = handleNotFound(); } logRequestResponse(req, response); return new Response( response.headers?.["Content-Type"] === "text/html" ? response.body : JSON.stringify(response.body), { status: response.status, headers: { "Content-Type": response.headers?.["Content-Type"] || "application/json", ...response.headers, }, }, ); }

glifbux