ORIGIN Docs

Get started

What Origin is

Origin lets a DogeOS app ask Dogecoin a question and use the answer. Does this wallet hold the coin? Does it own a Doginal from this collection? Did this payment confirm?

Origin indexes every Dogecoin block: DOGE, UTXOs, inscriptions, Doginals, collections and the full DRC-20 ledger. One front door for all of it. You can search it, read it from your server, or use it from a DogeOS contract. When you need to write back to Dogecoin, Origin hands you the request, and your user’s wallet signs it.

Dogecoin L1Origin indexerOriginYour app or contract
New here? You don’t need to run a node or understand inscriptions to start. Open Origin, pick a door, and follow it. Every answer ends with code you can copy.
Going deeper. Origin doesn’t keep its own copy of the chain. Answers resolve against Origin’s indexer, using fail-closed rules: if something can’t be proven, the answer is no. See Trust model.

Get started

Quickstart

Three ways in. Use whichever matches where you are.

1. No code

Go to ø.co, paste a Dogecoin address and type DU$T balance. You get the answer, where it came from, and your plugs.

2. From your server or frontend

Every fact Origin shows can be read straight from Origin’s public API. No key needed.

terminal
curl -s 'https://explorer.dogesoft.io/api/wallet/address/DPXjXNN2oiY8UWdGK1U5PgwK6ZV8cstn1s/drc20'
response (trimmed)
{
  "address": "DPXjXNN2oiY8UWdGK1U5PgwK6ZV8cstn1s",
  "balances": [
    { "tick": "DU$T", "balance": "6969", "available": "6969.0", "transferable": "0.0", "decimals": 18 }
  ]
}

3. From a DogeOS contract

Your contract calls Origin, Origin returns the fact. One address, one interface.

HoldersOnly.sol
interface IOrigin {
    function drc20Balance(string calldata dogeAddress, string calldata tick)
        external view returns (uint256 amount, uint64 l1Height, uint64 attestedAt);
}

contract HoldersOnly {
    IOrigin public immutable origin;
    constructor(IOrigin origin_) { origin = origin_; }

    function canEnter(string calldata dogeAddress) external view returns (bool) {
        (uint256 amount, , uint64 attestedAt) = origin.drc20Balance(dogeAddress, "DU$T");
        require(block.timestamp - attestedAt <= 1 hours, "stale");
        return amount >= 1_000_000 * 1e18;
    }
}
Live on DogeOS testnet. Origin is at 0xcc816160fF36891090780Aca810f637600329d5E on Chikyū (chain id 6281971). All addresses: index.json.

Get started

What’s live today

We only call something live when you can use it right now.

PieceStateWhere
Search and guided pathsLiveø.co · origin.dogesoft.io
Read API (balances, Doginals, collections, txs)Liveexplorer.dogesoft.io/api
Origin, OriginPlugs, OriginEnvelope contractsLive · testnetABI explorer · addresses
Origin Services (OriginInscriber, OriginAnchor)Live · testnetSee Origin Services
Genesis ANCHOR (prove any Dogecoin block or tx)Live · freeSee Genesis ANCHOR
Plugs marketplaceLive · testnetplugs.dogesoft.io
Built on Origin badgeLiveSee badge
Signed facts (attestations)Live/api/attest · multi-signed by Origin attesters, posted to Origin on DogeOS
Origin ProofPlannedSee Origin Proof
OP_CHECKZKP shadow index · OP_RETURN indexLiveProof checking still to come. See OP_CHECKZKP

DogeOS itself is still on testnet: Chikyū, chain id 6281971, RPC https://rpc.testnet.dogeos.com.

Get started

Plugs and earning

A plug is one reusable piece of a Dogecoin-powered build. “Holders of this coin get in.” “This Doginal is a playable character.”

How the money moves

99%of every plug license sale goes to the creator.
1%platform fee to Origin, fixed in the OriginPlugs contract.
20%of every paid call made through a verified plug goes to its creator: fresh facts (0.05 DOGE), inscriptions and stamps. Name your plug in the request (plugId). The rest funds attesters and the treasury.
Freereading facts on DogeOS. View calls never cost anything.
Live. The marketplace is open on DogeOS testnet at plugs.dogesoft.io. OriginPlugs: 0x71a96204D86194FfA46b04f89eB7eB6a0B2D4290.

Get started

DogeSoft base plugs

Every build starts from the DogeSoft base for its category. Bases are free, owned by DogeSoft, and run on DogeSoft’s inscriber, the Inscription Standard, indexer and attesters.

IdentityWallet Connect Base (in every build) and Signature Verify Base
Bridge & PaymentsBridge Base, the one doorway for value and proof between Dogecoin and Origin (replaces Doge Confirm)
HoldersHolder Gate Base
DoginalsDoginal Verify Base
CoinsCoin Data Base
ProofAnchor Base (free, under Season Seal)
InscriberInscriber Base
ZKZK Base (read only while OP_CHECKZKP is a draft)
Coming. Bases are in the catalogue and the console today. Listing them on OriginPlugs comes next.

Get started

Build console, SDK and webhooks

From an idea to a deployed contract without leaving Origin.

Get started

Origin Services

Write to Dogecoin from a DogeOS contract. Pay in DOGE and Origin does the L1 work.

ServicePriceWhat you get
OriginInscriber0.01 DOGE on-chain base (per verb) + Soft license meteringPlain Doginal under the Inscription Standard via the licensed SoftInscribeBase. Body needs a Soft-issued ref. Free quota per license/day for refs and assists; overage billed by Soft (see /api/metering). Max 1.4 KB.
OriginAnchor1 DOGEUp to 76 bytes in an OP_RETURN, e.g. a hash that proves a leaderboard or a document.
Origin.requestFact0.05 DOGEOne fresh fact, read now instead of from the last update.

Attesters re-read the result from Dogecoin before signing a receipt, so you get exactly the bytes you paid for. If it isn’t done in 24 hours, reclaim gives your fee back. DRC-20 bodies aren’t offered. Full guide: docs.dogesoft.io/origin/services.

Dogecoin basics

UTXOs in one minute

Dogecoin doesn’t store account balances. It stores coins sitting in outputs.

Every transaction spends some earlier outputs and creates new ones. An output nobody has spent yet is a UTXO (unspent transaction output). A wallet’s DOGE balance is the sum of the UTXOs it can spend.

An output is named by the transaction that created it plus its position: txid:vout. That pair is an outpoint. You’ll see outpoints a lot, because inscriptions live on them.

Coming from Ethereum? There’s no balanceOf on Dogecoin. Think of a wallet as a purse of exact bills. Paying means handing over whole bills and getting change back as a new bill.

Dogecoin basics

Inscriptions and Doginals

An inscription is data written into a Dogecoin transaction. A Doginal is a one-of-a-kind inscription, collected like an NFT.

The data (an image, text, JSON, HTML, audio, video) sits inside an envelope in the transaction. It gets an id like <txid>i0. The inscription then rides on a small output called the carrier. Whoever holds the carrier UTXO owns the inscription. To move it, you spend that output to someone else.

Collections aren’t a chain object. Origin keeps a registry of which inscriptions belong to which collection (298 at last count), and Origin uses it to answer “does this wallet own one of these?”.

Going deeper. Large files are split across many transactions (multipart). Origin’s indexer reassembles them and stores a SHA-256 of the full content, which Origin returns as contentHash.

Dogecoin basics

DRC-20 coins

DRC-20 coins are written on Dogecoin with plain-text inscriptions. No contract is involved.

A coin is deployed, minted and moved by inscribing small JSON bodies like {"p":"drc-20","op":"transfer","tick":"DU$T","amt":"10"}. An indexer replays every block to keep the ledger.

Sending a coin is two steps:

  1. Inscribe the transfer to your own address. That amount becomes transferable, meaning locked inside that inscription.
  2. Move the inscription to the recipient. When the move confirms, the ledger debits you and credits them.

That’s why a balance has three numbers. Balance is the total. Available is free to inscribe. Transferable is locked in transfer inscriptions that haven’t moved yet.

Going deeper. Tickers are exact, symbols included (DU$T is not DUST). The only transform Origin applies is lowercase with control characters removed. Amounts in Origin return values are base units: amount × 10^decimals.

Dogecoin basics

Confirmations

A transaction is confirmed once it’s in a block. Each block after that adds a confirmation.

Dogecoin makes a block about every minute. Six confirmations is a common bar for “this won’t change”. Origin defaults to six for payments, and you can ask for more.

DRC-20 is one step behind: the ledger can only settle a block once Origin’s indexer has processed it. Origin reports the height the ledger is indexed to, and answers pending for anything newer.

Dogecoin basics

Words we use

CoinA DRC-20 asset. We say coin, not token. It’s inscribed on L1, not issued by a contract.
DoginalA one-of-a-kind inscription.
KoinuSmallest DOGE unit. 1 DOGE = 100,000,000 koinu.
FeeDogecoin charges per byte. There’s no gas.
Commit / revealThe two transactions that write an inscription.
MoveThe transaction that hands an inscription to its recipient.
FactOne thing Origin can tell you, e.g. a coin balance at a block height.
L1 / L2Dogecoin mainnet / DogeOS.

Guide

Reward holders of a coin

Only let people in, airdrop, or unlock a feature if their Dogecoin wallet holds enough of a coin.

  1. On Origin, choose I have a coin → Let DogeOS apps reward my holders, or Building an app → A wallet holds a coin.
  2. Enter the ticker, a wallet to test with, and the minimum.
  3. Copy plug 01 to check it from your server today, or plug 02 for your contract.
server, today
const res = await fetch(`https://explorer.dogesoft.io/api/wallet/address/${addr}/drc20`);
const { balances } = await res.json();
const dust = balances.find((b) => b.tick.toLowerCase() === 'du$t');
const ok = Number(dust?.balance ?? 0) >= 1_000_000;
Which wallet is “theirs”? A DogeOS contract sees an EVM address, while the coins sit at a Dogecoin address. Until Origin’s address-link fact ships, have users prove their Dogecoin address with window.dogesoft.signMessage on your site, and check the signature on your server.

Guide

Reward holders of a collection

“Does this wallet own at least one DU$TINAL DOG?”

  1. Choose I have Doginals → Let DogeOS apps reward my holders.
  2. Start typing the collection name. The list fills from Origin’s registry.
  3. Origin counts the Doginals that wallet holds right now and confirms each one against the registry.

The Origin call is collectionCount(dogeAddress, collectionId). Collection ids are slugs like dustinal-dogs.

Going deeper. Ownership means the address holds the carrier UTXO, checked against Origin’s collection registry.

Guide

Verify a coin transfer

Paste a txid and ask “was this DRC-20 transfer valid?”.

Origin fails closed. A transfer is valid only when the move settled on the ledger and wasn’t settled by a manual repair or sweep. If the indexer hasn’t reached that block yet, the answer is pending, never yes.

terminal
curl -s 'https://explorer.dogesoft.io/api/explorer/tx/06f8c5cc6c54e94045db7b0fe2ee82f4d95dc8b12a4fcf3d4d5eb85d0d7450ed'
# look at drc20_operations[].data.ledger_settled and .settle_reason

Guide

Confirm a DOGE payment

Ship the order once the payment has enough confirmations.

server
const tx = await fetch(`https://explorer.dogesoft.io/api/tx/${txid}`).then((r) => r.json());
const paid = tx.confirmations >= 6;

On DogeOS the call is txConfirmed(txid, minConfirmations). The txid is passed as bytes32, written exactly as explorers display it. See Encoding rules.

Guide

Check an inscription is real

Paste an inscription id (…i0). Origin tells you whether Origin parsed it from chain, which envelope it uses, its content hash, where it was born and who holds it.

Inscription Standard means the body’s JSON opens with a ds tag: {"ds":{"action":"<VERB>","ref":"<id>"}}. Legacy Doginal means a valid inscription made before the standard. Both are real. The label tells you which rules it was written under.

Guide

Verify an inscription

Your users inscribe with their own Dogecoin wallet, using the Inscription Standard. Your DogeOS contract proves it landed exactly as expected.

  1. Expect. Your contract computes the hash it expects with OriginEnvelope.envelopeHashOf(contentType, body). No owner, no storage, nothing to trust.
  2. Inscribe. The user inscribes it on Dogecoin from their own wallet as a plain Doginal, with the verb inside the body’s ds tag. Origin never holds their key.
  3. Prove. Once it has 6 confirmations, Origin’s attesters record what landed. origin.inscriptionMatches(inscriptionId, envelopeHash) is true only if it is byte-for-byte what you expected.
PrizeCheck.sol
bytes memory body = envelope.launchMintBody("dustinal-dogs", id, "777");
bytes32 expected = envelope.envelopeHashOf("application/json", body);
// after the user inscribes it with their own wallet:
require(origin.inscriptionMatches(inscriptionId, expected), "not the prize we minted");
require(origin.isInscriptionOwner(inscriptionId, dogeAddress), "not theirs");
New here? You don’t build the tag yourself. OriginEnvelope has launchMintBody and dsTag for the standard JSON byte-for-byte, plus drc20TransferBody and drc20MintBody for the separate DRC-20 protocol.
Going deeper. envelopeHash = keccak256(abi.encode(contentType, body)), where the body opens with {"ds":{"action":"<VERB>","ref":"<id>"}}. Nothing but the plain Doginal goes on chain: no ACTION push, no metadata pushes. The SDK computes the same hash and is tested byte-for-byte against the contract.

Guide · Anchor Base

Genesis ANCHOR — prove any Dogecoin block or tx Free

Ask Origin “is this Dogecoin transaction or block real?” and get back proof, not an opinion.

Origin fetches the raw block from a Dogecoin node and recomputes everything itself: every txid, the merkle root and your transaction’s merkle path, the block hash and the proof of work. It also checks the block is on the best chain. Once a result is 7+ confirmations deep, the attesters sign it as an Origin fact your DogeOS contract can check. Nothing is inscribed and nothing is charged.

terminal · the very first Dogecoin transaction
curl -s 'https://origin.dogesoft.io/api/anchor/verify?tx=5b2a3f53f605d62c53e62932dac6925e3d74afa5a4b459745c36d42d0ed26a69'
# → "verified": true, "block": { "height": 0, "hash": "1a91e3da…5691", "pow": { "algo": "scrypt", "ok": true } },
#   "checks": { "txidRecomputed": true, "merkleProof": true, "blockHashRecomputed": true, "proofOfWork": true,
#               "onBestChain": true, "genesisRecordMatches": true },
#   "genesis": { "message": "Nintondo", "value": "88 DOGE", "spendable": false }, "attestation": { "fact", "signatures" }

curl -s 'https://origin.dogesoft.io/api/anchor/verify?block=1'          # by height
curl -s 'https://origin.dogesoft.io/api/anchor/verify?block=<hash>'     # or block hash; add &txids=1 for every txid
SDK
import { anchor } from 'https://origin.dogesoft.io/sdk/origin.js';

const r = await anchor.verifyTx(anchor.GENESIS.txid);
if (r.verified) console.log(r.block.height, r.genesis.message);       // 0 'Nintondo'
const b = await anchor.verifyBlock(1);
const fake = await anchor.verifyTx('de'.repeat(32));                  // { ok: false, verified: false, error: 'No Dogecoin transaction has that txid.' }

What comes back. verified is true only when every entry in checks is true. final is true at 7+ confirmations; before that you get the checks but no signature. proof has the tx’s index, merkle path (display hex, bottom-up) and the block’s txCount. Unknown txids answer 404, malformed ones 400, always with "verified": false.

On DogeOS. A final tx comes with two facts signed for the live Origin contract: TX_INCLUDED (subject txid, value 1, the same fact as /api/attest/tx-included) and L1_BLOCK (subject block hash, key tx count, value merkle root). Check either for free with Origin.verify(fact, signatures), or keep it for good with Origin.submit(fact, signatures) (you pay only gas), after which txConfirmed(txid, n) works for everyone. One L1_BLOCK fact covers every transaction in that block through its merkle path.

solidity
(bool ok, , uint64 height, ) = IGenesisAnchor(plug).verifyTx(fact, sigs);   // signed TX_INCLUDED
bool first = IGenesisAnchor(plug).isGenesisTx(rawTx);                      // genesis needs no signature at all

Genesis is special. Block 0 is built into Dogecoin Core, so the node can’t return its coinbase like a normal transaction (see the Genesis page). Origin rebuilds it from block 0’s raw bytes and matches it against the published genesis record. Origin’s contract reserves height 0, so for genesis the GenesisAnchorPlug helper hard-codes the genesis hashes and checks raw bytes with SHA-256 on chain, no signature needed.

GenesisAnchorPlug Live · testnet 0xa2B16644D978EF6f9A9aB9fcAF196e19d9aD2551 on DogeOS Chikyū (chain 6281971), wired to Origin 0xcc816160fF36891090780Aca810f637600329d5E. All of its functions are free view/pure calls (SDK: anchor.PLUG_ADDRESS, GENESIS_ANCHOR_ABI). See it on the explorer.

LimitAnonymousLicensed (signed session)
PriceFreeFree (0 DOGE overage)
Per minuteSmall allowance, per IP120 per license (and per IP)
Per UTC daySmall allowance, per IP100,000 per license

The licensed tier needs proof that you control the wallet: sign in once (License sessions) and send the token as X-Origin-Session. A bare plugId/wallet in the query is ignored and you get the anonymous tier. Inputs are strict: block is a plain height or a 64-hex hash, txids is 1 or 0, and unknown parameters answer 400.

Want the proof stamped on Dogecoin itself? That’s the paid ANCHOR verb through Origin Services, with a Soft-issued ref and the normal fees. Verifying stays free.

Guide · Licenses

License sessions: prove you hold the license

Licensed calls need proof that you control the wallet holding the license, not just its address.

Sign one plain message with the wallet (no transaction, no gas). Origin builds the message itself: it names origin.dogesoft.io, DogeOS chain 6281971, your plug, your wallet, a one-time nonce and a 5-minute expiry. Origin checks the signature (EIP-191 personal_sign; smart-contract wallets through EIP-1271), then checks OriginPlugs.hasLicense(plugId, wallet) on chain, and returns a session token bound to that wallet and plug. It lasts 30 minutes. Send it as the X-Origin-Session header.

SDK
import { session, refs, anchor, facts, metering } from 'https://origin.dogesoft.io/sdk/origin.js';

const s = await session.signIn({ wallet, plugId: 12, provider: window.ethereum });   // or signMessage: (m) => signer.signMessage(m)
await anchor.verifyTx(txid, { session: s });       // licensed limits
await facts.drc20Balance('D…', 'DU$T', { session: s });   // signed facts on your license quota
await refs.issue({ session: s, action: 'BUY' });   // single-use Soft ref for an inscription body
await metering({ session: s });                    // today’s usage for this license
if (!session.fresh(s)) { /* sign in again */ }
HTTP
GET  /api/session/challenge?wallet=0x…&plugId=12   → { nonce, message, expiresAt }
     # sign message with personal_sign
POST /api/session { "nonce": "…", "signature": "0x…" }   → { token, wallet, plugId, chainId, expiresAt }
GET  /api/session                     X-Origin-Session: <token>   → who the token belongs to
POST /api/ref { "action": "BUY" }     X-Origin-Session: <token>   → { ref, expiresInSeconds }
RuleWhat happens
Each nonce works onceIt is used up the moment it is presented, even if the signature is wrong. A replayed signature answers 401.
5 minutes to signAn expired challenge answers 401; get a new one.
Wrong wallet, plug, chain or siteThe signature must match the exact message Origin built for that wallet, plug, chain 6281971 and origin.dogesoft.io. Anything else answers 401.
No license403. Licenses are re-checked on chain while a session is in use, so a revoked license stops working shortly.
Edited or expired token401; sign in again.
No session/api/ref answers 401. /api/anchor/verify and /api/attest/<fact> answer on the anonymous tier.

Refs. A Soft-issued ref is bound to your plug, your wallet and one Origin action (BUY, GIFT, ANCHOR, …), is used once, and expires after 24 hours. A ref only works for the wallet it was issued to, so a copied ref is useless.

Guide

Built on Origin badge

Show users your Dogecoin data is verified by Origin. One line.

your-site.html
<script src="https://origin.dogesoft.io/shared/badge/origin-badge.js" defer></script>
<origin-badge plug="collection-holder-gate"></origin-badge>

Attributes: plug (links to that plug’s page on Origin Plugs), variant="mark" (logo only), theme="light", size="sm", floating (pinned bottom-right).

README.md
[![Built on Origin](https://origin.dogesoft.io/shared/badge/built-on-origin-dark.svg)](https://plugs.dogesoft.io)

Every plug page on Origin Plugs, every finished build on Origin and the Plugs studio hands you this snippet with your plug filled in.

Reference

Read API

Base: https://explorer.dogesoft.io/api. GET, public, JSON.

EndpointGives you
/healthIndexed height, chain tip, DRC-20 ledger height, staleness
/wallet/address/{addr}/balanceDOGE balance in koinu, UTXO count
/wallet/address/{addr}/utxosUTXOs and the inscriptions sitting on them
/wallet/address/{addr}/drc20Coin balances: balance, available, transferable
/wallet/address/{addr}/historyRecent confirmed activity
/tx/{txid}Confirmations, mempool flag, raw hex
/explorer/tx/{txid}Decoded DRC-20 operations and inscriptions
/explorer/drc20/{tick}Coin deploy, supply, holders
/explorer/inscriptions/{id}Owner, location, genesis, content hash, collections
/content/{id}The content, reassembled from chain (no /api prefix)
/explorer/collectionsCollections (max 200 per page, use offset)
/explorer/collections/{id}/itemsItems in a collection
Going deeper. Tickers in paths are case- and symbol-sensitive, so URL-encode them (du%24t). The decoded-tx endpoint can take several seconds on busy transactions, so cache what you can.

Reference

Origin contract Live · testnet

One entry point on DogeOS. Every method is a view, and every answer carries the L1 height it was true at.

ContractAddress on DogeOS Chikyū (6281971)
Origin0xcc816160fF36891090780Aca810f637600329d5E
OriginPlugs0x71a96204D86194FfA46b04f89eB7eB6a0B2D4290
OriginEnvelope0xdfa7fACb890C6966019BbC0EdA26508df9130592
OriginInscriber0xFd4dB41F0Dd1ac4C0EBB06FF2705A97B8e31b37b
OriginAnchor0xA52DF38e689F76c95cE5d4d596142CB0C9471577

The full, compiled interface lives in the ABI explorer (download: Origin.json, OriginPlugs.json). The calls you’ll use most:

IOrigin.sol (excerpt)
function drc20Balance(string calldata dogeAddress, string calldata tick)
    external view returns (uint256 amount, uint64 l1Height, uint64 attestedAt);
function collectionCount(string calldata dogeAddress, string calldata collectionId)
    external view returns (uint256 count, uint64 l1Height, uint64 attestedAt);
function isInscriptionOwner(string calldata inscriptionId, string calldata dogeAddress)
    external view returns (bool);
function inscriptionValid(string calldata inscriptionId)
    external view returns (bool ok, bytes32 contentHash, uint64 l1Height);
function drc20Supply(string calldata tick)
    external view returns (uint256 minted, uint256 maxSupply, uint64 l1Height);
function txConfirmed(bytes32 txid, uint256 minConfirmations)
    external view returns (bool ok, uint64 l1Height);
function drc20TransferValid(bytes32 txid) external view returns (bool ok, uint64 l1Height);
function isLinked(address account, string calldata dogeAddress) external view returns (bool);
function inscriptionHasAction(string calldata inscriptionId, string calldata action) external view returns (bool);
function inscriptionMatches(string calldata inscriptionId, bytes32 envelopeHash) external view returns (bool);
function check(bytes32 factType, bytes32 subject, bytes32 key, uint8 op, uint256 threshold, uint64 maxAge)
    external view returns (bool);
function requestFact(bytes32 factType, bytes32 subject, bytes32 key, uint256 plugId)
    external payable returns (uint256 requestId);

Fact types

FactValue
DOGE_BALANCEkoinu at outputs with more than 6 confirmations
DRC20_BALANCEamount, 18-decimal fixed point
DRC20_MINTED / DRC20_MAX_SUPPLYsupply, 18-decimal fixed point
DRC20_TRANSFER_VALID1 if the transfer settled on the ledger, else 0
COLLECTION_COUNTDoginals held from one collection
INSCRIPTION_OWNERkeccak256(bytes(ownerAddress))
INSCRIPTION_VALIDSHA-256 of the content
INSCRIPTION_ACTION / INSCRIPTION_ENVELOPEthe Inscription Standard verb / the hash of the plain Doginal
TX_INCLUDED1 once the transaction is six blocks deep
ADDRESS_LINKa DogeOS account linked to a Dogecoin address
L1_TIPlatest Dogecoin height Origin has seen (refreshed every 30 minutes)

Signed fact reads: limits

Signed facts from GET /api/attest/<fact> are metered like every other read. Without a session you get the anonymous tier, counted per IP. With a license session (X-Origin-Session) reads count against your license instead. Every answer carries a license block with usedToday, freePerDay and overQuota; GET /api/metering shows today’s usage.

LimitAnonymousLicensed (signed session)
Per minuteSmall allowance, per IP120 per license (and per IP)
Free per UTC daySmall allowance, per IP, then 4292,000 per license
After the free quotaRefused until 00:00 UTC0.005 DOGE per read (overQuota: true), up to 20,000 a day

Status reads, and reads that fail on Origin’s side, aren’t counted. A bad or expired token answers 401; it never falls back to the anonymous tier. Reading facts that are already stored on Origin (contract views on DogeOS) stays free.

Freshness

Facts are snapshots. Check attestedAt (or l1Height) against your own limit, e.g. one hour for a gate, and reject anything older.

Security model. Every fact needs M-of-N attester signatures (EIP-712, bound to the chain and contract), proves L1 confirmations and carries a signature expiry; older views can never overwrite newer ones; one fact type, or all of Origin, can be paused instantly, and bad facts quarantined. Paused or quarantined facts read as empty and fail verify(), so contracts built on Origin stop too. Every parameter, role and attester change goes through a timelock. 197 automated tests.
Going deeper. Under the hood, facts arrive as threshold-signed messages bound to the DogeOS chain id and the Origin address. You can verify one inline (pull) or relay it into storage (push). Origin is deployed directly, with no proxy, and can’t be upgraded: the address and behaviour you integrate against never change. New capabilities ship as new contracts alongside it.

Reference

Encoding rules

ThingHow Origin encodes it
Dogecoin addressPassed as string. Hashed as keccak256(bytes(addr)), case-sensitive.
TickerPassed as string, exact. Keyed by keccak256(lowercase(tick)).
Inscription idstring like <txid>i0. Keyed by keccak256(lowercase(id)).
CollectionSlug string, e.g. dustinal-dogs.
txidbytes32 = 0x + the txid as explorers display it (no byte reversal).
Amountsuint256 base units. DOGE in koinu.

Reference

Inscription standard

Every inscription under the standard is a plain Doginal. The verb rides inside the body:

{"ds":{"action":"<VERB>","ref":"<id>"}}   // ref is optional; nothing else inside ds

Origin serves marketplace and launch verbs (BUY, LAUNCH_MINT, and the rest of the licensed Origin set) through SoftInscribeBase only. Some Doge Soft actions are internal and never available through Origin. The verbs are documented on the inscription standard. An action is official only with the Doge Soft signature. The indexer, reading Dogecoin Core, is the source of truth for the orbit. DRC-20 stays its own positional protocol.

A matching verb is not enough. Without the Doge Soft signature, it is not official. Today that is the only official signature.

Reference

Answers and failures

AnswerMeans
✓ YesTrue on L1 at the stated height, under Origin’s rules.
✕ NoChecked, and not true.
… PendingNot decided yet: too few confirmations, or the DRC-20 ledger hasn’t reached that block.
Ø InfoContext, not a yes/no fact.

Origin fails closed. When data is ambiguous, missing or slow, it doesn’t guess. It says so.

Trust and roadmap

Trust model

Trust and roadmap

Origin Proof Planned

Prove something about a wallet’s Dogecoin history without showing all of it.

Examples: active for more than two years, used on 100 different days, held a Doginal from a collection since 2024, has created coins. These are activity and Sybil-resistance signals, not identity. A wallet is not a person, and Proof will never claim it is. No KYC, no names, no documents.

Trust and roadmap

OP_CHECKZKP Shadow index live

A draft Dogecoin soft fork (discussion #3869) that would let scripts verify zero-knowledge proofs.

It redefines OP_NOP10 (0xB9) as OP_CHECKZKP, with a Groth16 / BLS12-381 mode and a Halo2-KZG / BN256 mode. It isn’t activated, and Dogecoin Core hasn’t agreed to it.

Origin indexes it in shadow mode: every use is detected and parsed (mode, proof, verifying key, public inputs) and labelled not consensus-enforced. Proofs are stored but not checked yet; verification comes next. Older blocks are still being added. If it activates, the history is already there, and Origin can treat a verified proof as a native L1 fact.

Read it at explorer.dogesoft.io/api/explorer/zkp/status, /zkp/recent, /zkp/tx/:txid and /zkp/vk/:sha256. Every OP_RETURN is indexed too: /opreturn/recent?magic=ORA1, /opreturn/tx/:txid, /opreturn/sha256/:hash. Full reference: docs.dogesoft.io/explorer/zkp.

Trust and roadmap

FAQ

Do I need an API key?

No. Reads are public and rate-limited.

Does it cost anything?

Reading facts already stored on Origin (contract views) is free. Signed facts from /api/attest are free within a small per-IP allowance, or 2,000 a day per license with a signed session, then 0.005 DOGE per read on a license (limits). A fresh on-demand fact and Soft-issued refs use the license quota then a small Soft overage (defaults in /api/metering). On-chain inscription fee is 0.01 DOGE base on OriginInscriber; Soft may add assist metering. Paid plugs cost whatever their creator sets; the marketplace keeps 1%.

Is there a Dogecoin testnet?

Origin reads Dogecoin mainnet. DogeOS is on testnet (Chikyū) today.

Why does a balance show “transferable”?

Those coins are locked inside a transfer inscription that hasn’t moved yet. See DRC-20 coins.

Can Origin move coins for my users?

No. It builds the request; the user’s wallet signs it.

Something looks wrong.

Every answer links to the raw record it came from. Send that link to Origin.