TYPE/262 is live. Tokenize the apps you love. BjVsSDQoNbxswtPLtpAr5QXZTEXQsfEQTAz7A7iipump TYPE/262 is an open launchpad that ties a coin to a domain instead of a person. Launch a @pumpdotfun coin for any app, web game or website, and its creator fees go to that domain. Only its real owner can claim them. Why a domain. Fees routed to an X profile or a GitHub repo can be farmed: a lookalike handle, a renamed account or a fork passes for the real thing. The domain an app lives on can't be faked. Only its owner controls its DNS, and DNSSEC proves it, signature by signature, from the root keys down. The record. In June 2024, IANA // iana.org allocated RRTYPE 262, WALLET: an official DNS record for crypto addresses. TYPE/262 switches it on. One TXT line, _wallet.yourapp.com "SOL <address>", makes any domain payable. The vault. Every domain gets its own Solana address. A coin launched on TYPE/262 names that vault as its pump.fun creator, so every creator fee, on the curve and on PumpSwap after graduation, belongs to the domain. Fans can send it SOL or USDC too, before the app has ever heard of TYPE/262. The claim. The owner publishes the record and turns on DNSSEC. Cloudflare and Google must both answer, agree and validate the signatures. Then the vault pays the published wallet, minus 0.5%. Senders can take back deposits nobody claimed after 180 days. Nothing is taken on trust. Every vault, deposit, payout and refund is public on-chain. The Unclaimed Board ranks every app with money waiting, read straight from the chain: no indexer, no database. Built for agents too: any AI agent can check that an x402 payTo address really belongs to the domain it is paying. Fully open source under MIT: SDK, CLI, vault worker, contracts and the app. type262.com github.com/Type262/262

Pay any domain on @base // Multichain update. TYPE/262 now reaches its third chain. Any domain that publishes an EVM address in its WALLET record can be paid on Base, in USDC or ETH, straight to the address the domain publishes. One record works across every EVM chain we support, so a domain doesn't need to change anything. In the app, open Pay and enter a domain. When it publishes an EVM address, pick the network: @RobinhoodCrypto Chain for $USDG or $ETH, or @Base for $USDC or $ETH. Your wallet switches to Base, the transfer goes to the address the domain signed with DNSSEC, and the receipt is read straight from Base. A domain's pay button and payment link pick up Base the same way. When a domain publishes more than one EVM address, Base pays the one published for that asset, then its ETH line. An address published only under another chain's code is never paid on Base. This matters most for agents. x402 payments commonly settle in USDC on Base, and TYPE/262 already checks that an x402 payTo address belongs to the domain asking for payment. Verify now also shows the network a 402 response names next to each address, and the MCP server can pay a domain on Base directly, within its own spend limits, once the domain's EVM address is signed and every resolver agrees on it. From a terminal: type262 link yoursite.com 5 USDC base

Update: fund many domains at once. The software most of us depend on every day is built by people we never pay: the libraries in our projects, the tools we open every morning, the sites we read. Supporting them one by one, payment by payment, is slow enough that almost nobody does it. In the app, open Escrow and switch to Many domains. Paste up to 25 domains or links, or drop in a project's package.json and TYPE/262 looks up each dependency's homepage on npm. Choose SOL or USDC, and a total to split evenly or an amount for each. Every domain is routed on its own: - A domain that publishes a DNSSEC-signed Solana wallet, confirmed by both Cloudflare and Google, is paid at that wallet directly. - Every other domain gets its share in its own vault, where its owner claims it with one signed DNS record. Anything unclaimed after 180 days can be taken back from that domain's page. - Names that can't belong to a single owner are left out with the reason: pages on code hosts and app stores, subdomains of shared hosts, link shorteners, and email addresses at mail providers. Before anything is signed, you see the full plan: each domain, its route, its address and its amount, the total, the network fees, and how many wallet approvals it takes. The payments are packed into as few transactions as fit, 12 SOL payments in a single one. Each is simulated before your wallet sees it, and every route is checked again the moment you press Send. Every vault payment carries its own board tag, so each domain shows up on the Unclaimed Board with exactly what reached its vault. type262.com/app.html#escrow/…

Official token records. Every project with a token runs into the same problem. Within hours of a launch, copies appear with the same name, the same logo and the same ticker, and people looking for the contract address have to trust a reply, a screenshot or a pinned post. None of that is proof. A domain is. A project can now name its own tokens in DNS, with one TXT record at its domain: _token.yoursite.com TXT "SOL <mint>" The record names the chain and the address: SOL for a Solana mint, and HOOD, BASE or ETH for a token contract on Robinhood Chain, Base or Ethereum. It is signed with DNSSEC, so it can only come from whoever controls the domain, and anyone can check it from the internet's root keys down. In the app, open Verify and switch to Official token. Enter the project's domain and paste the coin as a mint, a pump.fun link or an explorer link. TYPE/262 reads the record through Cloudflare and Google and tells you exactly where the coin stands: official and signed, listed but not signed, not listed by that domain, or a domain that lists no tokens at all. An explorer link carries its chain, so a Base contract only matches a Base record. The same check runs on Launch → Explore: a coin whose domain lists it in a signed record carries an "Official · listed by <domain>" tag. Publish writes the record for you, and developers get the same check through the CLI and the SDK: type262 token yoursite.com <mint>

Three new features just shipped on TYPE/262. They're live on type262.com now, and the code is public on GitHub. Over the next few hours we'll walk through each of them: what it does, how it works under the hood, and why we built it. github.com/Type262/262/commi… Each one is built on the same foundation as everything else here: a domain's own DNS record, signed with DNSSEC and checked by anyone. Together they push that foundation further than it has gone so far. They change what a domain can prove about itself, what it takes to support the projects you rely on, and how far TYPE/262 reaches. TYPE/262 started as a way to make one record useful. These updates are where it starts to become infrastructure. github.com/Type262/262

A growing number of launchpads route a coin's fees to an X handle or a GitHub repo. Both look like identity. Neither was built to be one. An X handle is a username, and usernames move. When an account renames, the old handle is released and anyone can register it. Lookalikes cost nothing: a capital I for a lowercase l, an extra underscore, a Cyrillic letter that renders the same. Accounts get taken over through phishing and SIM swaps, and suspended ones can lose access overnight. A GitHub repo is even easier to copy. A fork is byte-for-byte identical, stars can be bought, and repositories get renamed and transferred. GitHub redirects the old path, and once the original owner moves on, an abandoned name can be registered by someone else, an attack known as repojacking. In both cases, the check that decides who gets paid happens inside a company's API. The launchpad's server asks X or GitHub through OAuth who you are, and everyone else has to trust that server's answer. Nobody outside can verify it, and no smart contract can check it. So the fees end up attached to whatever looked most like the project on the day someone clicked launch. TYPE/262 points fees at the one identifier that was built to be unique and provable: the domain.

The third step on TYPE/262: checking an x402 payTo before anything is paid. An x402 server answers a request with 402 Payment Required and names the address it wants paid. Nothing in that response proves the address belongs to the site. A compromised server, a malicious proxy or a lookalike domain can each name their own. In the app, open Verify and paste the URL with the address, or the whole 402 response. TYPE/262 takes the server's domain, resolves its WALLET record through Cloudflare and Google, and tells you whether the payTo is an address the domain itself published and signed with DNSSEC, published but unsigned, or not published at all. Agents get the same check as a tool: verify_payto in the MCP server returns safe, unsigned or no_match for every payTo in a 402 body, before any money moves.

What a WALLET record actually looks like. RRTYPE 262 doesn't invent a new wire format. Paul Hoffman's application defines it as identical to TXT: one or more length-prefixed strings. The first string is the currency code, and the second is the address, exactly as a wallet displays it. type262.com publishes this one: SOL 9QKi39EkFTM1x64TPG3H4mcMDkG85oWUttPdvzNjtvJP In RFC 3597's generic syntax, which DNS servers accept for a type they don't know by name: type262.com. 3600 IN TYPE262 \# 49 03534F4C2C39514B6933… 03 is the length of "SOL". 2C is 44, the length of the address. 1 + 3 + 1 + 44 = 49 bytes of record data. The catch: most DNS dashboards, including Cloudflare's, only offer the record types they already list. So TYPE/262 also reads the same pair from a TXT record at _wallet.<domain>, and holds it to the same rules: it must be DNSSEC-signed, and Cloudflare and Google must return the same address. The CLI prints all three forms for any domain and address: node bin/type262.mjs encode yoursite.com SOL <address>

We're working on going fully multi-chain. Right now, you can already launch a token and direct its fees to a domain on @solana and @RobinhoodCrypto. We're working on integrating more chains and optimizing our infrastructure. We appreciate your patience and support.

TYPE/262: paying a domain, whether or not it has a wallet yet. In the app, open Pay and enter any domain. TYPE/262 looks up its WALLET record and checks DNSSEC, then your wallet sends SOL or USDC on Solana straight to the address the domain publishes. If the domain hasn't published a wallet yet, open Escrow instead. The money waits in that domain's own vault on Solana, in public, until the owner claims it with one DNSSEC-signed record. If it's still unclaimed after 180 days, it comes back to you.

A note on DNSSEC, because it is the part that makes the proof above mean something. DNS is the internet's address book. When you look up a name, the answer passes through resolvers, routers and networks you do not control, and plain DNS has no way to prove that answer is genuine. Anyone along the path can return a forged one. For a website, HTTPS catches that: a fake server cannot present the site's certificate. A wallet address in DNS has no such second check. If someone forges the answer, the money goes to them. DNSSEC closes that gap. Every record is signed with the domain's own key, and each level of DNS vouches for the one below it: the root vouches for .com, and .com vouches for type262.com. The root keys are managed by IANA in public key-signing ceremonies, and the root has been signed since 2010. Any validator can follow that chain from the record back to the root and confirm the answer came from the domain's owner and was not changed along the way. TYPE/262 is built on that guarantee. A domain's vault pays out only to the wallet named in a DNSSEC-validated record: - On Solana, Cloudflare and Google must both validate the record and agree on it. - On Robinhood Chain, the contracts check the signatures themselves, on-chain, from the root keys down. The same check lets AI agents confirm that a payment address really belongs to the domain they are paying. type262.com is now signed, and its record validates on both resolvers. Next, we claim its vault with that record and post the transaction.

A note on DNSSEC, because it is the part that makes the proof above mean something. DNS is the internet's address book. When you look up a name, the answer passes through resolvers, routers and networks you do not control, and plain DNS has no way to prove that answer is genuine. Anyone along the path can return a forged one. For a website, HTTPS catches that: a fake server cannot present the site's certificate. A wallet address in DNS has no such second check. If someone forges the answer, the money goes to them. DNSSEC closes that gap. Every record is signed with the domain's own key, and each level of DNS vouches for the one below it: the root vouches for .com, and .com vouches for type262.com. The root keys are managed by IANA in public key-signing ceremonies, and the root has been signed since 2010. Any validator can follow that chain from the record back to the root and confirm the answer came from the domain's owner and was not changed along the way. TYPE/262 is built on that guarantee. A domain's vault pays out only to the wallet named in a DNSSEC-validated record: - On Solana, Cloudflare and Google must both validate the record and agree on it. - On Robinhood Chain, the contracts check the signatures themselves, on-chain, from the root keys down. The same check lets AI agents confirm that a payment address really belongs to the domain they are paying. type262.com is now signed, and its record validates on both resolvers. Next, we claim its vault with that record and post the transaction.

The first step on TYPE/262: publishing your domain's wallet. It takes one DNS record. In the app, open Publish, connect your Solana wallet and enter your domain. TYPE/262 builds the record for you: _wallet.yourdomain.com TXT "SOL <your address>" Add it at your DNS provider, then turn on DNSSEC so the zone is signed. In Resolve, Cloudflare and Google both return the record, the signatures validate, and the domain resolves to your address. From then on, anyone can pay the domain by name, AI agents can verify it as an x402 payTo, and the same record is what lets you claim the domain's vault and its pump.fun creator fees. type262.com

A domain can now prove which wallet stands behind a token, and anyone can check it with one command. Here is everything you need to verify our tech works. 1. The domain names its wallet. type262.com publishes its wallet in DNS, at _wallet.type262.com: SOL 9QKi39EkFTM1x64TPG3H4mcMDkG85oWUttPdvzNjtvJP The record is signed with DNSSEC. Its signatures chain from the internet's root keys, through .com, to type262.com, so the answer cannot be forged on its way to you. Verify it with: dig @1.1.1.1 +dnssec _wallet.type262.com TXT The "ad" flag in the response means the signature chain checked out. 2. That wallet created $262. The same address is the creator of $262 on pump.fun: solscan.io/account/9QKi39EkF… The link from our domain to our token is public, signed and checkable by anyone. An impersonator can copy our name, our logo and our posts, but not a valid signature for type262.com. 3. The launchpad sends fees to domains. Coins launched through TYPE/262 name a domain's vault as their pump.fun creator. TEST1 was launched for type262.com, and its creator is that domain's own vault: 3zLpW3d1U7ycyhAuPQJyVoKxJMkLzcyBAiABPszY7Zen. Every trade pays creator fees into it. A coin launched for wikipedia.org works the same way: its fees wait in that domain's vault until the owner publishes a record. 4. Only the real owner can claim. A vault pays out only to the wallet named in a DNSSEC-validated record. On Solana, Cloudflare and Google must both validate the record and agree on it. On Robinhood Chain, the contracts check the signatures on-chain, from the root keys down. Next, we will claim type262.com's vault with the record above and post the transaction here. Every coin launched through TYPE/262 is listed in the app's Explore tab, and all of the code is open source: github.com/Type262/262

We covered where WALLET came from: an application to IANA, filed by Paul Hoffman of ICANN, allocated as RRTYPE 262 in June 2024. This is how TYPE/262 resolves it. A domain publishes its Solana address as a WALLET record, with a _wallet TXT record as fallback, in a DNSSEC-signed zone. The client queries Cloudflare and Google over DoH and accepts the address only when both answers are DNSSEC-validated and identical. For x402, the same check runs before payment. verifyPayTo(url, payTo) confirms that the payTo address in a 402 response is published by the endpoint's own domain. On a mismatch it returns not-ok, and the agent doesn't pay. Domains without a record can still receive. Funds sent to the name wait in that domain's vault on Solana, and are released to the address the owner publishes once it passes the same two-resolver check, less 0.5%. Unclaimed deposits are refundable to the sender after 180 days. Payments settle on @solana, in $SOL or $USDC. Every step is in the open-source code. github.com/Type262/262

Every DNS record type starts as an application to IANA. This is the one for type 262, WALLET, filed by Paul Hoffman of ICANN. Its purpose: link crypto wallets to "a human-memorable name like a domain name." We built the software it was waiting for. iana.org/assignments/dns-par…

Open the internet's official list of DNS record types, scroll to number 262, and you will find a word nobody expected there: WALLET. iana.org/assignments/dns-par… IANA, the authority that has kept the internet's core identifiers since its earliest days, added RRTYPE 262 on June 21, 2024: "Public wallet address." It is a standard place for any domain to say where it gets paid, in the same DNS that already finds every website on Earth. Publish one DNSSEC-signed record, and any wallet, app or AI agent can pay your domain and know the address is authentic. Every domain already has a vault on Solana, so anyone can send a website SOL or USDC today, and only the real owner can claim it. Launch a pump.fun coin for any app, and its creator fees go to the domain, the one identity that can't be cloned or impersonated. It is all open source under the MIT license. The standard is in IANA's registry, the code is on GitHub, and the money is on-chain. github.com/Type262/262

Since June 2024, every domain on the internet has had an official way to become a wallet, and almost nobody has used it. On June 21, 2024, iana.org allocated a new DNS record type: RRTYPE 262, WALLET. IANA is the authority Jon Postel ran, the engineer who helped create the domain system and its first top-level domains, .com among them. WALLET was not invented by a crypto startup. An ICANN technologist requested it, and it sits in the same registry that defines how every website on the internet is found. Then it went dormant. More than two years later, almost no wallet, app or AI agent reads it. We have seen this before. HTTP 402, "Payment Required", was reserved in 1997 and waited almost three decades until x402 put it to work with stablecoins. WALLET is the same kind of primitive: native to the internet, standardized at the root, and unused. TYPE/262 switches it on. Publish one DNS record and your domain becomes payable. Any person, wallet or AI agent can resolve yoursite.com to a verified address and pay it in SOL or USDC on Solana. DNSSEC proves the answer came from the domain's real owner. Every domain already has a vault on Solana. Anyone can send money to any website today, even one that has never heard of us. The money waits in public until the owner publishes a signed record naming their wallet, and only that wallet can claim it. Builders and communities can launch a pump.fun coin for any app, game or website, with the domain's vault as the creator. Every trade pays creator fees to the domain, the one identity that can't be faked. Repos can be cloned and social accounts can be impersonated, but the domain where an app actually lives has one owner. For AI agents, it closes a gap that grows with every payment they make. Before paying an x402 payTo address, an agent can confirm that the domain it is dealing with actually published that address. Today, we are making all of it open source. All of it is public under the MIT license, with its tests: - the web app - the vault and claim worker - the Solana program - the Robinhood Chain contracts that verify DNSSEC on-chain from the IANA root keys - the resolver library - the CLI - the MCP server for AI agents Infrastructure that moves money for domains should be readable by anyone. Every rule is in the code, and every vault, deposit and launch is on-chain for anyone to check. Read it, run it, fork it, build on it. Every domain is a wallet. github.com/Type262/262