Meta-Address Registry Contract

import { generateIdentityProof } from '@identipay/zk';
import { generateKeyPair } from '@identipay/crypto';
import { poseidon } from '@identipay/crypto';

// Generate keypairs for stealth addresses
const spendKeys = generateKeyPair('ed25519');
const viewKeys = generateKeyPair('x25519');

// Compute identity commitment from government ID
const commitment = poseidon([
  BigInt(credential.firstName),
  BigInt(credential.lastName),
  BigInt(credential.birthdate),
  BigInt(credential.idNumber),
]);

// Generate ZK proof of credential ownership
const { proof, publicInputs } = await generateIdentityProof({
  credential,
  commitment,
});

// Register name on-chain
const tx = new TransactionBlock();
tx.moveCall({
  target: `${PACKAGE_ID}::meta_address_registry::register_name`,
  arguments: [
    tx.object(REGISTRY_ID),
    tx.object(IDENTITY_VK_ID),
    tx.pure('alice'),
    tx.pure(Array.from(spendKeys.publicKey)),
    tx.pure(Array.from(viewKeys.publicKey)),
    tx.pure(Array.from(commitment)),
    tx.pure(proof),
    tx.pure(publicInputs),
  ],
});

const result = await wallet.signAndExecuteTransactionBlock({
  transactionBlock: tx,
});

// Save private keys securely
await secureStorage.set('spend_private_key', spendKeys.privateKey);
await secureStorage.set('view_private_key', viewKeys.privateKey);

console.log('Registered @alice.idpay');

import { generateKeyPair } from '@identipay/crypto';

// Generate fresh keypairs
const newSpendKeys = generateKeyPair('ed25519');
const newViewKeys = generateKeyPair('x25519');

// Generate ZK proof (same commitment as original registration)
const { proof, publicInputs } = await generateIdentityProof({
  credential,
  commitment: originalCommitment,
});

// Rotate keys
const tx = new TransactionBlock();
tx.moveCall({
  target: `${PACKAGE_ID}::meta_address_registry::rotate_keys`,
  arguments: [
    tx.object(REGISTRY_ID),
    tx.object(entryObjectId), // owned MetaAddressEntry
    tx.object(IDENTITY_VK_ID),
    tx.pure(Array.from(newSpendKeys.publicKey)),
    tx.pure(Array.from(newViewKeys.publicKey)),
    tx.pure(proof),
    tx.pure(publicInputs),
  ],
});

await wallet.signAndExecuteTransactionBlock({ transactionBlock: tx });

// Update stored private keys
await secureStorage.set('spend_private_key', newSpendKeys.privateKey);
await secureStorage.set('view_private_key', newViewKeys.privateKey);

import { deriveStealthAddress } from '@identipay/crypto';

// Sender resolves recipient's name
const [spendPubkey, viewPubkey] = await identiPayClient.resolveName(
  'alice'
);

// Derive one-time stealth address
const ephemeralPrivateKey = randomBytes(32);
const stealthAddress = deriveStealthAddress(
  spendPubkey,
  viewPubkey,
  ephemeralPrivateKey
);

// Compute view tag for fast scanning
const sharedSecret = deriveECDH(ephemeralPrivateKey, viewPubkey);
const viewTag = sharedSecret[0]; // first byte

// Send payment to stealthAddress and emit announcement
await sendPayment({
  recipient: stealthAddress,
  amount,
  ephemeralPubkey: derivePublicKey(ephemeralPrivateKey),
  viewTag,
});