Bankeiz is one implementation.
Yours can be another.

THE APPLICATION CHANGES.
THE ORIGINAL KEEPS ITS HISTORY.

Follow $1,000 across three different applications. Each supported transition preserves the original lineage and assigns the transferred portion to the recipient.

$1,000 total · counted once 10.000000 Φ · exact illustrative position

A PAYMENT PROVIDER
IS NOT THE MONEY.

Compare the same commercial stages. Conventional providers support genuine settlement and financial ownership. The distinction here is how another application receives and establishes the evidence.

YOU CAN COPY THE NUMBER.
YOU CAN’T COPY THE AUTHORITY.

Two real synthetic fixtures. The same $2 display. One carries the expected scoped delivery authority; the other deliberately carries a mismatched authority binding.

The genuine v129 read-only reader loads only when you choose Verify both.

NOT EVEN BANKEIZ
GETS AN EXCEPTION.

November 2–4, 2026: Create an Asset had to carry the same Original through creation, signing, publication and complete public presentation.

YOUR CODE.
YOUR INTERFACE.
YOUR INSTITUTION.

Start with the actual v129 contracts and examples. Your implementation supplies admitted sources, exact consent, qualified custody and the atomic host boundary.

1. 01Choose the capability and rail
2. 02Open the complete Original
3. 03Verify source and pinned trust
4. 04Establish current authority
5. 05Check receiving and custody
6. 06Execute the authorized transition
7. 07Keep exact recovery
8. 08Reverify the result
9. 09Support the next legitimate transfer

import type {ReceizClient} from '@receiz/sdk';

type Edge=ReceizClient['value']['edge'];
type AdmittedInput=Parameters<Edge['planReserve']>[0];
type CommittedRecoveryInput=Parameters<Edge['createRecovery']>[0];

// The host supplies admitted sources and binds the exact amount, rail,
// participant heads, application and consent. A plan is not a payment.
export async function inspectBothReceivers(edge:Edge,input:AdmittedInput){
 const wrapper=await edge.planReserve(input);
 await edge.inspect(wrapper.plan,{
  participantId:wrapper.sourceParticipantId,expectedRail:'reserve',
 });
 await edge.inspect(wrapper.plan,{
  participantId:wrapper.destinationParticipantId,expectedRail:'reserve',
 });
 return wrapper;
}

export async function prepareExactTransition(edge:Edge,set:unknown,applicationId:string){
 const verified=await edge.verifyTransitionSet(set,{audience:applicationId});
 return edge.prepareCommitSet(verified);
}

// Between preparation and recovery, the qualified host store must atomically
// commit ALL participants or NONE and retain real SDK-issued custody.
// No generic SQL callback or caller-created object can replace that boundary.
export async function receiveActuallyCommittedValue(
 edge:Edge,committed:CommittedRecoveryInput,senderParticipantId:string,receiverParticipantId:string,
){
 const recovery=await edge.createRecovery(committed);
 // The host must durably retain this exact recovery before confirmation.
 // These fragments expose SDK boundaries, not a complete host adapter.
 await edge.confirmReserveSend(recovery,{
  applicationId:committed.applicationId,
  participantId:senderParticipantId,
 });
 return edge.receiveReserve(recovery,{
  applicationId:committed.applicationId,participantId:receiverParticipantId,
 });
}

git clone https://github.com/kojibai/reality-grade-banking.git
cd reality-grade-banking
npm ci
npm run receiver:check
npm run receiver:inspect -- /absolute/path/to/original-note.png
npm run conformance:contracts
npm run dev

Not a failure. Not a production approval.

What is assessed?

Receiver + capability + rail + build + environment

What counts?

Independent, applicable technical evidence

What does not?

Branding, a copied balance or a self-declared badge

THE NETWORK DOESN’T
NEED ONE OWNER.

Different institutions, applications and storage. Every receiver establishes the evidence for its own legitimate transition. Bankeiz is one participant.

Bankeiz must establish source, current authority and the accepted transition. It does not approve every later transfer by another implementation.

Receive. Pay. Continue.

Illustrative continuation · no production transactions are asserted.

Fiat funding uses
its actual supported rail.

Funding, reserve admission and any external settlement depend on the route’s real contracts and financial infrastructure.

Proof-native circulation
preserves its source.

An admitted Original can continue through legitimate transitions between conforming receivers. Another fiat funding event is not invented for every onward payment.

THE REQUIREMENTS ARE PUBLISHED.
THE IMPLEMENTATION IS OPEN.

Receiz supplies proof infrastructure. The financial Original carries its evidence. Independent implementations establish the receiving and execution requirements.

BUILD YOUR OWN.
THE PROOF STILL HAS TO HOLD.

You don’t have to become Bankeiz or operate on our application servers. Build your bank, wallet or merchant application. Receive the Original. Establish authority. Execute the legitimate transition. Carry its proof forward.