@kuiralabs/midnight-account-chain 0.1.0 → 0.2.0

package/dist/cli/owner.d.ts

@@ -1,3 +1,3 @@
-import { type Session } from '../src/session.ts';
+import type { Session } from '../src/session.ts';
 export type Out = (text: string) => void;
-export declare const runOwner: (argv: readonly string[], open?: () => Promise<Session>, out?: Out) => Promise<number>;
+export declare const runOwner: (argv: readonly string[], open: () => Promise<Session>, out?: Out) => Promise<number>;

package/dist/cli/owner.js

@@ -18,7 +18,6 @@
 import { randomBytes } from 'node:crypto';
 import { grantRequestFromLink, hexOf, sealedResponseLink } from '@kuiralabs/midnight-account';
 import { DEFAULT_LIMITS, exhaustedGrants, issueReadGrant, listRoster, revokeEveryGrant, revokeReadGrant, revokeReadGrants, termsFor } from "../src/issuance.js";
-import { openSession } from "../src/session.js";
 const EXIT_OK = 0;
 const EXIT_FAILED = 1;
 const EXIT_USAGE = 2;
@@ -216,7 +215,7 @@ const COMMANDS = {
 };
 // Runs one command and returns its exit code. The session is opened only
 // once the command line is known to be well formed, and always closed.
-export const runOwner = async (argv, open = openSession, out = console.log) => {
+export const runOwner = async (argv, open, out = console.log) => {
     let flags;
     try {
         flags = parse(argv);
@@ -255,5 +254,7 @@ export const runOwner = async (argv, open = openSession, out = console.log) => {
         await session?.close();
     }
 };
+// Run as a command, the genesis wallet pays: its module is loaded only then, so
+// the driver, which brings its own wallet, never loads testkit-js.
 if (import.meta.main)
-    process.exitCode = await runOwner(process.argv.slice(2));
+    process.exitCode = await runOwner(process.argv.slice(2), (await import("../src/seedWallets.js")).openSession);

package/dist/driver.d.ts

@@ -1,7 +1,7 @@
 import type { Arm } from '@kuiralabs/midnight-account';
 import { type Out } from './cli/owner.ts';
 import { type FeeWallet } from './src/providers.ts';
-export declare const DRIVER_VERSION = 3;
+export declare const DRIVER_VERSION = 4;
 export declare const accountOnRecord: () => {
     readonly address: string;
     readonly arm: Arm;

package/dist/driver.js

@@ -8,9 +8,12 @@
 //   MIDNIGHT_ACCOUNT_NODE_URL          the node, http(s)
 //   MIDNIGHT_ACCOUNT_INDEXER_URL       the indexer's GraphQL endpoint, http(s)
 //   MIDNIGHT_ACCOUNT_PROOF_SERVER_URL  the proof server, http(s)
-//   MIDNIGHT_ACCOUNT_ARTEFACTS_DIR     the proving artefacts, as compactc lays them out; this
-//                                      package's build carries none, so it is required when
-//                                      running from the published package (src/profile.ts)
+//   MIDNIGHT_ACCOUNT_ARTEFACTS_DIR     a directory to cache the proving artefacts in, each
+//                                      fetched as it is first needed and checked against this
+//                                      package's manifest; required when running from the
+//                                      published package, which carries none (src/artefacts.ts)
+//   MIDNIGHT_ACCOUNT_ARTEFACTS_SOURCE  optional: where they are fetched from, this build's
+//                                      release by default
 // and runs with the working directory where the private-state stores should
 // live (they are LevelDB directories under it).
 import { existsSync, renameSync, statSync } from 'node:fs';
@@ -23,7 +26,7 @@ import { OWNER_PATHS, stateFile } from "./src/profile.js";
 import { accountProviders } from "./src/providers.js";
 import { OWNER_RECORD, openSessionOver, readOwner } from "./src/session.js";
 // Bumped when what this module offers or expects changes in a way a caller must know.
-export const DRIVER_VERSION = 3;
+export const DRIVER_VERSION = 4;
 // A margin over the deploy transaction's validity before a deploy that has
 // not landed is taken as one that never will.
 const UNLANDED_MARGIN_MS = 5 * 60 * 1000;

package/dist/scripts/completeDeploy.js

@@ -6,7 +6,6 @@
 // resumes where it stopped.
 import { readFileSync } from 'node:fs';
 import { findDeployedContract } from '@midnight-ntwrk/midnight-js-contracts';
-import { MidnightWalletProvider, createDefaultTestLogger } from '@midnight-ntwrk/testkit-js';
 import { ACCOUNT_CIRCUITS, compiledAccount } from "../src/account.js";
 import { GENESIS_SEED, LOCALNET } from "../src/localnet.js";
 import { insertMissingVerifierKeys } from "../src/maintenance.js";
@@ -26,7 +25,9 @@ export const completeDeploy = async (providers, address) => {
         throw new Error('the maintenance authority was not retired');
     console.log(`all ${ACCOUNT_CIRCUITS.length} verifier keys on chain match the build; the maintenance authority is retired (counter ${authority.counter})`);
 };
+// Run as a script, the genesis wallet pays; testkit-js is loaded only then.
 if (import.meta.main) {
+    const { MidnightWalletProvider, createDefaultTestLogger } = await import('@midnight-ntwrk/testkit-js');
     const owner = JSON.parse(readFileSync(stateFile('owner.json'), 'utf8'));
     const wallet = await MidnightWalletProvider.build(createDefaultTestLogger(), LOCALNET, GENESIS_SEED);
     await wallet.start(true);

package/dist/scripts/deploy.js

@@ -28,7 +28,6 @@ import { getNetworkId } from '@midnight-ntwrk/midnight-js-network-id';
 import { sampleSigningKey } from '@midnight-ntwrk/midnight-js-protocol/compact-runtime';
 import { ContractDeploy, ContractState, Intent, Transaction } from '@midnight-ntwrk/midnight-js-protocol/ledger';
 import { SucceedEntirely } from '@midnight-ntwrk/midnight-js-types';
-import { MidnightWalletProvider, createDefaultTestLogger } from '@midnight-ntwrk/testkit-js';
 import { ARMS, accountEncryptionKeyPair, bootCommitmentPreimage, fromHex, hexOf, k1PublicKey, k1SecretKey, sha256, v1PublicKey, v1SecretKey } from '@kuiralabs/midnight-account';
 import { EMPTY_PRIVATE_STATE, compiledAccount } from "../src/account.js";
 import { GENESIS_SEED, LOCALNET } from "../src/localnet.js";
@@ -118,7 +117,10 @@ export const deployAccount = async (providers, arm, device = freshDevice(arm)) =
     await completeDeploy(providers, address);
     return address;
 };
+// Run as a script, the genesis wallet pays. testkit-js is loaded only then, so
+// the driver, which imports deployAccount with its own wallet, never loads it.
 if (import.meta.main) {
+    const { MidnightWalletProvider, createDefaultTestLogger } = await import('@midnight-ntwrk/testkit-js');
     const armArgument = process.argv[2] ?? 'v1';
     const arm = ARMS.find((candidate) => candidate === armArgument);
     if (arm === undefined)

package/dist/src/agent.d.ts

@@ -2,7 +2,7 @@ import { type Arm, type Bytes32, type GrantRequest, type SealedResponse, type Pa
 import { type VersionedFinalizedTransaction } from '@midnight-ntwrk/midnight-js-types';
 import { type DiscoveredCoin } from './coins.ts';
 import { type UnprovenCall } from './compose.ts';
-import { type Connection, type ShieldedAddress } from './connect.ts';
+import type { Connection, ShieldedAddress } from './connect.ts';
 import { type Grantee } from './grantee.ts';
 import { type FeeWallet } from './providers.ts';
 export declare const AGENT_VAULT: URL;
@@ -25,35 +25,6 @@ export type AgentOptions = {
     readonly mailboxOnly?: boolean;
 };
 export declare const agentAccount: () => string;
-export declare const openAgent: (slot: number, options?: AgentOptions) => Promise<{
-    grantee: Grantee;
-    grantId: Bytes32;
-    payContract: (coin: DiscoveredCoin, payee: string, amount: bigint) => Promise<{
-        finalized: import("@midnight-ntwrk/midnight-js-types").FinalizedTxData;
-        sent: SealedCoin;
-        change: SealedCoin | undefined;
-    }>;
-    unprovenContractSpend: (coin: DiscoveredCoin, payee: Bytes32, amount: bigint) => Promise<UnprovenCall & {
-        readonly change: SealedCoin | undefined;
-    }>;
-    scope: import("@kuiralabs/midnight-account").GrantScope;
-    source: () => "mailbox" | "response file";
-    spent: () => bigint;
-    readCoins: () => Promise<readonly DiscoveredCoin[]>;
-    spendShielded: (coin: DiscoveredCoin, merchant: ShieldedAddress, amount: bigint) => Promise<{
-        result: import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "withdraw_shielded_with_grant_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "withdraw_shielded_with_grant_k256">;
-        change: SealedCoin | undefined;
-    }>;
-    proveShieldedSpend: (coin: DiscoveredCoin, merchant: ShieldedAddress, amount: bigint) => Promise<ProvedSpend>;
-    submitProved: ({ tx, amount }: ProvedSpend) => Promise<import("@midnight-ntwrk/midnight-js-types").VersionedFinalizedTxData>;
-    address: string;
-    providers: import("./providers.ts").AccountProviders;
-    account: import("@midnight-ntwrk/midnight-js-contracts").FoundContract<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>>;
-    self: Bytes32;
-    readLedger: () => Promise<import("../managed/Account/contract/index.js").Ledger>;
-    close: () => Promise<void>;
-    wallet: FeeWallet;
-}>;
 export declare const openAgentOver: (connection: Connection & {
     readonly wallet: FeeWallet;
 }, slot: number, { mailboxOnly }?: AgentOptions) => Promise<{

package/dist/src/agent.js

@@ -14,10 +14,8 @@ import { compiledAccount } from "./account.js";
 import { grantFromMessages, readMailbox } from "./mailbox.js";
 import { changeCoinOf, readAccountZswap, sentCoinOf, walkInbox } from "./coins.js";
 import { payeeProviders, submitComposed, withClaim } from "./compose.js";
-import { connect } from "./connect.js";
 import { freshGrantee, granteeFromVault } from "./grantee.js";
-import { AGENT_FEE_SEED } from "./localnet.js";
-import { AGENT_PATHS, PAYEE_PATHS, ensureStateDir, stateFile } from "./profile.js";
+import { PAYEE_PATHS, ensureStateDir, stateFile } from "./profile.js";
 import { PRIVATE_STATE_ID } from "./providers.js";
 export const AGENT_VAULT = stateFile('agent.json');
 export const GRANT_REQUEST = stateFile('grant-request.json');
@@ -67,8 +65,6 @@ export const requestGrant = (account, clientId, slot, payTo, payToKind, arm) =>
 };
 // The account the agent's vault names, which its connection must be to.
 export const agentAccount = () => readVault().account;
-// The agent's session over its own fee wallet.
-export const openAgent = async (slot, options = {}) => openAgentOver(await connect(agentAccount(), AGENT_FEE_SEED, AGENT_PATHS), slot, options);
 // The agent's session over a connection the caller made to the vault's
 // account, with the wallet that pays its fees: the grantee key, the read
 // secret and the running spend are the vault's, whoever pays.

package/dist/src/artefacts.d.ts

@@ -0,0 +1,13 @@
+import { ZKConfigProvider } from '@midnight-ntwrk/midnight-js-types';
+export declare const ACCOUNT_BUILD_ID: string;
+export declare const BUILD_RELEASE: string;
+export type ArtefactCache = {
+    readonly directory: string;
+    readonly ensure: (circuits: readonly string[]) => Promise<void>;
+    readonly provider: <K extends string>() => ZKConfigProvider<K>;
+};
+export type ArtefactCacheOptions = {
+    readonly source?: string;
+    readonly stallMs?: number;
+};
+export declare const artefactCache: (root: string, { source, stallMs }?: ArtefactCacheOptions) => ArtefactCache;

package/dist/src/artefacts.js

@@ -0,0 +1,257 @@
+// The account's proving artefacts for a client of this package, which ships
+// none (a proving key is up to a quarter of a gigabyte): fetched one circuit's
+// file at a time, when midnight-js first asks for it, into a cache kept per
+// build, and kept only when it matches this package's manifest.
+//
+// The trust chain: the manifest this package carries (compactc's, beside the
+// compiled contract) lists a SHA-256 and a size for every key and ZKIR file. A
+// fetched file is kept only if it matches, so a key is as trusted as this
+// package, wherever it came from. The cache is laid out as compactc's output,
+// manifest included, so midnight-js's own provider checks every file again as
+// it reads it. A wrong proving key could not spend anything anyway: the node
+// verifies every proof against the verifier key the account holds on chain.
+//
+// Where from: the build's release in kuiralabs/midnight-account-artifacts by
+// default, or a source the caller names:
+// - an http(s) URL laid out as a release, every file under its own name
+//   (<source>/<circuit>.prover, .verifier, .bzkir). Its query string is kept
+//   for every file, so a URL signed for the whole prefix works; one signed for
+//   a single object cannot.
+// - an absolute directory (or file: URL) laid out as compactc's output
+//   (<source>/keys/<circuit>.prover, ...), as a local build of the contract is.
+import { createHash, randomBytes } from 'node:crypto';
+import { createReadStream, createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { copyFile } from 'node:fs/promises';
+import { dirname, isAbsolute, join } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { fileURLToPath } from 'node:url';
+import { NodeZkConfigProvider } from '@midnight-ntwrk/midnight-js-node-zk-config-provider';
+import { ZKConfigProvider } from '@midnight-ntwrk/midnight-js-types';
+import { ACCOUNT_BUILD } from "./account.js";
+// Where each build's release is: its tag is `build-` and the build's id.
+const ARTEFACT_RELEASES = 'https://github.com/kuiralabs/midnight-account-artifacts/releases/download/';
+// A fetch is abandoned when no bytes arrive for this long.
+const FETCH_STALL_MS = 60_000;
+// A build's id: this many hex digits of its manifest's SHA-256.
+const BUILD_ID_HEX_DIGITS = 16;
+const KEYS = 'keys';
+const ZKIR_DIRECTORY = 'zkir';
+const COMPILER = 'compiler';
+const MANIFEST = 'contract-manifest.json';
+const CONTRACT_INFO = 'contract-info.json';
+const ARTEFACT_DIRECTORIES = [KEYS, ZKIR_DIRECTORY];
+const manifestBytes = () => readFileSync(join(ACCOUNT_BUILD, COMPILER, MANIFEST));
+// This package's build of the account, by the hash of its manifest.
+export const ACCOUNT_BUILD_ID = createHash('sha256').update(manifestBytes()).digest('hex').slice(0, BUILD_ID_HEX_DIGITS);
+// This build's release, the source when none is named.
+export const BUILD_RELEASE = `${ARTEFACT_RELEASES}build-${ACCOUNT_BUILD_ID}/`;
+const MANIFEST_ENTRIES = JSON.parse(manifestBytes().toString('utf8'));
+const entryOf = (directory, name) => {
+    const entry = MANIFEST_ENTRIES[directory][name];
+    if (entry?.type !== 'file')
+        throw new Error(`this build of the account has no ${directory}/${name}`);
+    return entry;
+};
+const proverKeyFile = (circuit) => [KEYS, `${circuit}.prover`];
+const verifierKeyFile = (circuit) => [KEYS, `${circuit}.verifier`];
+const zkirFile = (circuit) => [ZKIR_DIRECTORY, `${circuit}.bzkir`];
+const hasCode = (error, code) => error instanceof Error && 'code' in error && error.code === code;
+// A temporary file beside `path`, named for the process writing it, so a run
+// can tell a dead process's leftovers from a live one's.
+const TEMPORARY_RANDOM_BYTES = 6;
+const temporaryPath = (path) => `${path}.${process.pid}.${randomBytes(TEMPORARY_RANDOM_BYTES).toString('hex')}.tmp`;
+const TEMPORARY_NAME = new RegExp(`\\.(\\d+)\\.[0-9a-f]{${TEMPORARY_RANDOM_BYTES * 2}}\\.tmp$`);
+const isRunning = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (cause) {
+        return hasCode(cause, 'EPERM');
+    }
+};
+// Removes a file another process may be removing at the same moment.
+const removeIfThere = (path) => {
+    try {
+        unlinkSync(path);
+    }
+    catch (cause) {
+        if (!hasCode(cause, 'ENOENT'))
+            throw cause;
+    }
+};
+const sizeOf = (path) => {
+    try {
+        return statSync(path).size;
+    }
+    catch (cause) {
+        if (hasCode(cause, 'ENOENT'))
+            return undefined;
+        throw cause;
+    }
+};
+const sha256Of = async (path) => {
+    const hash = createHash('sha256');
+    for await (const chunk of createReadStream(path))
+        hash.update(chunk);
+    return hash.digest('hex');
+};
+const matches = async (path, entry) => sizeOf(path) === entry.size && (await sha256Of(path)) === entry.hash;
+const sourceOf = (source) => {
+    if (/^https?:\/\//.test(source))
+        return { kind: 'url', base: new URL(source) };
+    const path = source.startsWith('file://') ? fileURLToPath(source) : source;
+    if (!isAbsolute(path))
+        throw new Error(`the source of the proving artefacts must be an http(s) URL or an absolute directory, not ${JSON.stringify(source)}`);
+    return { kind: 'directory', path };
+};
+// `name` under the base URL's path, keeping its query string.
+const urlOf = (base, name) => {
+    const url = new URL(base);
+    url.pathname = `${url.pathname.replace(/\/?$/, '/')}${name}`;
+    return url;
+};
+// Streams `url` into `temporary`, refusing more bytes than the manifest's size
+// and giving up when the server stalls for `stallMs`. The request is aborted
+// once done either way, so a refused response's body never holds a socket open.
+const download = async (url, temporary, entry, stallMs) => {
+    const controller = new AbortController();
+    const stall = setTimeout(() => controller.abort(new Error(`no data for ${stallMs / 1000} s`)), stallMs);
+    try {
+        const response = await fetch(url, { signal: controller.signal });
+        const body = response.body;
+        if (!response.ok || body === null)
+            throw new Error(`HTTP ${response.status}`);
+        let received = 0;
+        await pipeline(async function* () {
+            for await (const chunk of body) {
+                received += chunk.length;
+                if (received > entry.size)
+                    throw new Error(`more than the manifest's ${entry.size} bytes`);
+                stall.refresh();
+                yield chunk;
+            }
+        }, createWriteStream(temporary));
+    }
+    finally {
+        clearTimeout(stall);
+        controller.abort();
+    }
+};
+// The cache for this build under `root` (its own directory there, named by the
+// build's id, so two builds' files never mix): the manifest is placed in it,
+// and what a killed fetch left is removed.
+export const artefactCache = (root, { source = BUILD_RELEASE, stallMs = FETCH_STALL_MS } = {}) => {
+    if (!isAbsolute(root))
+        throw new Error(`the proving artefacts' cache must be an absolute path, not ${JSON.stringify(root)}`);
+    const from = sourceOf(source);
+    const directory = join(root, ACCOUNT_BUILD_ID);
+    placeCompilerFiles(directory);
+    removeAbandoned(directory);
+    // One fetch per file at a time: a second ask waits for the first.
+    const inFlight = new Map();
+    const ensureFile = ([folder, name]) => {
+        const relative = `${folder}/${name}`;
+        const running = inFlight.get(relative);
+        if (running !== undefined)
+            return running;
+        const fetching = (async () => {
+            const target = join(directory, folder, name);
+            const entry = entryOf(folder, name);
+            if (!(await matches(target, entry)))
+                await fetchInto(from, folder, name, target, entry, stallMs);
+        })().finally(() => inFlight.delete(relative));
+        inFlight.set(relative, fetching);
+        return fetching;
+    };
+    const ensure = async (circuits) => {
+        for (const circuit of circuits)
+            for (const file of [proverKeyFile(circuit), verifierKeyFile(circuit), zkirFile(circuit)])
+                await ensureFile(file);
+    };
+    const provider = () => new FetchingZkConfigProvider(new NodeZkConfigProvider(directory), ensureFile);
+    return { directory, ensure, provider };
+};
+// midnight-js's provider over the cache, each file fetched before it is read.
+class FetchingZkConfigProvider extends ZKConfigProvider {
+    cached;
+    ensureFile;
+    constructor(cached, ensureFile) {
+        super();
+        this.cached = cached;
+        this.ensureFile = ensureFile;
+    }
+    getArtifactRuntimeVersion() {
+        return this.cached.getArtifactRuntimeVersion();
+    }
+    async getProverKey(circuitId) {
+        await this.ensureFile(proverKeyFile(circuitId));
+        return this.cached.getProverKey(circuitId);
+    }
+    async getVerifierKey(circuitId) {
+        await this.ensureFile(verifierKeyFile(circuitId));
+        return this.cached.getVerifierKey(circuitId);
+    }
+    async getZKIR(circuitId) {
+        await this.ensureFile(zkirFile(circuitId));
+        return this.cached.getZKIR(circuitId);
+    }
+}
+// Writes this build's compiler files into the cache, atomically, unless the
+// same ones are there; a cache holding another build's is refused.
+const placeCompilerFiles = (directory) => {
+    mkdirSync(join(directory, COMPILER), { recursive: true });
+    for (const name of [MANIFEST, CONTRACT_INFO]) {
+        const ours = readFileSync(join(ACCOUNT_BUILD, COMPILER, name));
+        const target = join(directory, COMPILER, name);
+        if (existsSync(target)) {
+            if (readFileSync(target).equals(ours))
+                continue;
+            throw new Error(`${target} is another build's: the cache ${directory} is not this build's`);
+        }
+        const temporary = temporaryPath(target);
+        writeFileSync(temporary, ours);
+        renameSync(temporary, target);
+    }
+};
+// Removes the temporary files of fetches whose process is gone (killed
+// mid-download); a running process's own are left alone.
+const removeAbandoned = (directory) => {
+    for (const folder of ARTEFACT_DIRECTORIES) {
+        const path = join(directory, folder);
+        if (!existsSync(path))
+            continue;
+        for (const name of readdirSync(path)) {
+            const pid = TEMPORARY_NAME.exec(name)?.[1];
+            if (pid !== undefined && !isRunning(Number(pid)))
+                removeIfThere(join(path, name));
+        }
+    }
+};
+// Fetches one file to a temporary path beside `target`, checks it against its
+// manifest entry, and only then moves it into place. A URL serves it under its
+// own name, a directory under its compactc directory.
+const fetchInto = async (source, folder, name, target, entry, stallMs) => {
+    mkdirSync(dirname(target), { recursive: true });
+    const temporary = temporaryPath(target);
+    const from = source.kind === 'url' ? urlOf(source.base, name).href : join(source.path, folder, name);
+    try {
+        if (source.kind === 'url') {
+            await download(new URL(from), temporary, entry, stallMs);
+        }
+        else {
+            if (!existsSync(from))
+                throw new Error('not found');
+            await copyFile(from, temporary);
+        }
+        if (!(await matches(temporary, entry)))
+            throw new Error("not this build's file: refused");
+        renameSync(temporary, target);
+    }
+    catch (cause) {
+        throw new Error(`${folder}/${name} from ${from}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    }
+    finally {
+        removeIfThere(temporary);
+    }
+};

package/dist/src/connect.d.ts

@@ -1,5 +1,4 @@
-import { type EncPublicKey } from '@midnight-ntwrk/midnight-js-protocol/ledger';
-import { MidnightWalletProvider } from '@midnight-ntwrk/testkit-js';
+import type { EncPublicKey } from '@midnight-ntwrk/midnight-js-protocol/ledger';
 import { type Bytes32 } from '@kuiralabs/midnight-account';
 import { type Ledger } from '../managed/Account/contract/index.js';
 import { type FeeWallet, type ProviderPaths } from './providers.ts';
@@ -12,18 +11,8 @@ export declare const connectOver: (address: string, wallet: FeeWallet, paths: Pr
     readLedger: () => Promise<Ledger>;
     close: () => Promise<void>;
 }>;
-export declare const connect: (address: string, walletSeed: string, paths: ProviderPaths) => Promise<{
-    wallet: MidnightWalletProvider;
-    address: string;
-    providers: import("./providers.ts").AccountProviders;
-    account: import("@midnight-ntwrk/midnight-js-contracts").FoundContract<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>>;
-    self: Bytes32;
-    readLedger: () => Promise<Ledger>;
-    close: () => Promise<void>;
-}>;
 export declare const timed: <T>(label: string, run: () => Promise<T>) => Promise<T>;
 export type ShieldedAddress = {
     readonly coinPublicKey: Bytes32;
     readonly encryptionPublicKey: EncPublicKey;
 };
-export declare const shieldedAddressOf: (walletSeed: string) => ShieldedAddress;

package/dist/src/connect.js

@@ -2,12 +2,9 @@
 // providers and private-state store, the found contract, and reads of the
 // account's public state.
 import { findDeployedContract } from '@midnight-ntwrk/midnight-js-contracts';
-import { ZswapSecretKeys } from '@midnight-ntwrk/midnight-js-protocol/ledger';
-import { MidnightWalletProvider, createDefaultTestLogger, getShieldedSeed } from '@midnight-ntwrk/testkit-js';
 import { fromHex } from '@kuiralabs/midnight-account';
 import { ledger } from '../managed/Account/contract/index.js';
 import { EMPTY_PRIVATE_STATE, compiledAccount } from "./account.js";
-import { LOCALNET } from "./localnet.js";
 import { PRIVATE_STATE_ID, accountProviders } from "./providers.js";
 // A connection over a wallet the caller brings and will close: the account's
 // calls need only that it balances and submits (FeeWallet).
@@ -31,13 +28,6 @@ export const connectOver = async (address, wallet, paths, close) => {
     };
     return { address, providers, account, self, readLedger, close };
 };
-// A connection over the testkit wallet of a seed, which it starts and stops.
-// The scripts that move the wallet's own funds reach it as `wallet`.
-export const connect = async (address, walletSeed, paths) => {
-    const wallet = await MidnightWalletProvider.build(createDefaultTestLogger(), LOCALNET, walletSeed);
-    await wallet.start(true);
-    return { ...(await connectOver(address, wallet, paths, () => wallet.stop())), wallet };
-};
 // Times one on-chain step and reports it.
 export const timed = async (label, run) => {
     const startedAt = Date.now();
@@ -45,9 +35,3 @@ export const timed = async (label, run) => {
     console.log(`${label}: ${((Date.now() - startedAt) / 1000).toFixed(1)} s`);
     return result;
 };
-// A wallet seed's shielded address, derived as the wallet derives it (the
-// Zswap role of account 0, key 0), without syncing that wallet.
-export const shieldedAddressOf = (walletSeed) => {
-    const keys = ZswapSecretKeys.fromSeed(getShieldedSeed(walletSeed));
-    return { coinPublicKey: fromHex(keys.coinPublicKey, 32), encryptionPublicKey: keys.encryptionPublicKey };
-};

package/dist/src/localnet.d.ts

@@ -1,6 +1,16 @@
-import type { EnvironmentConfiguration } from '@midnight-ntwrk/testkit-js';
+import type { NetworkId } from '@midnightntwrk/wallet-sdk';
 export declare const NETWORK_ID = "undeployed";
 export declare const GENESIS_SEED = "0000000000000000000000000000000000000000000000000000000000000001";
 export declare const AGENT_FEE_SEED = "0000000000000000000000000000000000000000000000000000000000000002";
 export declare const MERCHANT_SEED = "0000000000000000000000000000000000000000000000000000000000000003";
-export declare const LOCALNET: EnvironmentConfiguration;
+export type Network = {
+    readonly networkId: string;
+    readonly walletNetworkId: NetworkId.NetworkId;
+    readonly node: string;
+    readonly nodeWS: string;
+    readonly indexer: string;
+    readonly indexerWS: string;
+    readonly proofServer: string;
+    readonly faucet: string | undefined;
+};
+export declare const LOCALNET: Network;

package/dist/src/profile.d.ts

@@ -1,9 +1,10 @@
+import { type ArtefactCache } from './artefacts.ts';
 import type { ProviderPaths } from './providers.ts';
 export declare const PROFILE: string | undefined;
 export declare const STATE_DIR: URL;
 export declare const stateFile: (name: string) => URL;
 export declare const ensureStateDir: () => void;
-export declare const ARTEFACTS: string;
+export declare const ARTEFACTS: string | ArtefactCache;
 export declare const OWNER_PATHS: ProviderPaths;
 export declare const AGENT_PATHS: ProviderPaths;
 export declare const PAYEE_PATHS: ProviderPaths;

package/dist/src/profile.js

@@ -10,13 +10,16 @@
 // profiles then live under it the same way.
 //
 // The proving artefacts are the repo's own build. The package as published
-// carries none (they are hundreds of megabytes), so a caller running from it
-// names a directory holding them with MIDNIGHT_ACCOUNT_ARTEFACTS_DIR, laid out
-// as compactc's output; its manifest must be this package's own.
-import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+// carries none (they are gigabytes), so a caller running from it names a
+// directory to cache them in with MIDNIGHT_ACCOUNT_ARTEFACTS_DIR: each file is
+// fetched as it is first needed, from this build's release or from
+// MIDNIGHT_ACCOUNT_ARTEFACTS_SOURCE, and kept only if it matches this
+// package's manifest (artefacts.ts).
+import { existsSync, mkdirSync } from 'node:fs';
 import { isAbsolute, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { ACCOUNT_BUILD } from "./account.js";
+import { artefactCache } from "./artefacts.js";
 // A profile name is a plain directory name, so it can neither escape
 // .state/ nor alias the default profile's directory.
 const PROFILE_NAME = /^[a-z0-9][a-z0-9-]{0,31}$/;
@@ -45,26 +48,22 @@ export const ensureStateDir = () => {
 };
 // A private-state store name for this profile.
 const profileStore = (base) => (PROFILE === undefined ? base : `${base}-${PROFILE}`);
-const MANIFEST = join('compiler', 'contract-manifest.json');
 const KEYS = 'keys';
-// The proving artefacts every party proves with: the directory the caller
-// names, if its build is this package's, else this package's own build, if it
-// holds them.
+// The proving artefacts every party proves with: a cache in the directory the
+// caller names, else this package's own build, if it holds them.
 const artefactsFromEnvironment = () => {
     const directory = process.env.MIDNIGHT_ACCOUNT_ARTEFACTS_DIR;
+    const source = process.env.MIDNIGHT_ACCOUNT_ARTEFACTS_SOURCE;
     if (directory === undefined) {
+        if (source !== undefined)
+            throw new Error('MIDNIGHT_ACCOUNT_ARTEFACTS_SOURCE needs MIDNIGHT_ACCOUNT_ARTEFACTS_DIR: name the directory to cache the proving artefacts in');
         if (!existsSync(join(ACCOUNT_BUILD, KEYS)))
-            throw new Error('this build of the account carries no proving keys: name a directory holding them with MIDNIGHT_ACCOUNT_ARTEFACTS_DIR');
+            throw new Error('this build of the account carries no proving keys: name a directory to cache them in with MIDNIGHT_ACCOUNT_ARTEFACTS_DIR');
         return ACCOUNT_BUILD;
     }
     if (!isAbsolute(directory))
         throw new Error(`MIDNIGHT_ACCOUNT_ARTEFACTS_DIR must be an absolute path: ${JSON.stringify(directory)}`);
-    const manifest = join(directory, MANIFEST);
-    if (!existsSync(manifest))
-        throw new Error(`MIDNIGHT_ACCOUNT_ARTEFACTS_DIR holds no ${MANIFEST}: ${directory}`);
-    if (!readFileSync(manifest).equals(readFileSync(join(ACCOUNT_BUILD, MANIFEST))))
-        throw new Error(`MIDNIGHT_ACCOUNT_ARTEFACTS_DIR holds another build of the account than this package's: ${directory}`);
-    return directory;
+    return artefactCache(directory, source === undefined ? {} : { source });
 };
 export const ARTEFACTS = artefactsFromEnvironment();
 // Each party's providers for this profile.

package/dist/src/providers.d.ts

@@ -1,10 +1,11 @@
 import type { MidnightProvider, MidnightProviders, WalletProvider } from '@midnight-ntwrk/midnight-js-types';
 import type { AccountCircuitId, AccountPrivateState } from './account.ts';
+import type { ArtefactCache } from './artefacts.ts';
 export declare const PRIVATE_STATE_ID = "account";
 export type AccountProviders = MidnightProviders<AccountCircuitId, string, AccountPrivateState>;
 export type ProviderPaths = {
     readonly store: string;
-    readonly artefacts: string;
+    readonly artefacts: string | ArtefactCache;
 };
 export type FeeWallet = WalletProvider & MidnightProvider;
 export declare const accountProviders: (wallet: FeeWallet, { store, artefacts }: ProviderPaths) => AccountProviders;

package/dist/src/providers.js

@@ -16,7 +16,7 @@ const STORE_PASSWORD = 'Answer to the Ultimate Question of Life, the Universe, a
 // before this function existed are still found.
 const storeAccountOf = (wallet) => Buffer.from(wallet.getCoinPublicKey()).toString('hex');
 export const accountProviders = (wallet, { store, artefacts }) => {
-    const zkConfigProvider = new NodeZkConfigProvider(artefacts);
+    const zkConfigProvider = typeof artefacts === 'string' ? new NodeZkConfigProvider(artefacts) : artefacts.provider();
     return {
         privateStateProvider: levelPrivateStateProvider({
             privateStateStoreName: store,

package/dist/src/seedWallets.d.ts

@@ -0,0 +1,75 @@
+import { MidnightWalletProvider } from '@midnight-ntwrk/testkit-js';
+import { type AgentOptions } from './agent.ts';
+import { type ShieldedAddress } from './connect.ts';
+import type { ProviderPaths } from './providers.ts';
+export declare const connect: (address: string, walletSeed: string, paths: ProviderPaths) => Promise<{
+    wallet: MidnightWalletProvider;
+    address: string;
+    providers: import("./providers.ts").AccountProviders;
+    account: import("@midnight-ntwrk/midnight-js-contracts").FoundContract<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>>;
+    self: import("@kuiralabs/midnight-account").Bytes32;
+    readLedger: () => Promise<import("../managed/Account/contract/index.js").Ledger>;
+    close: () => Promise<void>;
+}>;
+export declare const shieldedAddressOf: (walletSeed: string) => ShieldedAddress;
+export declare const openSession: () => Promise<{
+    wallet: MidnightWalletProvider;
+    address: string;
+    providers: import("./providers.ts").AccountProviders;
+    account: import("@midnight-ntwrk/midnight-js-contracts").FoundContract<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>>;
+    self: import("@kuiralabs/midnight-account").Bytes32;
+    readLedger: () => Promise<import("../managed/Account/contract/index.js").Ledger>;
+    close: () => Promise<void>;
+} & {
+    device: import("./device.ts").OwnerDevice;
+    bootSalt: Uint8Array<ArrayBufferLike>;
+    encSecret: () => import("@kuiralabs/midnight-account").Bytes32;
+    calls: {
+        activate: (bootSalt: import("@kuiralabs/midnight-account").Bytes32) => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "activate_initial_device_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "activate_initial_device_with_k256">>;
+        withdrawUnshielded: (color: import("@kuiralabs/midnight-account").Bytes32, amount: bigint, recipient: import("@kuiralabs/midnight-account").Bytes32) => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "withdraw_unshielded_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "withdraw_unshielded_with_k256">>;
+        withdrawShielded: (recipient: import("@kuiralabs/midnight-account").Bytes32, amount: bigint, coin: import("@kuiralabs/midnight-account").HeldCoin) => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "withdraw_shielded_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "withdraw_shielded_with_k256">>;
+        unprovenWithdrawShieldedToContract: (recipient: import("@kuiralabs/midnight-account").Bytes32, amount: bigint, coin: import("@kuiralabs/midnight-account").HeldCoin) => Promise<import("./compose.ts").UnprovenCall & {
+            readonly landed: () => Promise<void>;
+        }>;
+        appendInbox: (entry: Uint8Array) => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "append_inbox_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "append_inbox_with_k256">>;
+        rotateEncKey: (newKey: import("@kuiralabs/midnight-account").Bytes32) => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "rotate_enc_key_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "rotate_enc_key_with_k256">>;
+        addDevice: (newPk: import("@kuiralabs/midnight-account").Point) => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "add_device_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "add_device_with_k256">>;
+        issueGrant: (grantId: import("@kuiralabs/midnight-account").Bytes32, scope: import("@kuiralabs/midnight-account").GrantScope) => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "issue_grant_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "issue_grant_with_k256">>;
+        revokeGrant: (grantId: import("@kuiralabs/midnight-account").Bytes32) => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "revoke_grant_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "revoke_grant_with_k256">>;
+        revokeAllGrants: () => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "revoke_all_grants_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "revoke_all_grants_with_k256">>;
+    };
+    expectChange: (change: import("@kuiralabs/midnight-account").SealedCoin) => void;
+    settleChanges: () => Promise<number>;
+    refreshCoins: () => Promise<readonly import("./coins.ts").DiscoveredCoin[]>;
+    reencryptHoldings: () => Promise<number>;
+    rotateEncKey: () => Promise<number>;
+}>;
+export declare const openAgent: (slot: number, options?: AgentOptions) => Promise<{
+    grantee: import("./grantee.ts").Grantee;
+    grantId: import("@kuiralabs/midnight-account").Bytes32;
+    payContract: (coin: import("./coins.ts").DiscoveredCoin, payee: string, amount: bigint) => Promise<{
+        finalized: import("@midnight-ntwrk/midnight-js-types").FinalizedTxData;
+        sent: import("@kuiralabs/midnight-account").SealedCoin;
+        change: import("@kuiralabs/midnight-account").SealedCoin | undefined;
+    }>;
+    unprovenContractSpend: (coin: import("./coins.ts").DiscoveredCoin, payee: import("@kuiralabs/midnight-account").Bytes32, amount: bigint) => Promise<import("./compose.ts").UnprovenCall & {
+        readonly change: import("@kuiralabs/midnight-account").SealedCoin | undefined;
+    }>;
+    scope: import("@kuiralabs/midnight-account").GrantScope;
+    source: () => "mailbox" | "response file";
+    spent: () => bigint;
+    readCoins: () => Promise<readonly import("./coins.ts").DiscoveredCoin[]>;
+    spendShielded: (coin: import("./coins.ts").DiscoveredCoin, merchant: ShieldedAddress, amount: bigint) => Promise<{
+        result: import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "withdraw_shielded_with_grant_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "withdraw_shielded_with_grant_k256">;
+        change: import("@kuiralabs/midnight-account").SealedCoin | undefined;
+    }>;
+    proveShieldedSpend: (coin: import("./coins.ts").DiscoveredCoin, merchant: ShieldedAddress, amount: bigint) => Promise<import("./agent.ts").ProvedSpend>;
+    submitProved: ({ tx, amount }: import("./agent.ts").ProvedSpend) => Promise<import("@midnight-ntwrk/midnight-js-types").VersionedFinalizedTxData>;
+    address: string;
+    providers: import("./providers.ts").AccountProviders;
+    account: import("@midnight-ntwrk/midnight-js-contracts").FoundContract<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>>;
+    self: import("@kuiralabs/midnight-account").Bytes32;
+    readLedger: () => Promise<import("../managed/Account/contract/index.js").Ledger>;
+    close: () => Promise<void>;
+    wallet: import("./providers.ts").FeeWallet;
+}>;

package/dist/src/seedWallets.js

@@ -0,0 +1,31 @@
+// The repository's own parties, each paid by the testkit wallet of a localnet
+// seed: the owner by the genesis wallet, the agent by its fee wallet. Only the
+// repository's scripts and command line use them, so they are not built, and
+// nothing a client loads reaches testkit-js. A client brings its own wallet
+// instead (connectOver, openSessionOver, openAgentOver).
+import { ZswapSecretKeys } from '@midnight-ntwrk/midnight-js-protocol/ledger';
+import { MidnightWalletProvider, createDefaultTestLogger, getShieldedSeed } from '@midnight-ntwrk/testkit-js';
+import { fromHex } from '@kuiralabs/midnight-account';
+import { agentAccount, openAgentOver } from "./agent.js";
+import { connectOver } from "./connect.js";
+import { AGENT_FEE_SEED, GENESIS_SEED, LOCALNET } from "./localnet.js";
+import { AGENT_PATHS, OWNER_PATHS } from "./profile.js";
+import { openSessionOver, readOwner } from "./session.js";
+// A connection over the testkit wallet of a seed, which it starts and stops.
+// The scripts that move the wallet's own funds reach it as `wallet`.
+export const connect = async (address, walletSeed, paths) => {
+    const wallet = await MidnightWalletProvider.build(createDefaultTestLogger(), LOCALNET, walletSeed);
+    await wallet.start(true);
+    return { ...(await connectOver(address, wallet, paths, () => wallet.stop())), wallet };
+};
+// A wallet seed's shielded address, derived as the wallet derives it (the
+// Zswap role of account 0, key 0), without syncing that wallet.
+export const shieldedAddressOf = (walletSeed) => {
+    const keys = ZswapSecretKeys.fromSeed(getShieldedSeed(walletSeed));
+    return { coinPublicKey: fromHex(keys.coinPublicKey, 32), encryptionPublicKey: keys.encryptionPublicKey };
+};
+// The owner's session paid by the genesis wallet, which the scripts that move
+// that wallet's own funds reach as `wallet`.
+export const openSession = async () => openSessionOver(await connect(readOwner().contractAddress, GENESIS_SEED, OWNER_PATHS));
+// The agent's session over its own fee wallet.
+export const openAgent = async (slot, options = {}) => openAgentOver(await connect(agentAccount(), AGENT_FEE_SEED, AGENT_PATHS), slot, options);

package/dist/src/session.d.ts

@@ -1,6 +1,6 @@
 import { type Arm, type Bytes32, type SealedCoin } from '@kuiralabs/midnight-account';
 import { type DiscoveredCoin } from './coins.ts';
-import { type Connection } from './connect.ts';
+import type { Connection } from './connect.ts';
 import { type OwnerDevice } from './device.ts';
 export type OwnerRecord = {
     readonly contractAddress: string;
@@ -44,36 +44,4 @@ export declare const openSessionOver: <C extends Connection>(connection: C) => P
     reencryptHoldings: () => Promise<number>;
     rotateEncKey: () => Promise<number>;
 }>;
-export declare const openSession: () => Promise<{
-    wallet: import("@midnight-ntwrk/testkit-js").MidnightWalletProvider;
-    address: string;
-    providers: import("./providers.ts").AccountProviders;
-    account: import("@midnight-ntwrk/midnight-js-contracts").FoundContract<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>>;
-    self: Bytes32;
-    readLedger: () => Promise<import("../managed/Account/contract/index.js").Ledger>;
-    close: () => Promise<void>;
-} & {
-    device: OwnerDevice;
-    bootSalt: Uint8Array<ArrayBufferLike>;
-    encSecret: () => Bytes32;
-    calls: {
-        activate: (bootSalt: Bytes32) => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "activate_initial_device_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "activate_initial_device_with_k256">>;
-        withdrawUnshielded: (color: Bytes32, amount: bigint, recipient: Bytes32) => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "withdraw_unshielded_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "withdraw_unshielded_with_k256">>;
-        withdrawShielded: (recipient: Bytes32, amount: bigint, coin: import("@kuiralabs/midnight-account").HeldCoin) => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "withdraw_shielded_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "withdraw_shielded_with_k256">>;
-        unprovenWithdrawShieldedToContract: (recipient: Bytes32, amount: bigint, coin: import("@kuiralabs/midnight-account").HeldCoin) => Promise<import("./compose.ts").UnprovenCall & {
-            readonly landed: () => Promise<void>;
-        }>;
-        appendInbox: (entry: Uint8Array) => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "append_inbox_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "append_inbox_with_k256">>;
-        rotateEncKey: (newKey: Bytes32) => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "rotate_enc_key_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "rotate_enc_key_with_k256">>;
-        addDevice: (newPk: import("@kuiralabs/midnight-account").Point) => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "add_device_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "add_device_with_k256">>;
-        issueGrant: (grantId: Bytes32, scope: import("@kuiralabs/midnight-account").GrantScope) => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "issue_grant_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "issue_grant_with_k256">>;
-        revokeGrant: (grantId: Bytes32) => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "revoke_grant_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "revoke_grant_with_k256">>;
-        revokeAllGrants: () => Promise<import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "revoke_all_grants_with_jubjub"> | import("@midnight-ntwrk/midnight-js-contracts").FinalizedCallTxData<import("../managed/Account/contract/index.js").Contract<import("./account.ts").AccountPrivateState, import("../managed/Account/contract/index.js").Witnesses<import("./account.ts").AccountPrivateState>>, "revoke_all_grants_with_k256">>;
-    };
-    expectChange: (change: SealedCoin) => void;
-    settleChanges: () => Promise<number>;
-    refreshCoins: () => Promise<readonly DiscoveredCoin[]>;
-    reencryptHoldings: () => Promise<number>;
-    rotateEncKey: () => Promise<number>;
-}>;
 export {};

package/dist/src/session.js

@@ -6,10 +6,8 @@
 import { readFileSync, writeFileSync } from 'node:fs';
 import { fromHex, hexOf, sealInboxEntry, x25519KeyPair, x25519PublicOf } from '@kuiralabs/midnight-account';
 import { coinStore, contractCoinCommitment, readAccountZswap, walkInbox } from "./coins.js";
-import { connect } from "./connect.js";
 import { JubjubDevice, K256Device, recoverUseCounter } from "./device.js";
-import { GENESIS_SEED } from "./localnet.js";
-import { OWNER_PATHS, stateFile } from "./profile.js";
+import { stateFile } from "./profile.js";
 import { ownerCalls } from "./ownerCalls.js";
 import { PRIVATE_STATE_ID } from "./providers.js";
 const changeToJson = (coin) => ({ nonce: hexOf(coin.nonce), color: hexOf(coin.color), value: coin.value.toString() });
@@ -133,6 +131,3 @@ export const openSessionOver = async (connection) => {
         rotateEncKey,
     };
 };
-// The owner's session paid by the genesis wallet, which the scripts that move
-// that wallet's own funds reach as `wallet`.
-export const openSession = async () => openSessionOver(await connect(readOwner().contractAddress, GENESIS_SEED, OWNER_PATHS));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kuiralabs/midnight-account-chain",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "description": "The account contract on a local ledger-9 network, over midnight-js 5: a wallet-free reader, connections, composed contract payments, devices and grantees, the grant mailbox and verifier-key maintenance.",
   "license": "Apache-2.0",
@@ -37,11 +37,11 @@
     "@midnight-ntwrk/midnight-js-node-zk-config-provider": "5.0.0-rc.1",
     "@midnight-ntwrk/midnight-js-protocol": "5.0.0-rc.1",
     "@midnight-ntwrk/midnight-js-types": "5.0.0-rc.1",
-    "@midnight-ntwrk/testkit-js": "5.0.0-rc.1",
     "@midnightntwrk/ledger-v9": "1.0.0-rc.5",
     "@midnightntwrk/wallet-sdk": "2.0.0-rc.0"
   },
   "devDependencies": {
+    "@midnight-ntwrk/testkit-js": "5.0.0-rc.1",
     "@types/node": "24.13.2",
     "typescript": "6.0.3"
   },