A child account is an account derived from a root account at a BIP32 path, m/0, m/1 and so on. It has its own public key and EVM address, but no keyshares of its own: the root's signers own it through their shares of the root, so the root's signer set and threshold apply to every child.
Creating a child runs no keygen ceremony. The Salt API allocates the next path, the creating signer derives the child key from its share of the root, and a Robo signer of the root confirms it by deriving the same key from its own share. Only then does the child become active. Both sides derive with deriveChildPublicKey from @kagamidigital/salt-signer-sdk, a non-hardened BIP32 derivation that works on a single share.
Call createChildAccount with the root account and a name. It resolves once a Robo has confirmed the child:
const child = await salt.createChildAccount({
accountId: root.id,
name: 'Payroll',
signer: walletClient,
});
console.log(child.derivationPath); // 'm/0'
console.log(child.evmAddress);
The caller must:
The root needs at least one Robo signer online to confirm the child.
sequenceDiagram
participant C as salt-sdk (signer)
participant A as kagami-node (Salt API)
participant W as salt-websockets
participant R as salt-robo (Robo signer)
participant S as salt-signer-sdk
C->>A: create child: request the root's next derivation path
A->>A: allocate m/N (N = root's next child index), save child as pending
A-->>C: pending child at m/N
C->>C: load root keyshare
C->>S: deriveChildPublicKey(keyshare, m/N)
S-->>C: child public key (gives the child's address)
C->>A: propose child public key
C->>W: child-verify nudge to the root's Robo signers
W->>R: forward nudge
R->>A: read the child's path and the root
R->>R: load root keyshare
R->>S: deriveChildPublicKey(keyshare, m/N)
S-->>R: child public key
R->>A: confirm path and derived public key
A->>A: keys match: activate the child
loop until active
C->>A: read the child
end
A-->>C: active child with its public key and address
The Robo never sees the proposed key, and takes nothing from the nudge but the account and child ids: it reads the path from the API and derives the key itself. The API activates the child only if the Robo's key matches the proposal, so a wrong proposal cannot go live. One Robo confirmation is enough.
A child stays pending until a Robo confirms it. While it waits, createChildAccount re-nudges the Robos once, halfway through its timeout (60 seconds by default, set with timeoutMs). If no Robo confirms in time, it throws ChildVerificationTimeoutError and the child stays pending at its path.
Retry with retryChildVerification. It keeps the child's path:
try {
await salt.createChildAccount({
accountId: root.id,
name: 'Payroll',
signer,
});
} catch (err) {
if (err instanceof ChildVerificationTimeoutError) {
await salt.retryChildVerification({
accountId: err.accountId,
childId: err.childId,
signer,
});
}
}
getChildAccounts lists a root's children in path order, and getChildAccount returns one. A child carries kind: 'child', parentAccountId, childIndex, derivationPath and status. Its publicKey is empty, and it has no evmAddress, until it is active.
A Robo confirms children automatically: a Robo's NudgeListener handles child-verify nudges. With autoJoin: false it emits childVerifyReceived, whose verify callback derives and confirms the key; in autoJoin mode it confirms on its own and emits childVerified. verifyChildAccount confirms a child directly, out of band.
Child accounts cannot sign yet. Signing messages, verifying the account, submitting transactions and paying fees from a child all throw a ValidationError. Children do not inherit the root's policies.