@xylabs/aries 0.1.1

package/dist/actions/wallet/index.mjs

@@ -0,0 +1,1439 @@
+// src/actions/wallet/account/deriveAndAdd.ts
+import chalk from "chalk";
+
+// src/actions/wallet/paths.ts
+import OS from "os";
+import PATH from "path";
+function walletRoot() {
+  const override = process.env.ARIES_WALLET_HOME;
+  if (override) return override;
+  return PATH.join(OS.homedir(), ".aries", "wallet");
+}
+function walletPaths(root = walletRoot()) {
+  return {
+    root,
+    password: PATH.join(root, "password.json"),
+    phrases: PATH.join(root, "phrases.json"),
+    active: PATH.join(root, "active.json"),
+    addressBooks: PATH.join(root, "address-books.json"),
+    contacts: PATH.join(root, "contacts.json"),
+    networks: PATH.join(root, "networks.json"),
+    session: PATH.join(root, "session.json"),
+    machineId: PATH.join(root, ".machine-id")
+  };
+}
+
+// src/actions/wallet/storage.ts
+import FS from "fs";
+import PATH2 from "path";
+function ensureWalletDir(root = walletRoot()) {
+  if (!FS.existsSync(root)) {
+    FS.mkdirSync(root, { recursive: true, mode: 448 });
+    return;
+  }
+  try {
+    FS.chmodSync(root, 448);
+  } catch {
+  }
+}
+function readJsonFile(file) {
+  if (!FS.existsSync(file)) return void 0;
+  const raw = FS.readFileSync(file, "utf8");
+  if (raw.trim().length === 0) return void 0;
+  return JSON.parse(raw);
+}
+function writeJsonFile(file, value) {
+  ensureWalletDir(PATH2.dirname(file));
+  const tmp = `${file}.tmp`;
+  FS.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+  FS.renameSync(tmp, file);
+  try {
+    FS.chmodSync(file, 384);
+  } catch {
+  }
+}
+function deleteFile(file) {
+  if (FS.existsSync(file)) FS.unlinkSync(file);
+}
+
+// src/actions/wallet/addressBook/storage.ts
+var ADDRESS_BOOK_VERSION = 1;
+function readAllAddressBooks() {
+  return readJsonFile(walletPaths().addressBooks) ?? {};
+}
+function writeAllAddressBooks(data) {
+  writeJsonFile(walletPaths().addressBooks, data);
+}
+function readAddressBook(rootAddress) {
+  const all = readAllAddressBooks();
+  const key = rootAddress.toLowerCase();
+  return all[key] ?? {
+    rootAddress: key,
+    entries: [{ offset: "0" }, { offset: "1" }, { offset: "2" }],
+    version: ADDRESS_BOOK_VERSION
+  };
+}
+function writeAddressBook(book) {
+  const all = readAllAddressBooks();
+  all[book.rootAddress.toLowerCase()] = book;
+  writeAllAddressBooks(all);
+}
+function removeAddressBook(rootAddress) {
+  const all = readAllAddressBooks();
+  const key = rootAddress.toLowerCase();
+  if (key in all) {
+    delete all[key];
+    writeAllAddressBooks(all);
+  }
+}
+function upsertAddressBookEntry(rootAddress, entry) {
+  const book = readAddressBook(rootAddress);
+  const existing = book.entries.find((e) => e.offset === entry.offset);
+  if (existing) {
+    if (entry.label !== void 0) existing.label = entry.label;
+  } else {
+    book.entries.push(entry);
+  }
+  writeAddressBook(book);
+  return book;
+}
+function removeAddressBookEntry(rootAddress, offset) {
+  const book = readAddressBook(rootAddress);
+  book.entries = book.entries.filter((e) => e.offset !== offset);
+  writeAddressBook(book);
+  return book;
+}
+
+// src/actions/wallet/account/getActiveWallet.ts
+import { HDWallet } from "@xyo-network/sdk-js";
+import { DEFAULT_WALLET_PATH } from "@xyo-network/xl1-protocol-sdk";
+
+// src/actions/wallet/prompt.ts
+import { execFileSync } from "child_process";
+import {
+  closeSync,
+  openSync,
+  readSync,
+  writeSync
+} from "fs";
+var CTRL_C = 3;
+var ENTER = 13;
+var NEWLINE = 10;
+var BACKSPACE_DELETE = 127;
+var BACKSPACE = 8;
+function readChars(readFd, writeFd, mask) {
+  const chars = [];
+  const buf = Buffer.alloc(1);
+  for (; ; ) {
+    const bytes = readSync(readFd, buf, 0, 1, null);
+    if (bytes === 0) break;
+    const ch = buf[0];
+    if (ch === ENTER || ch === NEWLINE) break;
+    if (ch === CTRL_C) {
+      writeSync(writeFd, "\n");
+      throw new Error("Aborted");
+    }
+    if (ch === BACKSPACE_DELETE || ch === BACKSPACE) {
+      if (chars.length > 0) {
+        chars.pop();
+        writeSync(writeFd, "\b \b");
+      }
+      continue;
+    }
+    chars.push(ch);
+    writeSync(writeFd, mask ? "*" : String.fromCodePoint(ch));
+  }
+  writeSync(writeFd, "\n");
+  return Buffer.from(chars).toString("utf8");
+}
+function saveStty(readFd) {
+  try {
+    return execFileSync("stty", ["-g"], {
+      stdio: [readFd, "pipe", "ignore"],
+      encoding: "utf8"
+    }).trim();
+  } catch {
+    return void 0;
+  }
+}
+function applyStty(readFd, args) {
+  try {
+    execFileSync("stty", args, { stdio: [readFd, "ignore", "ignore"] });
+  } catch {
+  }
+}
+function promptTty(options) {
+  const readFd = openSync("/dev/tty", "r");
+  const writeFd = openSync("/dev/tty", "w");
+  const saved = saveStty(readFd);
+  try {
+    if (saved) applyStty(readFd, ["-echo", "-icanon", "min", "1", "time", "0"]);
+    writeSync(writeFd, options.prompt);
+    return readChars(readFd, writeFd, options.mask === true);
+  } finally {
+    if (saved) applyStty(readFd, [saved]);
+    try {
+      closeSync(readFd);
+    } catch {
+    }
+    try {
+      closeSync(writeFd);
+    } catch {
+    }
+  }
+}
+function promptPassword(prompt = "Password: ") {
+  const env = process.env.ARIES_WALLET_PASSWORD;
+  if (env !== void 0 && env.length > 0) return env;
+  return promptTty({ prompt, mask: true });
+}
+function promptText(prompt) {
+  return promptTty({ prompt, mask: false });
+}
+
+// src/actions/wallet/session/sessionCache.ts
+import { webcrypto as webcrypto3 } from "crypto";
+
+// src/actions/wallet/passwordKey.ts
+import { webcrypto } from "crypto";
+var subtle = webcrypto.subtle;
+var INITIALIZATION_VECTOR_LENGTH = 12;
+var PBKDF2_ITERATIONS = 1e5;
+var SALT_BYTES = 16;
+var PasswordKey = class _PasswordKey {
+  password;
+  salt;
+  constructor(password, salt = _PasswordKey.generateSalt()) {
+    this.password = password;
+    this.salt = salt;
+  }
+  static async decryptString(key, data) {
+    const encryptedData = new Uint8Array(Buffer.from(data, "base64"));
+    const iv = encryptedData.slice(0, INITIALIZATION_VECTOR_LENGTH);
+    const ciphertext = encryptedData.slice(INITIALIZATION_VECTOR_LENGTH);
+    const decrypted = await subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext);
+    return new TextDecoder("utf-8").decode(decrypted);
+  }
+  static async encryptString(key, data) {
+    const iv = webcrypto.getRandomValues(new Uint8Array(INITIALIZATION_VECTOR_LENGTH));
+    const ciphertext = await subtle.encrypt({ name: "AES-GCM", iv }, key, new TextEncoder().encode(data));
+    const combined = new Uint8Array(iv.length + ciphertext.byteLength);
+    combined.set(iv, 0);
+    combined.set(new Uint8Array(ciphertext), iv.length);
+    return Buffer.from(combined).toString("base64");
+  }
+  static generateSalt() {
+    const array = new Uint8Array(SALT_BYTES);
+    webcrypto.getRandomValues(array);
+    return [...array].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  static async getHashFromKey(key) {
+    const exported = await subtle.exportKey("raw", key);
+    const digest = await subtle.digest("SHA-256", exported);
+    return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  }
+  static async importEncryptionKey(rawKey) {
+    return await subtle.importKey("raw", rawKey, { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
+  }
+  static async importExtractableKey(rawKey) {
+    return await subtle.importKey("raw", rawKey, { name: "AES-GCM" }, true, ["encrypt", "decrypt"]);
+  }
+  static async serializeKey(key, salt = _PasswordKey.generateSalt()) {
+    const hash = await _PasswordKey.getHashFromKey(key);
+    return { hash, salt };
+  }
+  async deriveKey() {
+    const encoder = new TextEncoder();
+    const passphraseKey = await subtle.importKey(
+      "raw",
+      encoder.encode(this.password),
+      { name: "PBKDF2" },
+      false,
+      ["deriveKey"]
+    );
+    return await subtle.deriveKey(
+      {
+        name: "PBKDF2",
+        salt: encoder.encode(this.salt),
+        iterations: PBKDF2_ITERATIONS,
+        hash: "SHA-256"
+      },
+      passphraseKey,
+      { name: "AES-GCM", length: 256 },
+      true,
+      ["encrypt", "decrypt"]
+    );
+  }
+};
+async function encryptWithKey(key, data) {
+  const exported = await subtle.exportKey("raw", key);
+  const encKey = await PasswordKey.importEncryptionKey(exported);
+  return await PasswordKey.encryptString(encKey, data);
+}
+async function decryptWithKey(key, data) {
+  const exported = await subtle.exportKey("raw", key);
+  const encKey = await PasswordKey.importEncryptionKey(exported);
+  return await PasswordKey.decryptString(encKey, data);
+}
+
+// src/actions/wallet/session/machineId.ts
+import { webcrypto as webcrypto2 } from "crypto";
+import FS2 from "fs";
+import OS2 from "os";
+function generateMachineSecret() {
+  const bytes = new Uint8Array(32);
+  webcrypto2.getRandomValues(bytes);
+  return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function loadMachineSecret() {
+  ensureWalletDir();
+  const path = walletPaths().machineId;
+  if (FS2.existsSync(path)) {
+    return FS2.readFileSync(path, "utf8").trim();
+  }
+  const secret = generateMachineSecret();
+  FS2.writeFileSync(path, `${secret}
+`, { mode: 384 });
+  try {
+    FS2.chmodSync(path, 384);
+  } catch {
+  }
+  return secret;
+}
+async function deriveMachineKey() {
+  const secret = loadMachineSecret();
+  const stable = `${OS2.hostname()}:${OS2.userInfo().username}:${secret}`;
+  const passwordKey = new PasswordKey(stable, "aries-wallet-machine-kek-v1");
+  return await passwordKey.deriveKey();
+}
+
+// src/actions/wallet/session/sessionCache.ts
+var subtle2 = webcrypto3.subtle;
+var DEFAULT_SESSION_TTL_SECONDS = 15 * 60;
+async function unlockSession(passwordKey, ttlSeconds = DEFAULT_SESSION_TTL_SECONDS) {
+  const machineKey = await deriveMachineKey();
+  const exported = await subtle2.exportKey("raw", passwordKey);
+  const exportedBase64 = Buffer.from(new Uint8Array(exported)).toString("base64");
+  const encryptedKey = await encryptWithKey(machineKey, exportedBase64);
+  const expiresAt = Date.now() + ttlSeconds * 1e3;
+  const data = { encryptedKey, expiresAt };
+  writeJsonFile(walletPaths().session, data);
+  return expiresAt;
+}
+function lockSession() {
+  deleteFile(walletPaths().session);
+}
+async function readSession() {
+  const data = readJsonFile(walletPaths().session);
+  if (!data) return void 0;
+  if (data.expiresAt <= Date.now()) {
+    lockSession();
+    return void 0;
+  }
+  try {
+    const machineKey = await deriveMachineKey();
+    const exportedBase64 = await decryptWithKey(machineKey, data.encryptedKey);
+    const raw = Buffer.from(exportedBase64, "base64");
+    return await PasswordKey.importExtractableKey(
+      raw.buffer.slice(raw.byteOffset, raw.byteOffset + raw.byteLength)
+    );
+  } catch {
+    lockSession();
+    return void 0;
+  }
+}
+
+// src/actions/wallet/password/passwordStorage.ts
+function readPassword() {
+  return readJsonFile(walletPaths().password);
+}
+function writePassword(values) {
+  writeJsonFile(walletPaths().password, values);
+}
+function hasPassword() {
+  return readPassword() !== void 0;
+}
+
+// src/actions/wallet/password/validatePassword.ts
+async function validatePassword(password) {
+  const stored = readPassword();
+  if (!stored) return void 0;
+  const passwordKey = new PasswordKey(password, stored.salt);
+  const key = await passwordKey.deriveKey();
+  const hash = await PasswordKey.getHashFromKey(key);
+  if (hash !== stored.hash) return void 0;
+  return key;
+}
+
+// src/actions/wallet/password/getActiveKey.ts
+async function getActiveKey() {
+  if (!hasPassword()) {
+    throw new Error("Wallet not initialized. Run `aries wallet create` or `aries wallet import` first.");
+  }
+  const cached = await readSession();
+  if (cached) return cached;
+  const password = promptPassword("Wallet password: ");
+  const key = await validatePassword(password);
+  if (!key) throw new Error("Incorrect password.");
+  return key;
+}
+
+// src/actions/wallet/seedPhrase/phraseStorage.ts
+function readPhrases() {
+  const data = readJsonFile(walletPaths().phrases);
+  return data?.phrases ?? [];
+}
+function writePhrases(phrases) {
+  writeJsonFile(walletPaths().phrases, { phrases });
+}
+function readActive() {
+  return readJsonFile(walletPaths().active) ?? {};
+}
+function writeActive(active) {
+  writeJsonFile(walletPaths().active, active);
+}
+function findPhrase(id) {
+  return readPhrases().find((p) => p.id === id || p.label === id);
+}
+function getActivePhrase() {
+  const phrases = readPhrases();
+  if (phrases.length === 0) return void 0;
+  const active = readActive();
+  if (active.phraseId) {
+    const found = phrases.find((p) => p.id === active.phraseId);
+    if (found) return found;
+  }
+  return phrases[0];
+}
+
+// src/actions/wallet/account/getActiveWallet.ts
+async function getActiveWallet() {
+  const record = getActivePhrase();
+  if (!record) throw new Error("No active wallet. Run `aries wallet create` or `aries wallet import` first.");
+  const key = await getActiveKey();
+  const mnemonic = await decryptWithKey(key, record.encryptedPhrase);
+  const rootWallet = await HDWallet.fromPhrase(mnemonic, DEFAULT_WALLET_PATH);
+  return {
+    record,
+    mnemonic,
+    rootWallet
+  };
+}
+async function deriveAccount(rootWallet, offset) {
+  return await rootWallet.derivePath(offset);
+}
+
+// src/actions/wallet/account/deriveAndAdd.ts
+async function deriveAndAdd(options) {
+  const { rootWallet } = await getActiveWallet();
+  const account = await deriveAccount(rootWallet, options.offset);
+  upsertAddressBookEntry(rootWallet.address, { offset: options.offset, label: options.label });
+  console.log(chalk.green(`Derived account at offset ${chalk.cyan(options.offset)}: 0x${account.address}`));
+  if (options.label) console.log(chalk.gray(`  label: ${options.label}`));
+}
+
+// src/actions/wallet/account/labelAccount.ts
+import chalk2 from "chalk";
+async function labelAccount(offset, label) {
+  const { rootWallet } = await getActiveWallet();
+  upsertAddressBookEntry(rootWallet.address, { offset, label });
+  console.log(chalk2.green(`Labeled account ${chalk2.cyan(offset)} as ${chalk2.white(label)}`));
+}
+
+// src/actions/wallet/account/listAccounts.ts
+import chalk3 from "chalk";
+async function listAccounts() {
+  const { record, rootWallet } = await getActiveWallet();
+  const book = readAddressBook(rootWallet.address);
+  console.log(chalk3.cyan(`Wallet ${record.label} (${record.id})`));
+  console.log(chalk3.gray(`  root: ${rootWallet.address}`));
+  console.log();
+  if (book.entries.length === 0) {
+    console.log(chalk3.gray("  No derived accounts. Run `aries wallet account derive <offset>`."));
+    return;
+  }
+  for (const entry of book.entries) {
+    const account = await deriveAccount(rootWallet, entry.offset);
+    const offset = chalk3.cyan(entry.offset.padEnd(6));
+    const label = chalk3.white((entry.label ?? "").padEnd(20));
+    console.log(`  ${offset} ${label} 0x${account.address}`);
+  }
+}
+
+// src/actions/wallet/account/removeAccount.ts
+import chalk4 from "chalk";
+async function removeAccount(offset) {
+  const { rootWallet } = await getActiveWallet();
+  removeAddressBookEntry(rootWallet.address, offset);
+  console.log(chalk4.green(`Removed account at offset ${chalk4.cyan(offset)} from address book`));
+}
+
+// src/actions/wallet/account/showAccount.ts
+import chalk5 from "chalk";
+async function showAccount(offset) {
+  const { rootWallet } = await getActiveWallet();
+  const book = readAddressBook(rootWallet.address);
+  const entry = book.entries.find((e) => e.offset === offset);
+  const account = await deriveAccount(rootWallet, offset);
+  console.log(chalk5.cyan(`Account ${offset}`));
+  console.log(`  ${chalk5.gray("label:")}    ${entry?.label ?? "\u2014"}`);
+  console.log(`  ${chalk5.gray("address:")}  0x${account.address}`);
+  if (account.public) console.log(`  ${chalk5.gray("public:")}   ${account.public.hex}`);
+  console.log(`  ${chalk5.gray("path:")}     ${offset}`);
+}
+
+// src/actions/wallet/backup/exportBackup.ts
+import FS3 from "fs";
+import chalk6 from "chalk";
+
+// src/actions/wallet/contact/storage.ts
+var CONTACTS_VERSION = 1;
+function readContacts() {
+  return readJsonFile(walletPaths().contacts) ?? {
+    entries: [],
+    version: CONTACTS_VERSION
+  };
+}
+function writeContacts(file) {
+  writeJsonFile(walletPaths().contacts, file);
+}
+
+// src/actions/wallet/backup/exportBackup.ts
+var SCHEMA = "network.xyo.wallet.backup";
+var VERSION = 1;
+var ADDRESS_BOOK_SCHEMA = "network.xyo.wallet.addressBook";
+var CONTACTS_SCHEMA = "network.xyo.wallet.contacts";
+function exportBackup(options) {
+  const exportedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const entries = [];
+  const sources = [];
+  const addressBooks = readAllAddressBooks();
+  for (const book of Object.values(addressBooks)) {
+    entries.push({
+      ...book,
+      schema: ADDRESS_BOOK_SCHEMA,
+      exportedAt
+    });
+    if (!sources.includes(ADDRESS_BOOK_SCHEMA)) sources.push(ADDRESS_BOOK_SCHEMA);
+  }
+  const contacts = readContacts();
+  if (contacts.entries.length > 0) {
+    entries.push({
+      ...contacts,
+      schema: CONTACTS_SCHEMA,
+      exportedAt
+    });
+    sources.push(CONTACTS_SCHEMA);
+  }
+  const backup = {
+    schema: SCHEMA,
+    version: VERSION,
+    entries,
+    exportedAt,
+    sources
+  };
+  FS3.writeFileSync(options.file, `${JSON.stringify(backup, null, 2)}
+`, { mode: 384 });
+  console.log(chalk6.green(`Backup written to ${options.file}`));
+  console.log(chalk6.gray(`  ${entries.length} entries, sources: ${sources.join(", ")}`));
+}
+
+// src/actions/wallet/backup/importBackup.ts
+import FS4 from "fs";
+import chalk7 from "chalk";
+function importBackup(options) {
+  const raw = FS4.readFileSync(options.file, "utf8");
+  const parsed = JSON.parse(raw);
+  if (parsed.schema !== "network.xyo.wallet.backup") {
+    throw new Error(`Not a wallet backup (schema=${parsed.schema}).`);
+  }
+  const allBooks = readAllAddressBooks();
+  let booksImported = 0;
+  let contactsImported = 0;
+  const existingContacts = readContacts();
+  for (const entry of parsed.entries) {
+    if (entry.schema === "network.xyo.wallet.addressBook") {
+      const book = entry;
+      const key = book.rootAddress.toLowerCase();
+      const merged = allBooks[key] ? mergeAddressBooks(allBooks[key], book) : {
+        rootAddress: key,
+        entries: book.entries,
+        version: book.version
+      };
+      allBooks[key] = merged;
+      booksImported++;
+    } else if (entry.schema === "network.xyo.wallet.contacts") {
+      const contacts = entry;
+      for (const contact of contacts.entries) {
+        upsertContact(existingContacts, contact);
+        contactsImported++;
+      }
+    }
+  }
+  if (booksImported > 0) writeAllAddressBooks(allBooks);
+  if (contactsImported > 0) writeContacts(existingContacts);
+  console.log(chalk7.green(`Imported backup from ${options.file}`));
+  console.log(chalk7.gray(`  address books: ${booksImported}, contacts: ${contactsImported}`));
+}
+function mergeAddressBooks(existing, incoming) {
+  const merged = {
+    rootAddress: existing.rootAddress,
+    version: Math.max(existing.version, incoming.version),
+    entries: [...existing.entries]
+  };
+  for (const entry of incoming.entries) {
+    const found = merged.entries.find((e) => e.offset === entry.offset);
+    if (found) {
+      if (entry.label !== void 0) found.label = entry.label;
+    } else {
+      merged.entries.push(entry);
+    }
+  }
+  return merged;
+}
+function upsertContact(file, contact) {
+  const normalized = contact.address.toLowerCase();
+  const found = file.entries.find((e) => e.address.toLowerCase() === normalized);
+  if (found) {
+    found.label = contact.label;
+    found.updatedAt = contact.updatedAt;
+  } else {
+    file.entries.push({ ...contact, address: normalized });
+  }
+}
+
+// src/actions/wallet/balance/getBalance.ts
+import { XL1Amount } from "@xyo-network/xl1-protocol-sdk";
+import chalk8 from "chalk";
+
+// src/actions/wallet/client/walletClient.ts
+import {
+  basicRemoteViewerLocator,
+  ProviderFactoryLocator,
+  SimpleXyoConnectionRunner,
+  SimpleXyoGatewayRunner,
+  SimpleXyoRunner,
+  SimpleXyoSigner,
+  XyoGatewayRunnerMoniker,
+  XyoRunnerMoniker,
+  XyoViewerMoniker
+} from "@xyo-network/xl1-sdk";
+async function loadValidators() {
+  try {
+    const mod = await import("@xyo-network/chain-validation");
+    return {
+      validateHydratedBlock: mod.validateHydratedBlock,
+      validateHydratedBlockState: mod.validateHydratedBlockState
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function createReadOnlyClient(rpcUrl) {
+  const validators = await loadValidators();
+  const viewerLocator = await basicRemoteViewerLocator(
+    "aries-wallet-readonly",
+    { rpc: { protocol: "http", url: rpcUrl } },
+    void 0,
+    validators ? { validators } : void 0
+  );
+  const viewer = await viewerLocator.getInstance(XyoViewerMoniker);
+  return { viewer, locator: viewerLocator };
+}
+async function createWalletClient(rpcUrl, account) {
+  const validators = await loadValidators();
+  const viewerLocator = await basicRemoteViewerLocator(
+    "aries-wallet",
+    { rpc: { protocol: "http", url: rpcUrl } },
+    void 0,
+    validators ? { validators } : void 0
+  );
+  const locator = new ProviderFactoryLocator(viewerLocator.context, {});
+  locator.register(SimpleXyoSigner.factory(SimpleXyoSigner.dependencies, { account }));
+  locator.register(SimpleXyoGatewayRunner.factory(SimpleXyoGatewayRunner.dependencies, {}));
+  locator.register(SimpleXyoRunner.factory(SimpleXyoRunner.dependencies, {}));
+  locator.register(SimpleXyoConnectionRunner.factory(SimpleXyoConnectionRunner.dependencies, {}));
+  locator.validateDependencies();
+  const gateway = await locator.getInstance(XyoGatewayRunnerMoniker);
+  const runner = await locator.getInstance(XyoRunnerMoniker);
+  const viewer = await locator.getInstance(XyoViewerMoniker);
+  return {
+    gateway,
+    runner,
+    viewer,
+    connection: gateway.connection,
+    locator
+  };
+}
+
+// src/actions/wallet/network/storage.ts
+var DEFAULT_NETWORKS = [
+  {
+    id: "xl1-mainnet",
+    label: "XL1 Mainnet",
+    rpcUrl: "https://node.xyo.network",
+    isCustom: false
+  },
+  {
+    id: "xl1-testnet",
+    label: "XL1 Testnet",
+    rpcUrl: "https://testnet.node.xyo.network",
+    isCustom: false
+  }
+];
+function readNetworks() {
+  const data = readJsonFile(walletPaths().networks);
+  if (data) return data;
+  const seeded = {
+    networks: DEFAULT_NETWORKS,
+    activeId: DEFAULT_NETWORKS[0].id
+  };
+  writeJsonFile(walletPaths().networks, seeded);
+  return seeded;
+}
+function writeNetworks(file) {
+  writeJsonFile(walletPaths().networks, file);
+}
+function getActiveNetwork() {
+  const file = readNetworks();
+  const found = file.networks.find((n) => n.id === file.activeId);
+  if (!found) throw new Error(`Active network ${file.activeId} not found.`);
+  return found;
+}
+
+// src/actions/wallet/balance/getBalance.ts
+async function getBalance(options = {}) {
+  const offset = options.offset ?? "0";
+  const { rootWallet } = await getActiveWallet();
+  const account = await deriveAccount(rootWallet, offset);
+  const network = getActiveNetwork();
+  const { viewer } = await createReadOnlyClient(network.rpcUrl);
+  const atto = await viewer.account.balance.accountBalance(account.address);
+  const display = new XL1Amount(atto).toString();
+  console.log(`${chalk8.cyan("balance:")} ${display} XL1`);
+  console.log(`${chalk8.gray("atto:")}    ${atto}`);
+  console.log(`${chalk8.gray("address:")} 0x${account.address}`);
+  console.log(`${chalk8.gray("network:")} ${network.id} (${network.rpcUrl})`);
+}
+
+// src/actions/wallet/contact/contactActions.ts
+import chalk9 from "chalk";
+function normalize(address) {
+  return address.toLowerCase();
+}
+function listContacts() {
+  const file = readContacts();
+  if (file.entries.length === 0) {
+    console.log(chalk9.gray("No contacts. Run `aries wallet contact add <address> <label>` to add one."));
+    return;
+  }
+  for (const entry of file.entries) {
+    console.log(`  ${chalk9.white(entry.label.padEnd(20))} ${entry.address}`);
+  }
+}
+function addContact(address, label) {
+  const file = readContacts();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const normalized = normalize(address);
+  const existing = file.entries.find((e) => normalize(e.address) === normalized);
+  if (existing) {
+    existing.label = label;
+    existing.updatedAt = now;
+  } else {
+    file.entries.push({
+      address: normalized,
+      label,
+      createdAt: now,
+      updatedAt: now
+    });
+  }
+  writeContacts(file);
+  console.log(chalk9.green(`Saved contact ${chalk9.cyan(label)} (${normalized})`));
+}
+function renameContact(address, label) {
+  addContact(address, label);
+}
+function removeContact(address) {
+  const file = readContacts();
+  const normalized = normalize(address);
+  const before = file.entries.length;
+  file.entries = file.entries.filter((e) => normalize(e.address) !== normalized);
+  if (file.entries.length === before) throw new Error(`Contact not found: ${address}`);
+  writeContacts(file);
+  console.log(chalk9.green(`Removed contact ${normalized}`));
+}
+
+// src/actions/wallet/network/networkActions.ts
+import chalk10 from "chalk";
+function listNetworks() {
+  const file = readNetworks();
+  for (const network of file.networks) {
+    const marker = network.id === file.activeId ? chalk10.green("* ") : "  ";
+    const id = chalk10.cyan(network.id.padEnd(20));
+    const label = chalk10.white(network.label.padEnd(20));
+    const custom = network.isCustom ? chalk10.gray("(custom)") : "";
+    console.log(`${marker}${id} ${label} ${network.rpcUrl} ${custom}`);
+  }
+}
+function useNetwork(id) {
+  const file = readNetworks();
+  const found = file.networks.find((n) => n.id === id);
+  if (!found) throw new Error(`Network not found: ${id}`);
+  file.activeId = id;
+  writeNetworks(file);
+  console.log(chalk10.green(`Active network set to ${chalk10.cyan(id)}`));
+}
+function addNetwork(options) {
+  const file = readNetworks();
+  if (file.networks.some((n) => n.id === options.id)) {
+    throw new Error(`Network already exists: ${options.id}`);
+  }
+  const record = {
+    id: options.id,
+    label: options.label ?? options.id,
+    rpcUrl: options.rpcUrl,
+    chainId: options.chainId,
+    isCustom: true
+  };
+  file.networks.push(record);
+  writeNetworks(file);
+  console.log(chalk10.green(`Added network ${chalk10.cyan(options.id)} (${options.rpcUrl})`));
+}
+function removeNetwork(id) {
+  const file = readNetworks();
+  const target = file.networks.find((n) => n.id === id);
+  if (!target) throw new Error(`Network not found: ${id}`);
+  if (!target.isCustom) throw new Error(`Cannot remove built-in network: ${id}`);
+  file.networks = file.networks.filter((n) => n.id !== id);
+  if (file.activeId === id) file.activeId = file.networks[0]?.id ?? "";
+  writeNetworks(file);
+  console.log(chalk10.green(`Removed network ${chalk10.cyan(id)}`));
+}
+
+// src/actions/wallet/password/changePassword.ts
+import chalk11 from "chalk";
+async function changePassword() {
+  const current = promptPassword("Current password: ");
+  const oldKey = await validatePassword(current);
+  if (!oldKey) throw new Error("Incorrect password.");
+  const next = promptPassword("New password: ");
+  const confirmed = promptPassword("Confirm new password: ");
+  if (next !== confirmed) throw new Error("Passwords do not match.");
+  if (next.length === 0) throw new Error("Password cannot be empty.");
+  const salt = PasswordKey.generateSalt();
+  const newKey = await new PasswordKey(next, salt).deriveKey();
+  const phrases = readPhrases();
+  for (const phrase of phrases) {
+    const mnemonic = await decryptWithKey(oldKey, phrase.encryptedPhrase);
+    phrase.encryptedPhrase = await encryptWithKey(newKey, mnemonic);
+  }
+  writePhrases(phrases);
+  writePassword(await PasswordKey.serializeKey(newKey, salt));
+  lockSession();
+  console.log(chalk11.green("Password changed. Re-unlock to start a new session."));
+}
+
+// src/actions/wallet/seedPhrase/createPhrase.ts
+import { HDWallet as HDWallet2 } from "@xyo-network/sdk-js";
+import chalk12 from "chalk";
+
+// src/actions/wallet/password/setPassword.ts
+async function setPassword(password) {
+  if (password.length === 0) throw new Error("Password cannot be empty");
+  const salt = PasswordKey.generateSalt();
+  const passwordKey = new PasswordKey(password, salt);
+  const key = await passwordKey.deriveKey();
+  const values = await PasswordKey.serializeKey(key, salt);
+  writePassword(values);
+  return { key, salt };
+}
+
+// src/actions/wallet/password/initOrUnlock.ts
+async function initOrUnlock() {
+  if (hasPassword()) return await getActiveKey();
+  const fromEnv = process.env.ARIES_WALLET_PASSWORD;
+  if (fromEnv !== void 0 && fromEnv.length > 0) {
+    const { key: key2 } = await setPassword(fromEnv);
+    return key2;
+  }
+  const password = promptPassword("Set wallet password: ");
+  const confirmed = promptPassword("Confirm password: ");
+  if (password !== confirmed) throw new Error("Passwords do not match.");
+  const { key } = await setPassword(password);
+  return key;
+}
+
+// src/actions/wallet/seedPhrase/idGen.ts
+import { webcrypto as webcrypto4 } from "crypto";
+function generatePhraseId() {
+  const bytes = new Uint8Array(8);
+  webcrypto4.getRandomValues(bytes);
+  return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/actions/wallet/seedPhrase/createPhrase.ts
+async function createPhrase(options) {
+  const key = await initOrUnlock();
+  const mnemonic = HDWallet2.generateMnemonic();
+  const encryptedPhrase = await encryptWithKey(key, mnemonic);
+  const record = {
+    id: generatePhraseId(),
+    label: options.label,
+    walletKind: "user",
+    encryptedPhrase,
+    createdAt: Date.now()
+  };
+  const phrases = readPhrases();
+  phrases.push(record);
+  writePhrases(phrases);
+  if (phrases.length === 1) writeActive({ phraseId: record.id });
+  console.log(chalk12.green(`Created wallet ${chalk12.cyan(record.label)} (id ${record.id})`));
+  console.log();
+  console.log(chalk12.yellow("Recovery phrase \u2014 write this down and store it safely:"));
+  console.log();
+  console.log(`  ${chalk12.white(mnemonic)}`);
+  console.log();
+  console.log(chalk12.gray("You will not be shown this phrase again unless you run `aries wallet export`."));
+  return record;
+}
+
+// src/actions/wallet/seedPhrase/exportPhrase.ts
+import chalk13 from "chalk";
+async function exportPhrase(options = {}) {
+  const record = options.id ? findPhrase(options.id) : getActivePhrase();
+  if (!record) throw new Error("Wallet not found.");
+  const key = await getActiveKey();
+  const mnemonic = await decryptWithKey(key, record.encryptedPhrase);
+  console.log(chalk13.yellow(`Recovery phrase for ${chalk13.cyan(record.label)} (id ${record.id}):`));
+  console.log();
+  console.log(`  ${chalk13.white(mnemonic)}`);
+  return mnemonic;
+}
+
+// src/actions/wallet/seedPhrase/importPhrase.ts
+import { HDWallet as HDWallet3 } from "@xyo-network/sdk-js";
+import chalk14 from "chalk";
+async function importPhrase(options) {
+  const key = await initOrUnlock();
+  const mnemonic = (options.phrase ?? promptText("Recovery phrase: ")).trim();
+  if (mnemonic.split(/\s+/).length < 12) {
+    throw new Error("Recovery phrase must be at least 12 words.");
+  }
+  await HDWallet3.fromPhrase(mnemonic);
+  const encryptedPhrase = await encryptWithKey(key, mnemonic);
+  const record = {
+    id: generatePhraseId(),
+    label: options.label,
+    walletKind: "user",
+    encryptedPhrase,
+    createdAt: Date.now()
+  };
+  const phrases = readPhrases();
+  phrases.push(record);
+  writePhrases(phrases);
+  if (phrases.length === 1) writeActive({ phraseId: record.id });
+  console.log(chalk14.green(`Imported wallet ${chalk14.cyan(record.label)} (id ${record.id})`));
+  return record;
+}
+
+// src/actions/wallet/seedPhrase/listPhrases.ts
+import chalk15 from "chalk";
+function listPhrases() {
+  const phrases = readPhrases();
+  if (phrases.length === 0) {
+    console.log(chalk15.gray("No wallets. Run `aries wallet create` or `aries wallet import` to add one."));
+    return;
+  }
+  const active = readActive();
+  for (const phrase of phrases) {
+    const marker = phrase.id === active.phraseId ? chalk15.green("* ") : "  ";
+    const created = new Date(phrase.createdAt).toISOString();
+    console.log(`${marker}${chalk15.cyan(phrase.label.padEnd(20))} ${chalk15.gray(phrase.id)}  ${chalk15.gray(created)}`);
+  }
+}
+
+// src/actions/wallet/seedPhrase/removePhrase.ts
+import { HDWallet as HDWallet4 } from "@xyo-network/sdk-js";
+import { DEFAULT_WALLET_PATH as DEFAULT_WALLET_PATH2 } from "@xyo-network/xl1-protocol-sdk";
+import chalk16 from "chalk";
+async function removePhrase(options) {
+  const phrases = readPhrases();
+  const target = phrases.find((p) => p.id === options.id || p.label === options.id);
+  if (!target) throw new Error(`Wallet not found: ${options.id}`);
+  try {
+    const key = await getActiveKey();
+    const mnemonic = await decryptWithKey(key, target.encryptedPhrase);
+    const root = await HDWallet4.fromPhrase(mnemonic, DEFAULT_WALLET_PATH2);
+    removeAddressBook(root.address);
+  } catch (e) {
+    console.warn(chalk16.yellow(`Warning: failed to clean up address book: ${e.message}`));
+  }
+  const remaining = phrases.filter((p) => p.id !== target.id);
+  writePhrases(remaining);
+  const active = readActive();
+  if (active.phraseId === target.id) {
+    writeActive({ ...active, phraseId: remaining[0]?.id });
+  }
+  console.log(chalk16.green(`Removed wallet ${chalk16.cyan(target.label)} (id ${target.id})`));
+}
+
+// src/actions/wallet/seedPhrase/renamePhrase.ts
+import chalk17 from "chalk";
+function renamePhrase(id, label) {
+  const phrases = readPhrases();
+  const target = phrases.find((p) => p.id === id || p.label === id);
+  if (!target) throw new Error(`Wallet not found: ${id}`);
+  target.label = label;
+  writePhrases(phrases);
+  console.log(chalk17.green(`Renamed wallet ${target.id} to ${chalk17.cyan(label)}`));
+}
+
+// src/actions/wallet/seedPhrase/usePhrase.ts
+import chalk18 from "chalk";
+function usePhrase(id) {
+  const record = findPhrase(id);
+  if (!record) throw new Error(`Wallet not found: ${id}`);
+  const active = readActive();
+  writeActive({ ...active, phraseId: record.id });
+  console.log(chalk18.green(`Active wallet set to ${chalk18.cyan(record.label)} (id ${record.id})`));
+}
+
+// src/actions/wallet/session/unlock.ts
+import chalk19 from "chalk";
+async function unlock(options = {}) {
+  if (!hasPassword()) {
+    throw new Error("Wallet not initialized. Run `aries wallet create` or `aries wallet import` first.");
+  }
+  const password = promptPassword("Wallet password: ");
+  const key = await validatePassword(password);
+  if (!key) throw new Error("Incorrect password.");
+  const ttl = options.ttl ?? DEFAULT_SESSION_TTL_SECONDS;
+  const expiresAt = await unlockSession(key, ttl);
+  console.log(chalk19.green(`Wallet unlocked. Session expires ${new Date(expiresAt).toISOString()}.`));
+}
+function lock() {
+  lockSession();
+  console.log(chalk19.green("Wallet locked."));
+}
+
+// src/actions/wallet/sign/signPayload.ts
+import FS5 from "fs";
+
+// ../../node_modules/.pnpm/@xyo-network+boundwitness-builder@5.5.2_@bitauth+libauth@3.0.0_@scure+base@2.2.0_@xylab_4c4b2704d625c906bfa16bd14f65b27b/node_modules/@xyo-network/boundwitness-builder/dist/neutral/index.mjs
+import {
+  asAddress,
+  asHash,
+  assertEx,
+  hexFromArrayBuffer,
+  toArrayBuffer
+} from "@xylabs/sdk-js";
+
+// ../../node_modules/.pnpm/@xyo-network+boundwitness-model@5.5.2_@xylabs+sdk-js@5.0.101_@opentelemetry+api@1.9.1_@_815cc9f8526e164e787cddfcee3cd298/node_modules/@xyo-network/boundwitness-model/dist/neutral/index.mjs
+import {
+  AddressZod,
+  HashZod,
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk-js";
+import { PayloadZod, SchemaZod } from "@xyo-network/payload-model";
+import z2 from "zod";
+import { asSchema } from "@xyo-network/payload-model";
+import { HexZod } from "@xylabs/sdk-js";
+import z from "zod";
+import { PayloadZod as PayloadZod2 } from "@xyo-network/payload-model";
+import z3 from "zod";
+import { isStorageMeta } from "@xyo-network/payload-model";
+var BoundWitnessSchema = asSchema("network.xyo.boundwitness", true);
+var SignaturesMetaZod = z.object({ $signatures: z.array(z.union([HexZod, z.null()])) });
+var UnsignedSignaturesMetaZod = z.object({ $signatures: z.array(z.null()) });
+var SignedSignaturesMetaZod = z.object({ $signatures: z.array(HexZod).min(1) });
+var BoundWitnessRequiredFieldsZod = z2.object({
+  addresses: z2.array(AddressZod),
+  payload_hashes: z2.array(HashZod),
+  payload_schemas: z2.array(SchemaZod),
+  previous_hashes: z2.array(HashZod.nullable())
+});
+var BoundWitnessMetaZod = z2.object({
+  $destination: AddressZod.optional(),
+  $sourceQuery: HashZod.optional()
+}).extend(SignaturesMetaZod.shape);
+var BoundWitnessZod = PayloadZod.safeExtend({ schema: z2.literal(BoundWitnessSchema) }).safeExtend(BoundWitnessRequiredFieldsZod.shape).safeExtend(BoundWitnessMetaZod.shape);
+var isBoundWitness = zodIsFactory(BoundWitnessZod);
+var asBoundWitness = zodAsFactory(BoundWitnessZod, "asBoundWitness");
+var toBoundWitness = zodToFactory(BoundWitnessZod, "toBoundWitness");
+var AnyBoundWitnessZod = BoundWitnessZod.loose();
+var SignedBoundWitnessZod = BoundWitnessZod.extend(SignedSignaturesMetaZod.shape);
+var AnySignedBoundWitnessZod = SignedBoundWitnessZod.loose();
+var UnsignedBoundWitnessZod = BoundWitnessZod.extend(UnsignedSignaturesMetaZod.shape);
+var AnyUnsignedBoundWitnessZod = UnsignedBoundWitnessZod.loose();
+function HydratedBoundWitnessZodBuilder(bwZod) {
+  return z3.tuple([bwZod, z3.array(PayloadZod2.loose())]);
+}
+var HydratedBoundWitnessZod = HydratedBoundWitnessZodBuilder(BoundWitnessZod);
+var SignedHydratedBoundWitnessZod = HydratedBoundWitnessZodBuilder(SignedBoundWitnessZod);
+var UnsignedHydratedBoundWitnessZod = HydratedBoundWitnessZodBuilder(UnsignedBoundWitnessZod);
+
+// ../../node_modules/.pnpm/@xyo-network+boundwitness-builder@5.5.2_@bitauth+libauth@3.0.0_@scure+base@2.2.0_@xylab_4c4b2704d625c906bfa16bd14f65b27b/node_modules/@xyo-network/boundwitness-builder/dist/neutral/index.mjs
+import {
+  ObjectHasher,
+  removeEmptyFields,
+  sortFields
+} from "@xyo-network/hash";
+import { omitSchema, PayloadBuilder } from "@xyo-network/payload-builder";
+import { Mutex } from "async-mutex";
+import {
+  asHash as asHash2,
+  difference,
+  exists
+} from "@xylabs/sdk-js";
+import { PayloadBuilder as PayloadBuilder2 } from "@xyo-network/payload-builder";
+import { asHash as asHash3 } from "@xylabs/sdk-js";
+import { assertEx as assertEx2 } from "@xylabs/sdk-js";
+var GeneratedBoundWitnessFields = ["addresses", "payload_hashes", "payload_schemas", "previous_hashes"];
+var uniqueAddresses = (addresses, throwOnFalse = false) => {
+  const addressesSet = /* @__PURE__ */ new Set();
+  for (const address of addresses) {
+    if (addressesSet.has(address)) {
+      if (throwOnFalse) {
+        throw new Error("Duplicate address");
+      }
+      return false;
+    }
+    addressesSet.add(address);
+  }
+  return true;
+};
+var uniqueAccounts = (accounts, throwOnFalse = false) => {
+  return uniqueAddresses(accounts.map((account) => account.address), throwOnFalse);
+};
+var BoundWitnessBuilder = class _BoundWitnessBuilder extends PayloadBuilder {
+  static _buildMutex = new Mutex();
+  _accounts = [];
+  _errorHashes;
+  _errors = [];
+  _payloadHashes;
+  _payloadSchemas;
+  _payloads = [];
+  constructor(options) {
+    super({ ...options, schema: BoundWitnessSchema });
+  }
+  get addresses() {
+    uniqueAccounts(this._accounts, true);
+    return this._accounts.map((account) => account.address.toLowerCase());
+  }
+  get payloadSchemas() {
+    return this._payloadSchemas ?? this._payloads.map((payload) => {
+      return assertEx(payload.schema, () => this.missingSchemaMessage(payload));
+    });
+  }
+  get previousHashBytes() {
+    return this._accounts.map((account) => account.previousHashBytes ?? null);
+  }
+  get previousHashes() {
+    return this._accounts.map((account) => account.previousHash ?? null);
+  }
+  static addressIndex(payload, address) {
+    const index = payload.addresses.indexOf(address);
+    if (index === -1) {
+      throw new Error("Invalid address");
+    }
+    return index;
+  }
+  static previousHash(boundWitness, address) {
+    return asHash(boundWitness.previous_hashes[this.addressIndex(boundWitness, address)])?.toLowerCase();
+  }
+  static async linkingFields(accounts, payloads) {
+    const addresses = accounts.map((account) => asAddress(hexFromArrayBuffer(account.addressBytes, { prefix: false }), true));
+    const previous_hashes = accounts.map((account) => account.previousHash ?? null);
+    const payload_hashes = payloads ? await _BoundWitnessBuilder.hashes(payloads) : [];
+    const payload_schemas = payloads?.map(({ schema }) => schema) ?? [];
+    return {
+      addresses,
+      payload_hashes,
+      payload_schemas,
+      previous_hashes
+    };
+  }
+  static signature(payload, address) {
+    return payload.$signatures[this.addressIndex(payload, address)];
+  }
+  static async signatures(accounts, dataHash) {
+    const hashBytes = toArrayBuffer(dataHash);
+    const previousHashesBytes = accounts?.map((account) => account.previousHashBytes);
+    return await Promise.all(accounts.map(async (account, index) => hexFromArrayBuffer((await account.sign(hashBytes, previousHashesBytes[index]))[0])));
+  }
+  static validateGeneratedFields(fields) {
+    assertEx(fields.payload_hashes?.length === fields.payload_schemas?.length, () => "Payload hash/schema mismatch");
+    assertEx(!fields.payload_hashes.includes(null), () => "nulls found in hashes");
+    assertEx(!fields.payload_schemas.includes(null), () => "nulls found in schemas");
+  }
+  async build(sign = true) {
+    return await _BoundWitnessBuilder._buildMutex.runExclusive(async () => {
+      const dataHashableFields = await this.dataHashableFields();
+      const $signatures = sign ? await this.sign() : this.addresses.map(() => null);
+      const ret = {
+        ...this._meta,
+        ...dataHashableFields,
+        ...this._fields,
+        $signatures
+      };
+      return [
+        ret,
+        this._payloads,
+        this._errors
+      ];
+    });
+  }
+  async dataHash() {
+    const dataHashableFields = await this.dataHashableFields();
+    const hash = await ObjectHasher.hash(dataHashableFields);
+    return hash;
+  }
+  async dataHashableFields() {
+    const generatedFields = await this.generatedFields();
+    _BoundWitnessBuilder.validateGeneratedFields(generatedFields);
+    const fields = {
+      ...PayloadBuilder.omitMeta(this._fields ?? {}),
+      ...generatedFields
+    };
+    return await _BoundWitnessBuilder.dataHashableFields(this._schema, fields);
+  }
+  error(payload) {
+    assertEx(this._errorHashes === void 0, () => "Can not set errors when hashes already set");
+    if (payload) {
+      this._errors.push(assertEx(sortFields(payload)));
+    }
+    return this;
+  }
+  errors(errors) {
+    if (errors) {
+      for (const error of errors) {
+        if (error !== null) {
+          this.error(error);
+        }
+      }
+    }
+    return this;
+  }
+  fields(fields) {
+    const clone = structuredClone(fields);
+    for (const field of GeneratedBoundWitnessFields) {
+      delete clone[field];
+    }
+    this._fields = _BoundWitnessBuilder.omitStorageMeta(
+      _BoundWitnessBuilder.omitClientMeta(
+        omitSchema(removeEmptyFields(clone))
+      )
+    );
+    return this;
+  }
+  hashes(hashes, schema) {
+    assertEx(this.payloads.length === 0, () => "Can not set hashes when payloads already set");
+    this._payloadHashes = hashes;
+    this._payloadSchemas = schema;
+    return this;
+  }
+  payload(payload) {
+    assertEx(this._payloadHashes === void 0, () => "Can not set payloads when hashes already set");
+    if (payload) {
+      this._payloads.push(assertEx(sortFields(payload)));
+    }
+    return this;
+  }
+  payloads(payloads) {
+    if (payloads)
+      for (const payload of payloads) {
+        if (payload !== null) {
+          this.payload(payload);
+        }
+      }
+    return this;
+  }
+  signer(account) {
+    uniqueAccounts([...this._accounts, account], true);
+    this._accounts?.push(account);
+    return this;
+  }
+  signers(accounts) {
+    uniqueAccounts([...this._accounts, ...accounts], true);
+    this._accounts?.push(...accounts);
+    return this;
+  }
+  sourceQuery(sourceQuery) {
+    this._meta = {
+      ...this._meta,
+      $sourceQuery: sourceQuery
+    };
+    return this;
+  }
+  /** @deprecated use signer instead */
+  witness(account) {
+    this._accounts?.push(account);
+    return this;
+  }
+  /** @deprecated use signers instead */
+  witnesses(accounts) {
+    this._accounts?.push(...accounts);
+    return this;
+  }
+  async sign() {
+    uniqueAccounts(this._accounts, true);
+    const hashBytes = toArrayBuffer(await this.dataHash());
+    return await Promise.all(this._accounts.map(async (account) => hexFromArrayBuffer((await account.sign(hashBytes))[0])));
+  }
+  async generatedFields() {
+    return await _BoundWitnessBuilder.linkingFields(this._accounts, this._payloads);
+  }
+  missingSchemaMessage(payload) {
+    return `Builder: Missing Schema
+${JSON.stringify(payload, null, 2)}`;
+  }
+};
+
+// src/actions/wallet/sign/signPayload.ts
+import chalk20 from "chalk";
+async function signPayload(options) {
+  const offset = options.offset ?? "0";
+  const raw = FS5.readFileSync(options.file, "utf8");
+  const payload = JSON.parse(raw);
+  if (typeof payload.schema !== "string" || payload.schema.length === 0) {
+    throw new Error("Payload must have a non-empty `schema` string field.");
+  }
+  const { rootWallet } = await getActiveWallet();
+  const account = await deriveAccount(rootWallet, offset);
+  const [boundwitness, payloads] = await new BoundWitnessBuilder().payload(payload).signer(account).build();
+  const result = { boundwitness, payloads };
+  const json = JSON.stringify(result, null, 2);
+  if (options.output) {
+    FS5.writeFileSync(options.output, `${json}
+`);
+    console.log(chalk20.green(`Signed payload written to ${options.output}`));
+  } else {
+    console.log(json);
+  }
+}
+
+// src/actions/wallet/transaction/broadcastTransaction.ts
+import FS6 from "fs";
+import chalk21 from "chalk";
+function reviveBigints(_key, value) {
+  if (typeof value === "string" && /^-?\d+n$/.test(value)) {
+    return BigInt(value.slice(0, -1));
+  }
+  return value;
+}
+async function broadcastTransaction(options) {
+  const offset = options.offset ?? "0";
+  const raw = FS6.readFileSync(options.file, "utf8");
+  const signedTx = JSON.parse(raw, reviveBigints);
+  const network = getActiveNetwork();
+  const { rootWallet } = await getActiveWallet();
+  const account = await deriveAccount(rootWallet, offset);
+  console.log(chalk21.gray(`Connecting to ${network.rpcUrl}...`));
+  const { runner } = await createWalletClient(network.rpcUrl, account);
+  const hash = await runner.broadcastTransaction(signedTx);
+  console.log(chalk21.green(`Broadcast accepted: ${hash}`));
+}
+
+// src/actions/wallet/transaction/sendTransaction.ts
+import { asAddress as asAddress2, assertEx as assertEx3 } from "@xylabs/sdk-js";
+import { XL1Amount as XL1Amount2 } from "@xyo-network/xl1-protocol-sdk";
+import chalk22 from "chalk";
+async function sendTransaction(options) {
+  const offset = options.offset ?? "0";
+  const { rootWallet } = await getActiveWallet();
+  const account = await deriveAccount(rootWallet, offset);
+  const network = getActiveNetwork();
+  const recipient = assertEx3(asAddress2(options.recipient.toLowerCase().replace(/^0x/, "")), () => `Invalid recipient address: ${options.recipient}`);
+  const amountXL1 = XL1Amount2.fromXL1(BigInt(options.amount));
+  console.log(chalk22.gray(`Connecting to ${network.rpcUrl}...`));
+  const { gateway } = await createWalletClient(network.rpcUrl, account);
+  console.log(chalk22.gray(`Submitting transfer of ${options.amount} XL1 to 0x${recipient}...`));
+  const hash = await gateway.send(recipient, amountXL1.atto);
+  console.log(chalk22.gray(`Tx submitted: ${hash}`));
+  const attempts = options.attempts ?? 30;
+  const delay = options.delay ?? 2e3;
+  console.log(chalk22.gray(`Confirming (up to ${attempts} attempts, ${delay}ms apart)...`));
+  await gateway.confirmSubmittedTransaction(hash, { attempts, delay });
+  console.log(chalk22.green(`Sent ${options.amount} XL1 \u2192 0x${recipient}`));
+  console.log(`${chalk22.gray("hash:")}    ${hash}`);
+  console.log(`${chalk22.gray("from:")}    0x${account.address}`);
+  console.log(`${chalk22.gray("network:")} ${network.id}`);
+}
+
+// src/actions/wallet/transaction/signTransactionFile.ts
+import FS7 from "fs";
+import { buildTransaction } from "@xyo-network/xl1-protocol-sdk";
+import chalk23 from "chalk";
+function asBigint(value) {
+  return typeof value === "bigint" ? value : BigInt(value);
+}
+async function signTransactionFile(options) {
+  const offset = options.offset ?? "0";
+  const raw = FS7.readFileSync(options.file, "utf8");
+  const tx = JSON.parse(raw);
+  const { rootWallet } = await getActiveWallet();
+  const account = await deriveAccount(rootWallet, offset);
+  const fees = tx.fees ? {
+    base: asBigint(tx.fees.base),
+    gasLimit: asBigint(tx.fees.gasLimit),
+    gasPrice: asBigint(tx.fees.gasPrice),
+    priority: asBigint(tx.fees.priority)
+  } : void 0;
+  const signed = await buildTransaction(
+    tx.chain,
+    tx.onChainPayloads ?? [],
+    tx.offChainPayloads ?? [],
+    account,
+    asBigint(tx.nbf),
+    asBigint(tx.exp),
+    void 0,
+    fees
+  );
+  const serialized = JSON.stringify(signed, (_key, value) => typeof value === "bigint" ? value.toString() : value, 2);
+  if (options.output) {
+    FS7.writeFileSync(options.output, `${serialized}
+`);
+    console.log(chalk23.green(`Signed transaction written to ${options.output}`));
+  } else {
+    console.log(serialized);
+  }
+}
+export {
+  addContact,
+  addNetwork,
+  broadcastTransaction,
+  changePassword,
+  createPhrase,
+  deriveAccount,
+  deriveAndAdd,
+  exportBackup,
+  exportPhrase,
+  getActiveWallet,
+  getBalance,
+  hasPassword,
+  importBackup,
+  importPhrase,
+  labelAccount,
+  listAccounts,
+  listContacts,
+  listNetworks,
+  listPhrases,
+  lock,
+  removeAccount,
+  removeContact,
+  removeNetwork,
+  removePhrase,
+  renameContact,
+  renamePhrase,
+  sendTransaction,
+  showAccount,
+  signPayload,
+  signTransactionFile,
+  unlock,
+  useNetwork,
+  usePhrase
+};
+//# sourceMappingURL=index.mjs.map