@xylabs/aries 0.1.1 → 0.1.7

package/dist/actions/wallet/sign/signPayload.mjs

@@ -1,637 +0,0 @@
-// 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";
-
-// 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/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/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
-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);
-  }
-}
-export {
-  signPayload
-};
-//# sourceMappingURL=signPayload.mjs.map