Ownership, untethered

KEYS DECAY.OWNERSHIPENDURES.

A Solana ownership layer built to outlast the key that started it.

Begin descent See the blueprint

PROTOCOL: AFTRKEYNETWORK: SOLANA

aftrkey.engine / 01

SIMULATION ACTIVE

EVERYTHING BEGINS WITH A KEY.

SOURCE IDENTITY

SOLANA / RESEARCH PHASE

01 / THE DEPENDENCY

One key. One fracture.

Every wallet hangs on a single signature. A future quantum machine could forge it.

PRIVATE KEY

SIGNATURE

OWNERSHIP

Break the key, inherit the vault.

Illustration only

aftrkey.engine / 01

SIMULATION ACTIVE

EVERYTHING BEGINS WITH A KEY.

SOURCE IDENTITY

SOLANA / RESEARCH PHASE

02 / THE SEPARATION

Cut the cord.

Assets slip out of the wallet and into a vault no single key can open.

LEGACY AUTHORITY: DETACHED

Authority, unbound.

SEPARATION / RUNTIMEops 000000

1#[program]

2pub mod aftrkey {

3 use super::*;

5 pub fn deposit(ctx: Context<Deposit>, amount: u64, commitment: [u8; 32]) -> Result<()> {

6 let vault = &mut ctx.accounts.vault;

7 require!(amount > 0, AfterError::ZeroAmount);

8 token::transfer(ctx.accounts.into_transfer_ctx(), amount)?;

9 vault.ledger.credit(commitment, amount)?;

10 emit!(Deposited { commitment, amount });

11 Ok(())

12 }

14 pub fn settle(ctx: Context<Settle>, ix: SettleIx) -> Result<()> {

15 let id = &mut ctx.accounts.identity;

16 require!(ix.nonce > id.nonce, AfterError::Replay);

17 verify_pq(&ix.proof, &id.commitment, &ix.digest())?;

18 id.nonce = ix.nonce;

19 ctx.accounts.ledger.debit(ix.from, ix.amount)?;

20 ctx.accounts.ledger.credit(ix.to, ix.amount)?;

21 Ok(())

22 }

24 pub fn hibernate(ctx: Context<Hibernate>, proof: Proof) -> Result<()> {

25 let v = &mut ctx.accounts.vault;

26 verify_pq(&proof, &v.owner, b"HIBERNATE")?;

27 v.state = VaultState::Sealed;

28 v.exits = ExitPolicy::Closed;

29 Ok(())

30 }

31}

1#[program]

2pub mod aftrkey {

3 use super::*;

5 pub fn deposit(ctx: Context<Deposit>, amount: u64, commitment: [u8; 32]) -> Result<()> {

6 let vault = &mut ctx.accounts.vault;

7 require!(amount > 0, AfterError::ZeroAmount);

8 token::transfer(ctx.accounts.into_transfer_ctx(), amount)?;

9 vault.ledger.credit(commitment, amount)?;

10 emit!(Deposited { commitment, amount });

11 Ok(())

12 }

14 pub fn settle(ctx: Context<Settle>, ix: SettleIx) -> Result<()> {

15 let id = &mut ctx.accounts.identity;

16 require!(ix.nonce > id.nonce, AfterError::Replay);

17 verify_pq(&ix.proof, &id.commitment, &ix.digest())?;

18 id.nonce = ix.nonce;

19 ctx.accounts.ledger.debit(ix.from, ix.amount)?;

20 ctx.accounts.ledger.credit(ix.to, ix.amount)?;

21 Ok(())

22 }

24 pub fn hibernate(ctx: Context<Hibernate>, proof: Proof) -> Result<()> {

25 let v = &mut ctx.accounts.vault;

26 verify_pq(&proof, &v.owner, b"HIBERNATE")?;

27 v.state = VaultState::Sealed;

28 v.exits = ExitPolicy::Closed;

29 Ok(())

30 }

31}

1const secret = crypto.getRandomValues(new Uint8Array(32));

2const salt = crypto.getRandomValues(new Uint8Array(16));

3const commitment = await sha256(concat(secret, salt));

5const leaves = merkle.build(oneTimeKeys(secret, 1024));

6const root = leaves.root();

8async function authorize(action: Action, nonce: bigint) {

9 const digest = domain("AFTRKEY/v0", action, nonce);

10 const sig = wots.sign(nextLeaf(secret), digest);

11 return { root, sig, path: leaves.path(sig.index) };

12}

14const ix = await program.methods

15 .settle({ from: ghostA, to: ghostB, amount, nonce })

16 .accounts({ ledger, identity })

17 .instruction();

19assert(ix.data.length < 1232, "tx size budget");

20console.log("SIMULATED", digest.hex());

1const secret = crypto.getRandomValues(new Uint8Array(32));

2const salt = crypto.getRandomValues(new Uint8Array(16));

3const commitment = await sha256(concat(secret, salt));

5const leaves = merkle.build(oneTimeKeys(secret, 1024));

6const root = leaves.root();

8async function authorize(action: Action, nonce: bigint) {

9 const digest = domain("AFTRKEY/v0", action, nonce);

10 const sig = wots.sign(nextLeaf(secret), digest);

11 return { root, sig, path: leaves.path(sig.index) };

12}

14const ix = await program.methods

15 .settle({ from: ghostA, to: ghostB, amount, nonce })

16 .accounts({ ledger, identity })

17 .instruction();

19assert(ix.data.length < 1232, "tx size budget");

20console.log("SIMULATED", digest.hex());

1vault_pda = find_program_address(["vault", mint])

2owner = program_id // no private key

3wallet = detached

5for leaf in winternitz_chain(secret):

6 pk[i] = hash^w(leaf)

7root = merkle(pk)

9on settle(from, to, amt, proof):

10 assert proof.root == registry[from]

11 assert nonce[from] < proof.nonce

12 ledger[from] -= amt

13 ledger[to] += amt

15on hibernate(proof):

16 exits = closed

17 override = none

19on migrate(dest, proof):

20 assert dest.scheme == "post_quantum"

21 status = planned

1vault_pda = find_program_address(["vault", mint])

2owner = program_id // no private key

3wallet = detached

5for leaf in winternitz_chain(secret):

6 pk[i] = hash^w(leaf)

7root = merkle(pk)

9on settle(from, to, amt, proof):

10 assert proof.root == registry[from]

11 assert nonce[from] < proof.nonce

12 ledger[from] -= amt

13 ledger[to] += amt

15on hibernate(proof):

16 exits = closed

17 override = none

19on migrate(dest, proof):

20 assert dest.scheme == "post_quantum"

21 status = planned

rust · typescript · pseudocodeillustrative, not deployed

aftrkey.engine / 01

SIMULATION ACTIVE

EVERYTHING BEGINS WITH A KEY.

SOURCE IDENTITY

SOLANA / RESEARCH PHASE

03 / IDENTITY AFTER KEYS

Become a ghost.

A quiet credential, untied from any wallet, that proves it is you.

IDENTITY: GHOST-0001
COMMITMENT: 0x1AAF...6CD9
STATUS: SIMULATED
OWNER SECRET: LOCAL DEMO ONLY

Not an account. A proof only you can summon.

Visual only. Nothing is stored.

aftrkey.engine / 01

SIMULATION ACTIVE

EVERYTHING BEGINS WITH A KEY.

SOURCE IDENTITY

SOLANA / RESEARCH PHASE

04 / THE AFTERWORLD

A hidden lattice.

Value drifts between ghosts without waking the old wallets.

Ghost network / simulation

› SYSTEM READY. SELECT TWO IDENTITIES.

identity active identity asset in transit

Tap two nodes to send a phantom transfer.

aftrkey.engine / 01

SIMULATION ACTIVE

EVERYTHING BEGINS WITH A KEY.

SOURCE IDENTITY

SOLANA / RESEARCH PHASE

05 / PRESERVATION STATE

Put it to sleep.

Seal every exit until you, and only you, wake it.

HIBERNATION = DISABLED

EXTERNAL PATHWAYS = OPEN WITH PROOF

OWNER AUTHORIZATION = REQUIRED

ADMINISTRATIVE OVERRIDE = NONE

No admin. No override. Just you.

Concept. Not yet built or audited.

aftrkey.engine / 01

SIMULATION ACTIVE

EVERYTHING BEGINS WITH A KEY.

SOURCE IDENTITY

SOLANA / RESEARCH PHASE

06 / PROTOCOL ARCHITECTURE

Six layers, one idea.

AFTRKEY / UNDER THE HOODops 000000

1#[program]

2pub mod aftrkey {

3 use super::*;

5 pub fn deposit(ctx: Context<Deposit>, amount: u64, commitment: [u8; 32]) -> Result<()> {

6 let vault = &mut ctx.accounts.vault;

7 require!(amount > 0, AfterError::ZeroAmount);

8 token::transfer(ctx.accounts.into_transfer_ctx(), amount)?;

9 vault.ledger.credit(commitment, amount)?;

10 emit!(Deposited { commitment, amount });

11 Ok(())

12 }

14 pub fn settle(ctx: Context<Settle>, ix: SettleIx) -> Result<()> {

15 let id = &mut ctx.accounts.identity;

16 require!(ix.nonce > id.nonce, AfterError::Replay);

17 verify_pq(&ix.proof, &id.commitment, &ix.digest())?;

18 id.nonce = ix.nonce;

19 ctx.accounts.ledger.debit(ix.from, ix.amount)?;

20 ctx.accounts.ledger.credit(ix.to, ix.amount)?;

21 Ok(())

22 }

24 pub fn hibernate(ctx: Context<Hibernate>, proof: Proof) -> Result<()> {

25 let v = &mut ctx.accounts.vault;

26 verify_pq(&proof, &v.owner, b"HIBERNATE")?;

27 v.state = VaultState::Sealed;

28 v.exits = ExitPolicy::Closed;

29 Ok(())

30 }

31}

1#[program]

2pub mod aftrkey {

3 use super::*;

5 pub fn deposit(ctx: Context<Deposit>, amount: u64, commitment: [u8; 32]) -> Result<()> {

6 let vault = &mut ctx.accounts.vault;

7 require!(amount > 0, AfterError::ZeroAmount);

8 token::transfer(ctx.accounts.into_transfer_ctx(), amount)?;

9 vault.ledger.credit(commitment, amount)?;

10 emit!(Deposited { commitment, amount });

11 Ok(())

12 }

14 pub fn settle(ctx: Context<Settle>, ix: SettleIx) -> Result<()> {

15 let id = &mut ctx.accounts.identity;

16 require!(ix.nonce > id.nonce, AfterError::Replay);

17 verify_pq(&ix.proof, &id.commitment, &ix.digest())?;

18 id.nonce = ix.nonce;

19 ctx.accounts.ledger.debit(ix.from, ix.amount)?;

20 ctx.accounts.ledger.credit(ix.to, ix.amount)?;

21 Ok(())

22 }

24 pub fn hibernate(ctx: Context<Hibernate>, proof: Proof) -> Result<()> {

25 let v = &mut ctx.accounts.vault;

26 verify_pq(&proof, &v.owner, b"HIBERNATE")?;

27 v.state = VaultState::Sealed;

28 v.exits = ExitPolicy::Closed;

29 Ok(())

30 }

31}

1const secret = crypto.getRandomValues(new Uint8Array(32));

2const salt = crypto.getRandomValues(new Uint8Array(16));

3const commitment = await sha256(concat(secret, salt));

5const leaves = merkle.build(oneTimeKeys(secret, 1024));

6const root = leaves.root();

8async function authorize(action: Action, nonce: bigint) {

9 const digest = domain("AFTRKEY/v0", action, nonce);

10 const sig = wots.sign(nextLeaf(secret), digest);

11 return { root, sig, path: leaves.path(sig.index) };

12}

14const ix = await program.methods

15 .settle({ from: ghostA, to: ghostB, amount, nonce })

16 .accounts({ ledger, identity })

17 .instruction();

19assert(ix.data.length < 1232, "tx size budget");

20console.log("SIMULATED", digest.hex());

1const secret = crypto.getRandomValues(new Uint8Array(32));

2const salt = crypto.getRandomValues(new Uint8Array(16));

3const commitment = await sha256(concat(secret, salt));

5const leaves = merkle.build(oneTimeKeys(secret, 1024));

6const root = leaves.root();

8async function authorize(action: Action, nonce: bigint) {

9 const digest = domain("AFTRKEY/v0", action, nonce);

10 const sig = wots.sign(nextLeaf(secret), digest);

11 return { root, sig, path: leaves.path(sig.index) };

12}

14const ix = await program.methods

15 .settle({ from: ghostA, to: ghostB, amount, nonce })

16 .accounts({ ledger, identity })

17 .instruction();

19assert(ix.data.length < 1232, "tx size budget");

20console.log("SIMULATED", digest.hex());

1vault_pda = find_program_address(["vault", mint])

2owner = program_id // no private key

3wallet = detached

5for leaf in winternitz_chain(secret):

6 pk[i] = hash^w(leaf)

7root = merkle(pk)

9on settle(from, to, amt, proof):

10 assert proof.root == registry[from]

11 assert nonce[from] < proof.nonce

12 ledger[from] -= amt

13 ledger[to] += amt

15on hibernate(proof):

16 exits = closed

17 override = none

19on migrate(dest, proof):

20 assert dest.scheme == "post_quantum"

21 status = planned

1vault_pda = find_program_address(["vault", mint])

2owner = program_id // no private key

3wallet = detached

5for leaf in winternitz_chain(secret):

6 pk[i] = hash^w(leaf)

7root = merkle(pk)

9on settle(from, to, amt, proof):

10 assert proof.root == registry[from]

11 assert nonce[from] < proof.nonce

12 ledger[from] -= amt

13 ledger[to] += amt

15on hibernate(proof):

16 exits = closed

17 override = none

19on migrate(dest, proof):

20 assert dest.scheme == "post_quantum"

21 status = planned

rust · typescript · pseudocodeillustrative, not deployed

Connects conventional Solana assets with program-controlled custody.

Separates token custody from ordinary externally controlled wallet keys using Solana program accounts.

Records cryptographic commitments associated with independent authorization identities.

Validates authorized actions under a proposed post-quantum security model.

Manages ownership changes and internal balance accounting.

Explores authorization-controlled exits into future compatible wallet infrastructure.

aftrkey.engine / 01

SIMULATION ACTIVE

EVERYTHING BEGINS WITH A KEY.

SOURCE IDENTITY

SOLANA / RESEARCH PHASE

07 / THE NETWORK TOKEN

Fuel for the lattice.

$KEY opens tools. It never holds your assets hostage.

IDENTITY CAPACITY

Access additional Ghost Identity features.

PRESERVATION TOOLS

Access advanced security and migration planning interfaces.

NETWORK GOVERNANCE

Participate in decisions concerning the non-custodial ecosystem.

TOKEN$KEY

NETWORKSOLANA

Your assets never depend on holding $KEY. No price promises.

aftrkey.engine / 01

SIMULATION ACTIVE

EVERYTHING BEGINS WITH A KEY.

SOURCE IDENTITY

SOLANA / RESEARCH PHASE

08 / THE QUANTUM EXODUS

Someday, we leave the keys behind.

AFTRKEY maps the way out.

Phase 00

CONVENTIONAL OWNERSHIP

Phase 01

QUANTUM THREAT MODEL

Phase 02

AUTHORITY SEPARATION

Phase 03

INDEPENDENT IDENTITIES

Phase 04

INTERNAL OWNERSHIP NETWORK

Phase 05

POST-QUANTUM MIGRATION

Proposed future capability

Open the sandbox Read the documentation

aftrkey.engine / 01

SIMULATION ACTIVE

EVERYTHING BEGINS WITH A KEY.

SOURCE IDENTITY

SOLANA / RESEARCH PHASE