1AM Midnight DApp Integration

Provider Setup (Dust-Free)

import { setNetworkId } from '@midnight-ntwrk/midnight-js-network-id';
import { FetchZkConfigProvider } from '@midnight-ntwrk/midnight-js-fetch-zk-config-provider';
import { indexerPublicDataProvider } from '@midnight-ntwrk/midnight-js-indexer-public-data-provider';

setNetworkId(config.networkId);

// ZK keys from your CDN
const zkConfigProvider = new FetchZkConfigProvider(
  'https://your-cdn.com/contract/compiled/your-contract',
  fetch.bind(window),
);

// On-chain state
const publicDataProvider = indexerPublicDataProvider(config.indexerUri, config.indexerWsUri);

// Proof provider — wallet routes to ProofStation native binary
const provingProvider = await api.getProvingProvider(zkConfigProvider);
const proofProvider = {
  async proveTx(unprovenTx) {
    const { CostModel } = await import('@midnight-ntwrk/ledger-v8');
    return unprovenTx.prove(provingProvider, CostModel.initialCostModel());
  },
};

// Wallet provider — ProofStation sponsors dust fees (user pays nothing)
const shieldedAddr = await api.getShieldedAddresses();
const walletProvider = {
  getCoinPublicKey: () => shieldedAddr.shieldedCoinPublicKey,
  getEncryptionPublicKey: () => shieldedAddr.shieldedEncryptionPublicKey,
  async balanceTx(tx) {
    const hex = toHex(tx.serialize());
    const result = await api.balanceUnsealedTransaction(hex);
    const { Transaction } = await import('@midnight-ntwrk/ledger-v8');
    return Transaction.deserialize('signature', 'proof', 'binding', fromHex(result.tx));
  },
};

// Submit provider
const midnightProvider = {
  async submitTx(tx) {
    await api.submitTransaction(toHex(tx.serialize()));
    return tx.identifiers()[0];
  },
};

Deploy & Call Contracts

import { deployContract, submitCallTx } from '@midnight-ntwrk/midnight-js-contracts';
import { CompiledContract } from '@midnight-ntwrk/compact-js';

const compiled = CompiledContract.make('MyContract', ContractClass).pipe(
  CompiledContract.withVacantWitnesses,
  CompiledContract.withCompiledFileAssets('./contract/compiled/my-contract'),
);

// Deploy — user pays nothing
const deployed = await deployContract(providers, { compiledContract: compiled });
const address = deployed.deployTxData.public.contractAddress;

// Call circuit — user pays nothing
const result = await submitCallTx(providers, {
  compiledContract: compiled,
  contractAddress: address,
  circuitId: 'myCircuit',
  args: [arg1, arg2],
});

Transaction Flow

1. SDK builds unproven tx from contract circuit + args
2. proofProvider.proveTx() → wallet → ProofStation /check + /prove → ZK proof (~2-5s)
3. walletProvider.balanceTx() → wallet → ProofStation /balance-only → server adds dust
4. midnightProvider.submitTx() → wallet broadcasts to chain → tx hash returned

Hex Conversion Helpers

function toHex(bytes: Uint8Array): string {
  return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
}

function fromHex(hex: string): Uint8Array {
  return new Uint8Array(hex.match(/.{2}/g)!.map(b => parseInt(b, 16)));
}

Networks

References

• DApp Connector API — full wallet API reference
• ZK Key Hosting — CDN setup for prover/verifier keys
• DApp Listing — submit your app to the 1AM registry

Example

ZKMint Night-ID at zkmint.1am.xyz — full dust-free minting. Source: midnight-launchpad/lib/midnight/night-id-contract.ts