Developer Integration Guide

1function detectWallet(): Promise<InitialAPI | null> {
2  return new Promise((resolve) => {
3    const wallet = window.midnight?.['1am'];
4    if (wallet) { resolve(wallet); return; }
5
6    let attempts = 0;
7    const interval = setInterval(() => {
8      const w = window.midnight?.['1am'];
9      if (w) { clearInterval(interval); resolve(w); }
10      else if (++attempts > 50) { clearInterval(interval); resolve(null); }
11    }, 100);
12  });
13}

1const wallet = await detectWallet();
2if (!wallet) throw new Error('1AM wallet not installed');
3
4const connectedAPI = await wallet.connect('preview');

1const { shieldedAddress } = await connectedAPI.getShieldedAddresses();
2const { unshieldedAddress } = await connectedAPI.getUnshieldedAddress();
3const { dustAddress } = await connectedAPI.getDustAddress();
4
5const shieldedBalances = await connectedAPI.getShieldedBalances();
6const unshieldedBalances = await connectedAPI.getUnshieldedBalances();
7const { balance, cap } = await connectedAPI.getDustBalance();

1const config = await connectedAPI.getConfiguration();
2// {
3//   networkId: 'preview',
4//   indexerUri: 'https://indexer.preview.midnight.network/api/v4/graphql',
5//   indexerWsUri: 'wss://indexer.preview.midnight.network/api/v4/graphql/ws',
6//   proverServerUri: 'https://api-preview.1am.xyz',
7//   substrateNodeUri: 'wss://rpc.preview.midnight.network',
8// }

1npm install @midnight-ntwrk/compact-js \
2  @midnight-ntwrk/midnight-js-contracts \
3  @midnight-ntwrk/midnight-js-types \
4  @midnight-ntwrk/midnight-js-fetch-zk-config-provider \
5  @midnight-ntwrk/midnight-js-indexer-public-data-provider \
6  @midnight-ntwrk/midnight-js-network-id \
7  @midnight-ntwrk/ledger-v8

1import { setNetworkId } from '@midnight-ntwrk/midnight-js-network-id';
2import { FetchZkConfigProvider } from '@midnight-ntwrk/midnight-js-fetch-zk-config-provider';
3import { indexerPublicDataProvider } from '@midnight-ntwrk/midnight-js-indexer-public-data-provider';
4
5async function buildProviders(connectedAPI) {
6  const config = await connectedAPI.getConfiguration();
7  setNetworkId(config.networkId);
8
9  const zkConfigProvider = new FetchZkConfigProvider(
10    'https://your-app.com/contract/compiled/your-contract',
11    fetch.bind(window),
12  );
13
14  const publicDataProvider = indexerPublicDataProvider(
15    config.indexerUri, config.indexerWsUri,
16  );
17
18  const provingProvider = await connectedAPI.getProvingProvider(zkConfigProvider);
19  const proofProvider = {
20    async proveTx(unprovenTx) {
21      const { CostModel } = await import('@midnight-ntwrk/ledger-v8');
22      return unprovenTx.prove(provingProvider, CostModel.initialCostModel());
23    },
24  };
25
26  const shieldedAddress = await connectedAPI.getShieldedAddresses();
27  const walletProvider = {
28    getCoinPublicKey: () => shieldedAddress.shieldedCoinPublicKey,
29    getEncryptionPublicKey: () => shieldedAddress.shieldedEncryptionPublicKey,
30    async balanceTx(tx) {
31      const serialized = tx.serialize();
32      const hex = Array.from(serialized).map(b => b.toString(16).padStart(2, '0')).join('');
33      const result = await connectedAPI.balanceUnsealedTransaction(hex);
34      const { Transaction } = await import('@midnight-ntwrk/ledger-v8');
35      const bytes = new Uint8Array(result.tx.match(/.{2}/g).map(b => parseInt(b, 16)));
36      return Transaction.deserialize('signature', 'proof', 'binding', bytes);
37    },
38  };
39
40  const midnightProvider = {
41    async submitTx(tx) {
42      const serialized = tx.serialize();
43      const hex = Array.from(serialized).map(b => b.toString(16).padStart(2, '0')).join('');
44      await connectedAPI.submitTransaction(hex);
45      return tx.identifiers()[0];
46    },
47  };
48
49  return { publicDataProvider, zkConfigProvider, proofProvider, walletProvider, midnightProvider };
50}

1import { CompiledContract } from '@midnight-ntwrk/compact-js';
2import { deployContract } from '@midnight-ntwrk/midnight-js-contracts';
3import { Contract } from './your-compiled-contract';
4
5const compiledContract = CompiledContract.make('YourContract', Contract).pipe(
6  CompiledContract.withVacantWitnesses,
7  CompiledContract.withCompiledFileAssets('./contract/compiled/your-contract'),
8);
9
10const providers = await buildProviders(connectedAPI);
11const deployed = await deployContract(providers, { compiledContract });
12console.log('Contract address:', deployed.deployTxData.public.contractAddress);

1import { submitCallTx } from '@midnight-ntwrk/midnight-js-contracts';
2
3const result = await submitCallTx(providers, {
4  compiledContract,
5  contractAddress: '09dbe05f...',
6  circuitId: 'register',
7  args: [nameHash, 1n],
8});
9
10console.log('Tx hash:', result.public.txHash);

1your-cdn.com/contract/compiled/your-contract/
2  keys/
3    circuitName.prover      (2-10 MB each)
4    circuitName.verifier    (2 KB each)
5  zkir/
6    circuitName.bzkir       (1-3 KB each)

1Your DApp → 1AM Wallet → ProofStation
2                            ↓
3                  1. Proves ZK circuits (native binary, ~2-5s)
4                  2. Adds dust fees (server wallet pool)
5                  3. Returns finalized transaction
6                            ↓
7          1AM Wallet submits to Midnight chain
8
9Total user cost: 0 NIGHT, 0 dust.

1{
2  "name": "Your DApp",
3  "description": "Short description",
4  "logo": "https://your-app.com/logo.svg",
5  "link": "https://your-app.com",
6  "chains": ["midnight"],
7  "categories": ["defi", "games", "collectibles", "social", "other"]
8}

1npx midnight-agent-skills init