@xylabs/aries 0.1.1

package/dist/commands/walletSignCommand.mjs

@@ -0,0 +1,662 @@
+// 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 deleteFile(file) {
+  if (FS.existsSync(file)) FS.unlinkSync(file);
+}
+
+// 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 });
+}
+
+// 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 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;
+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 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 readActive() {
+  return readJsonFile(walletPaths().active) ?? {};
+}
+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/sign/signPayload.ts
+import FS3 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 chalk from "chalk";
+async function signPayload(options) {
+  const offset = options.offset ?? "0";
+  const raw = FS3.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) {
+    FS3.writeFileSync(options.output, `${json}
+`);
+    console.log(chalk.green(`Signed payload written to ${options.output}`));
+  } else {
+    console.log(json);
+  }
+}
+
+// src/commands/walletSignCommand.ts
+var walletSignCommand = {
+  command: "sign <file>",
+  describe: "Sign a JSON payload with a derived account (produces a BoundWitness)",
+  builder: (yargs) => yargs.positional("file", {
+    type: "string",
+    demandOption: true,
+    describe: "Path to a JSON payload file"
+  }).option("offset", {
+    alias: "o",
+    type: "string",
+    default: "0",
+    describe: "HD path offset of the signer"
+  }).option("output", {
+    alias: "O",
+    type: "string",
+    describe: "Write output to file instead of stdout"
+  }),
+  handler: async (argv) => {
+    await signPayload({
+      file: argv.file,
+      offset: argv.offset,
+      output: argv.output
+    });
+  }
+};
+export {
+  walletSignCommand
+};
+//# sourceMappingURL=walletSignCommand.mjs.map