SDK
createWallet
client.createWallet creates a smart-account wallet for a signer. The signer's key lives wherever you keep it (env var, OS keychain, hardware wallet). Altana never sees it.
First create a client with createClient, configured with the chains the wallet should work on. The same wallet address is provisioned on every chain the client lists.
import { createClient, BNB, signerFromPrivateKey } from "@altananetwork/sdk";
const client = createClient({ chains: [BNB] });
const signer = signerFromPrivateKey("0x...");
const wallet = await client.createWallet({ signer });The wallet is counterfactual. Its address is deterministic, but it isn't a smart account onchain until the first execute. That first execute is what registers the admin key in Keystore.
Parameters
type ClientCreateWalletOptions = {
/** Bring your own signer. If omitted, the SDK generates a fresh private-key signer. */
signer?: Signer;
};The chains the wallet is provisioned on come from the client (createClient({ chains })), not from this call.
Returns
type CreateWalletResult = {
address: Address; // the wallet's smart-account address (same on every chain)
signer: Signer; // same reference if you passed one in
};Notes
- Fund
result.addresswith native tokens before callingexecute— the wallet is counterfactual and has no balance until you send some. The first transaction pays the KeyStore registration fee and the relay fee from that balance; unfunded, it throwsThe relay rejected the request to prepare the call: its simulation reverted with no reason on …; the wallet cannot pay for it: it holds 0 tBNB …(see Errors). - Browser wallets (MetaMask, Trust Wallet, Rabby) cannot be the signer — they withhold the signatures a 7702 account needs. They make excellent funding sources instead: see Onboard users from browser wallets for the connect → passkey → one-click-funding flow.
- If you omit
signer, the SDK generates a fresh private-key signer and returns it on the result. Persistresult.signerhowever your app stores keys. - The address is identical on every chain the client was configured with, so one wallet handle works across all of them: pass
chainIdper operation to pick which one. Every signer type is multichain, passkeys included: a passkey has no EOA, so one throwaway secp256k1 signs the EIP-7702 authorization on each chain and is then discarded, and that throwaway's address is the wallet's on all of them. A network whose Keystore lives on another chain with a relay (Base Sepolia, rooted in Sepolia) is provisioned there too, with the same address and admin, because its registry writes go through the wallet's own account there.
Private key helpers
Two functions handle the private-key signer path:
signerFromPrivateKey(key): reconstructs a signer from a key you already have. Use this when the key is stored in an env var, OS keychain, or secrets manager.
import { signerFromPrivateKey } from "@altananetwork/sdk";
const signer = signerFromPrivateKey(process.env.PRIVATE_KEY as `0x${string}`);Need a new key? Generate it yourself, then wrap it. The SDK never stores key material and has no supported way to hand a key back to you, so the copy you make here is the only one.
import { generatePrivateKey } from "viem/accounts";
import { signerFromPrivateKey, createClient, BNB } from "@altananetwork/sdk";
const privateKey = generatePrivateKey();
console.log("Save this key:", privateKey); // persist before continuing
const signer = signerFromPrivateKey(privateKey);
const client = createClient({ chains: [BNB] });
const wallet = await client.createWallet({ signer });createPrivateKeySigner() also generates a fresh secp256k1 key, and createWallet() with no signer argument calls it internally and attaches the result to wallet.signer. Both are fine when the key is ephemeral, for a test or a throwaway wallet. Neither is a good fit when you need to keep the key: wallet.signer is typed as a Signer, which exposes an address, a public key, and the ability to sign, and nothing that yields the private key. Generate the key yourself whenever you intend to persist it.