@ledgerhq/vault-common 2.1.1 → 2.1.3

package/lib/index.mjs

@@ -1,3252 +0,0 @@
-import {
-  createHSMBridge_default
-} from "./chunk-ZJCMYPBL.mjs";
-import {
-  recipeManifest
-} from "./chunk-MNUHUKY3.mjs";
-import {
-  authenticate,
-  createDefaultRunner_default,
-  decodeChallenge,
-  getAuthTokens,
-  getTradelinkPledge,
-  getTradelinkRecipient,
-  performRequest,
-  prepareRequest_default,
-  reviewAPIRequest_default,
-  signAndApprove
-} from "./chunk-6TT6A6YA.mjs";
-import {
-  createNetwork
-} from "./chunk-VOB7PA3G.mjs";
-import {
-  LIGHT_EVM_CURRENCIES,
-  deserializeUnitValue,
-  extractSecureChannel,
-  getAccountTypeByCurrency,
-  getAccountUnit,
-  getCryptoCurrencyById,
-  getCurrencyOrToken,
-  getCurrencyUnit,
-  getDefaultUsername,
-  getGateAccountUnit,
-  getTokenUnit,
-  getWorkspaceFromGate,
-  listCryptoCurrencies,
-  queue,
-  serializeUnitValue,
-  unwrapConnection,
-  vaultCoins,
-  wait,
-  xpubToExtendedPubKey
-} from "./chunk-QNNV5GBH.mjs";
-import {
-  genKeys
-} from "./chunk-HU7O2ZFW.mjs";
-import {
-  GateGroupRequestTypeDefs,
-  feesLevels
-} from "./chunk-54MXA3ZY.mjs";
-import {
-  __export
-} from "./chunk-J5LGTIGS.mjs";
-
-// src/bakeManifest.ts
-import { SILENT_LOGGER as SILENT_LOGGER2 } from "@ledgerhq/vault-utils";
-import chalk from "chalk";
-import orderBy from "lodash/orderBy";
-import sortBy2 from "lodash/sortBy";
-
-// src/deserializeManifest.ts
-var fromRawUser = (u) => typeof u === "number" ? { device: u } : u;
-var fromRawAPIUser = (u) => typeof u === "string" ? { name: u } : u;
-function deserializeManifest(manifest) {
-  const { users, ...rest } = manifest;
-  return {
-    ...rest,
-    ...users ? {
-      users: {
-        ...users.operators ? { operators: users.operators.map(fromRawUser) } : {},
-        ...users.admins ? { admins: users.admins.map(fromRawUser) } : {},
-        ...users.api ? { api: users.api.map(fromRawAPIUser) } : {},
-        ...users.apiV2 ? { apiV2: users.apiV2 } : {}
-      }
-    } : {}
-  };
-}
-var deserializeManifest_default = deserializeManifest;
-
-// src/fetchTokens.ts
-import { SILENT_LOGGER } from "@ledgerhq/vault-utils";
-function erc20TokenToGateTokenCurrency(erc20) {
-  const parent_currency = erc20.blockchain_name === "foundation" ? "ethereum" : erc20.blockchain_name === "ropsten" ? "ethereum_ropsten" : erc20.blockchain_name === "goerli" ? "ethereum_goerli" : null;
-  if (!parent_currency) {
-    throw new Error(
-      `Can't determine parent_currency from ERC20 token with blockchain_name "${erc20.blockchain_name}"`
-    );
-  }
-  return {
-    contract_address: erc20.contract_address,
-    family: "ethereum",
-    name: erc20.name,
-    parent_currency,
-    ticker: erc20.ticker,
-    token_type: "erc20",
-    units: [
-      {
-        name: erc20.ticker,
-        code: erc20.ticker,
-        magnitude: erc20.decimals
-      }
-    ],
-    __legacy_hsm_account_parameters: erc20.hsm_account_parameters,
-    __legacy_hsm_signature: erc20.hsm_signature
-  };
-}
-async function fetchERC20Tokens(ctx, { logger = SILENT_LOGGER } = {}) {
-  if (process.env.LEGACY_TOKENS) {
-    const res = await ctx.network("GET", "/currencies/erc20s");
-    return res.erc20s.map(erc20TokenToGateTokenCurrency);
-  }
-  let tokens;
-  try {
-    tokens = await ctx.network("GET", "/currencies/tokens");
-  } catch (err) {
-    logger.error(
-      "Fetching tokens has failed, if you are targeting a gate < Vault 3.6, set environment variable LEGACY_TOKENS to 1"
-    );
-    logger.error("e.g: LEGACY_TOKENS=1 ledger-vault <command>");
-    throw err;
-  }
-  return tokens;
-}
-var fetchTokens_default = fetchERC20Tokens;
-
-// src/revault-compat.ts
-import { createEngine } from "@ledgerhq/revault-sdk/engine";
-import { onboard } from "@ledgerhq/revault-sdk/onboarding";
-
-// src/genSeed.ts
-import { entropyToMnemonic } from "bip39";
-import hex from "crypto-js/enc-hex";
-import sha256 from "crypto-js/sha256";
-var hashCode = (str) => {
-  return Buffer.from(hex.stringify(sha256(str)), "hex");
-};
-var genSeed = (salt = "", index = 1, options = {}) => {
-  const { overrideSeeds } = options;
-  const overriddenSeed = !!overrideSeeds && overrideSeeds[index - 1];
-  if (overriddenSeed) return overriddenSeed;
-  const entropy = hashCode(`${salt}_${index}`);
-  return entropyToMnemonic(entropy.toString("hex"));
-};
-var genSeed_default = genSeed;
-
-// src/revault-compat.ts
-function genSeed2({ salt, index }) {
-  return genSeed_default(salt, index);
-}
-async function onboardWithRevault(options, logger) {
-  const engineOptions = {
-    salt: options.salt,
-    baseUrl: options.revaultApiUrl,
-    deviceApiUrl: options.deviceApiUrl,
-    genSeed: genSeed2
-  };
-  const revaultLogger = {
-    ...logger,
-    warning: logger.info,
-    debug: (msg) => {
-      if (process.env.DEBUG === "1") {
-        console.log("DEBUG", msg);
-      }
-    },
-    output: logger.info
-  };
-  const baseEngine = createEngine(engineOptions, revaultLogger);
-  const rootClient = baseEngine.createClient({ rootAuthToken: options.revaultRootAuthToken });
-  try {
-    const onboarding = await rootClient.onboarding.startOnboarding.mutate({
-      hsmScriptsVersion: options.hsmScriptsVersion,
-      workspaceName: options.workspace,
-      compartmentId: options.compartmentId,
-      mode: "GATE_COMPAT"
-    });
-    const onboardingEngine = baseEngine.withOnboarding(onboarding.id);
-    await onboard({ engine: onboardingEngine }, revaultLogger);
-  } catch (err) {
-    if (err instanceof Error && err.message.includes("has already started onboarding")) {
-      logger.info("Onboarding already started, assuming it's finished, skipping");
-      return;
-    }
-    throw err;
-  }
-}
-
-// src/utilsComparison.ts
-import isEqual from "lodash/isEqual";
-import sortBy from "lodash/sortBy";
-var areGroupsDifferent = (group1, group2) => {
-  if (group1.users.length !== group2.users.length) return true;
-  const sortedUsers1 = sortBy(group1.users, [(user) => user.toString()]);
-  const sortedUsers2 = sortBy(group2.users, [(user) => user.toString()]);
-  return !isEqual(sortedUsers1, sortedUsers2);
-};
-var areWorkspaceRulesDifferent = (rule1, rule2) => {
-  if (rule1.permission !== rule2.permission) return true;
-  if (rule1.steps.length !== rule2.steps.length) return true;
-  return rule1.steps.some((step1, i) => {
-    const step2 = rule2.steps[i];
-    if (step1.quorum !== step2.quorum) return true;
-    if (!isEqual(sortBy(step1.users), sortBy(step2.users))) return true;
-    return false;
-  });
-};
-var formatAddress = (a) => `${a.currency}-${a.address}`;
-var areWhitelistsDifferent = (whitelist1, whitelist2) => {
-  if (whitelist1.addresses.length !== whitelist2.addresses.length) return true;
-  const _addresses1 = whitelist1.addresses.map(formatAddress);
-  const _addresses2 = whitelist2.addresses.map(formatAddress);
-  return !isEqual(sortBy(_addresses1), sortBy(_addresses2));
-};
-function sanitizeThreshold(step) {
-  return { ...step, min: step.min || 0 };
-}
-var areAccountsDifferent = (account1, account2) => {
-  if (account1.name !== account2.name) return true;
-  if (account1.tradelink_data || account2.tradelink_data) return false;
-  const account1Rules = account1.rules;
-  const account2Rules = account2.rules;
-  if (!!account1Rules !== !!account2Rules) return true;
-  if (!account1Rules || !account2Rules) return false;
-  if (account1Rules.length !== account2Rules.length) return true;
-  let isDifferent = false;
-  account1Rules.forEach((rule, index) => {
-    const account2Rule = account2Rules[index];
-    if (!account2Rule) throw new Error(`No rule found at index ${index}`);
-    if (rule.length !== account2Rule.length) {
-      isDifferent = true;
-      return;
-    }
-    rule.forEach((step) => {
-      if (step.type === "WHITELIST") {
-        const same = account2Rule.find(
-          (s) => s.type === "WHITELIST" && isEqual(sortBy(s.whitelists), sortBy(step.whitelists))
-        );
-        if (!same) {
-          isDifferent = true;
-          return;
-        }
-      }
-      if (step.type === "THRESHOLD") {
-        const sanitized = sanitizeThreshold(step);
-        const same = account2Rule.find((s) => {
-          if (s.type === "THRESHOLD") {
-            const sanitizeStep = sanitizeThreshold(s);
-            return sanitizeStep.min === sanitized.min && sanitizeStep.max === sanitized.max;
-          }
-          return false;
-        });
-        if (!same) {
-          isDifferent = true;
-          return;
-        }
-      }
-      if (step.type === "MULTI_AUTHORIZATIONS") {
-        const same = account2Rule.find(
-          (s) => s.type === "MULTI_AUTHORIZATIONS"
-        );
-        if (!same || areStepsOfMultiAuthDifferent(step.steps, same.steps)) {
-          isDifferent = true;
-          return;
-        }
-      }
-    });
-  });
-  return isDifferent;
-};
-var areVaultEntitiesDifferent = (vaultEntity1, vaultEntity2) => {
-  if (vaultEntity1.accounts && vaultEntity2.accounts && vaultEntity1.accounts.length !== vaultEntity2.accounts.length)
-    return true;
-  return !isEqual(sortBy(vaultEntity1.accounts), sortBy(vaultEntity2.accounts));
-};
-var areStepsOfMultiAuthDifferent = (steps1, steps2) => {
-  if (steps1.length !== steps2.length) return true;
-  let isDifferent = false;
-  steps1.forEach((s, index) => {
-    const s2 = steps2[index];
-    if (!s2) throw new Error(`No step found at index ${index}`);
-    if (s.quorum !== s2.quorum) {
-      isDifferent = true;
-      return;
-    }
-    if ("group" in s && !("group" in s2) || "group" in s2 && !("group" in s)) {
-      isDifferent = true;
-      return;
-    }
-    if ("group" in s && "group" in s2 && s.group !== s2.group) {
-      isDifferent = true;
-      return;
-    }
-    if ("users" in s && "users" in s2) {
-      if (s.users.length !== s2.users.length || !isEqual(sortBy(s.users), sortBy(s2.users))) {
-        isDifferent = true;
-        return;
-      }
-    }
-  });
-  return isDifferent;
-};
-
-// src/bakeManifest.ts
-var DEFAULT_QUORUM = 2;
-async function bakeManifest(_manifest, pool, options = {}) {
-  const { logger = SILENT_LOGGER2, waitForActive } = options;
-  const manifest = deserializeManifest_default(_manifest);
-  if (_manifest.salt) {
-    pool.setSalt(_manifest.salt);
-  }
-  if (options.revaultOnboarding) {
-    logger.step("[REVAULT] Onboarding");
-    await onboardWithRevault(
-      {
-        ...pool.getRevaultCompatOptions(),
-        ...options.revaultOnboarding
-      },
-      logger
-    );
-  } else {
-    logger.info("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
-    logger.info("\u2551 DEPRECATION NOTICE - LEGACY ONBOARDING HAS BEEN DECOMMISSIONED       \u2551");
-    logger.info("\u2551                                                                      \u2551");
-    logger.info("\u2551 Onboarding skipped, as the new onboarding options were not provided. \u2551");
-    logger.info("\u2551 Please refer to changelog & announcements to see how you can adapt   \u2551");
-    logger.info("\u2551 your code or command.                                                \u2551");
-    logger.info("\u2551                                                                      \u2551");
-    logger.info("\u2551 See v2.0 release of vault-cli/vault-common on GitHub.                \u2551");
-    logger.info("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
-  }
-  const runner = options.runner || createDefaultRunner_default(pool, options);
-  const manifestFromGate = await recipeManifest(pool, { saveAccountsIndexes: true });
-  const { rawData } = manifestFromGate;
-  const {
-    groupsByName,
-    whitelistsByName,
-    accountsByName,
-    usersWithDevice,
-    usersWithoutDevice,
-    vaultEntitiesByName,
-    exchangesByName,
-    policiesByName,
-    tradelinkCustodiansByName,
-    tradelinkHSMCustodiansByName,
-    tradelinkExchangesByName,
-    tradelinkHSMExchangesByName,
-    tradelinkHSMAssetManagersByName,
-    tradelinkAssetManagersByName,
-    tradelinkOnboardingStatus
-  } = rawData;
-  const gateManifest = manifestFromGate.manifest;
-  const __usersByDevice = {
-    ...usersWithDevice.reduce((acc, curr) => {
-      return { ...acc, ...{ [curr.deviceIndex]: curr.user } };
-    }, {})
-  };
-  const __usersByName = {
-    ...usersWithDevice.reduce((acc, curr) => {
-      return { ...acc, ...{ [curr.user.username]: curr.user } };
-    }, {}),
-    ...usersWithoutDevice.reduce((acc, curr) => {
-      return { ...acc, ...{ [curr.user.username]: curr.user } };
-    }, {})
-  };
-  const __groupsIDsByName = {
-    ...Object.keys(groupsByName).reduce((acc, curr) => {
-      const group = groupsByName[curr];
-      if (!group) return acc;
-      return { ...acc, ...{ [curr]: group.id } };
-    }, {})
-  };
-  const __whitelistsIDsByName = {
-    ...Object.keys(whitelistsByName).reduce((acc, curr) => {
-      const whitelist = whitelistsByName[curr];
-      if (!whitelist) return acc;
-      return { ...acc, ...{ [curr]: whitelist.id } };
-    }, {})
-  };
-  const __hsmAMsIDsByName = {
-    ...Object.keys(tradelinkHSMAssetManagersByName).reduce((acc, curr) => {
-      const am = tradelinkHSMAssetManagersByName[curr];
-      if (!am) return acc;
-      return { ...acc, ...{ [curr]: am.id } };
-    }, {})
-  };
-  const __hsmExchangesIDsByName = {
-    ...Object.keys(tradelinkHSMExchangesByName).reduce((acc, curr) => {
-      const exchange = tradelinkHSMExchangesByName[curr];
-      if (!exchange) return acc;
-      return { ...acc, ...{ [curr]: exchange.id } };
-    }, {})
-  };
-  const __hsmCustodiansIDsByName = {
-    ...Object.keys(tradelinkHSMCustodiansByName).reduce((acc, curr) => {
-      const custodian = tradelinkHSMCustodiansByName[curr];
-      if (!custodian) return acc;
-      return { ...acc, ...{ [curr]: custodian.id } };
-    }, {})
-  };
-  const __accountsByName = { ...accountsByName };
-  let tokens = [];
-  const shouldLoadTokens = manifest.accounts && manifest.accounts.find((account) => "contractAddress" in account);
-  if (shouldLoadTokens) {
-    const admin = await pool.login(4);
-    tokens = await fetchTokens_default(admin, { logger });
-  }
-  if (manifest.users) {
-    const adminsAndOperators = [];
-    if (manifest.users.admins) {
-      adminsAndOperators.push(
-        ...manifest.users.admins.map(
-          (a) => ({ role: "admin", device: a.device })
-        )
-      );
-    }
-    if (manifest.users.operators) {
-      adminsAndOperators.push(
-        ...manifest.users.operators.map(
-          (a) => ({ role: "operator", device: a.device })
-        )
-      );
-    }
-    await queue(
-      sortBy2(adminsAndOperators, (u) => u.device),
-      genCreateAdminsAndOperators()
-    );
-    if (manifest.users.api) {
-      logger.step("LAM users creation");
-      await queue(manifest.users.api, genCreateAPIUser());
-    }
-    if (manifest.users.apiV2) {
-      logger.step("API users creation");
-      await queue(manifest.users.apiV2, genCreateAPIV2User());
-    }
-  }
-  if (manifest.workspaceRules) {
-    logger.step("Workspace rules creation");
-    await queue(manifest.workspaceRules, createWorkspaceRule);
-  }
-  if (manifest.groups) {
-    logger.step("Groups");
-    await queue(manifest.groups, createGroup);
-  }
-  if (manifest.whitelists) {
-    logger.step("Whitelists");
-    await queue(manifest.whitelists, createWhitelist);
-  }
-  if (manifest.tradelink) {
-    logger.step("TradeLink");
-    const adminDevices = await pool.getOnboardingAdminDevices();
-    await queue(
-      adminDevices.map((a) => ({ user: a[1], contractNames: ["TRADELINK_ADDENDUM", "TRADELINK"] })),
-      approveContracts
-    );
-    await queue(manifest.tradelink.custodians, createTradelinkCustodian);
-    await queue(manifest.tradelink.assetManagers, createTradelinkAssetManager);
-    await queue(manifest.tradelink.exchanges, createTradelinkExchange);
-    await createTradelinkNetwork(manifest.tradelink);
-    if (manifest.tradelink.onboarded) {
-      await onboardTradelinkNetwork(manifest.tradelink);
-      await queue(
-        manifest.tradelink.exchanges,
-        (exchange) => onboardTradelinkEntity(exchange, "exchanges")
-      );
-      await queue(
-        manifest.tradelink.assetManagers,
-        (am) => onboardTradelinkEntity(am, "asset_managers")
-      );
-    }
-  }
-  if (manifest.accounts) {
-    logger.step("Accounts");
-    manifest.accounts = orderBy(manifest.accounts, "contractAddress", "desc");
-    await queue(manifest.accounts, createAccount);
-  }
-  if (manifest.entities) {
-    logger.step("Entities");
-    await queue(manifest.entities, createVaultEntity);
-  }
-  if (manifest.exchanges) {
-    logger.step("Exchanges");
-    await queue(manifest.exchanges, createVaultExchange);
-  }
-  if (manifest.policies) {
-    logger.step("Policies");
-    await queue(manifest.policies, createVaultPolicy);
-  }
-  if (manifest.quorum) {
-    logger.step("Quorum");
-    await editQuorum(manifest.quorum);
-  }
-  if (manifest.contractApprovals) {
-    logger.step("Contract Approvals");
-    await queue(manifest.contractApprovals, approveContracts);
-  }
-  logger.success("Done");
-  async function editQuorum(quorum) {
-    if (gateManifest.quorum === quorum || quorum === DEFAULT_QUORUM && !gateManifest.quorum) {
-      logger.info(`Quorum is already set to ${quorum}, skipping`);
-      return;
-    }
-    await runner.editQuorum({ quorum });
-    logger.info(`Quorum updated to ${quorum}`);
-  }
-  function genCreateAdminsAndOperators() {
-    return async function createGenericUser(user) {
-      const fn = genCreateUser(user.role);
-      return fn(user.device);
-    };
-  }
-  async function setViewAll(username, gateUserId, viewAll) {
-    logger.info(`Setting view-all permission to ${viewAll} for API user ${username}...`);
-    const admin = await pool.login(4);
-    await admin.network("PUT", `/people/${gateUserId}`, { view_all_override: viewAll });
-    logger.info(`API user ${username} has now view-all permission set to ${viewAll}`);
-  }
-  function genCreateAPIV2User() {
-    return async function createAPIV2User(apiV2User) {
-      const username = apiV2User.name;
-      const existingUser = usersWithoutDevice.find((uwd) => uwd.user.username === username);
-      if (existingUser) {
-        if (["APPROVED", "ACTIVE"].includes(existingUser.user.status)) {
-          logger.info(`Skipping registration of API user ${username}`);
-          __usersByName[existingUser.user.username] = existingUser.user;
-          const targetViewAll = !!apiV2User.viewAll;
-          const existingViewAll = !!existingUser.user.view_all_override;
-          const shouldUpdateViewAll = targetViewAll !== existingViewAll;
-          if (shouldUpdateViewAll) {
-            await setViewAll(username, existingUser.user.id, targetViewAll);
-          }
-          return;
-        }
-      }
-      const params = {
-        user: apiV2User,
-        name: username,
-        publicKey: apiV2User.publicKey ?? genKeys(username).hexPubKey,
-        role: apiV2User.role
-      };
-      const userRequest = await runner.createAPIV2User(params);
-      const userAccessRequest = await runner.createAPIV2UserAccess(params);
-      __usersByName[userRequest.user.username] = userRequest.user;
-      logger.info(`(+) Created API user: ${username}`);
-      if (apiV2User.viewAll) {
-        await setViewAll(username, userRequest.user.id, true);
-      }
-      logger.info(
-        chalk`{red.bold IMPORTANT:} {red The API user credentials will not be displayed again so note them somewhere}`
-      );
-      logger.info(
-        JSON.stringify({
-          api_key_id: userAccessRequest.api_key_id,
-          api_key_secret: userAccessRequest.api_key_secret
-        })
-      );
-    };
-  }
-  function genCreateAPIUser() {
-    return async function createUser(apiUser) {
-      const username = apiUser.name;
-      const existingUser = usersWithDevice.find((ud) => ud.user.username === username);
-      if (existingUser) {
-        if (existingUser.user.status === "ACTIVE") {
-          logger.info(`Skipping registration of LAM ${username}`);
-          __usersByName[existingUser.user.username] = existingUser.user;
-          return;
-        }
-      }
-      const { device_id } = await pool.lamAPI.createInvitation(username);
-      const params = { user: apiUser, userID: device_id, name: username };
-      const request = await runner.createAPIUser(params, manifestFromGate);
-      __usersByName[request.user.username] = request.user;
-      logger.info(`(+) Created LAM api user: ${username}`);
-    };
-  }
-  function genCreateUser(role) {
-    return async function createUser(device) {
-      const name = manifest.customUsernames && manifest.customUsernames[device] || getDefaultUsername(role, device);
-      const userID = await pool.getUserID(device);
-      const findByUserID = (ud) => ud.user.user_id === userID;
-      const existingUser = usersWithDevice.find(findByUserID);
-      if (existingUser) {
-        logger.info(`Skipping registration of ${role} ${device}`);
-        __usersByDevice[device] = existingUser.user;
-        __usersByName[existingUser.user.username] = existingUser.user;
-        return;
-      }
-      const createUserParams = { role, userID, name, device };
-      const request = await runner.createUser(createUserParams);
-      __usersByDevice[device] = request.user;
-      __usersByName[request.user.username] = request.user;
-      logger.info(`(+) Created ${name}`);
-    };
-  }
-  async function createWorkspaceRule(rule) {
-    const existingRule = gateManifest.workspaceRules?.find((r) => r.permission === rule.permission);
-    if (!existingRule || areWorkspaceRulesDifferent(rule, existingRule)) {
-      const step = rule.steps[0];
-      logger.info(
-        `Configuring workspace rule ${rule.permission} with ${step.quorum} approvals out of ${step.users.length} user(s)`
-      );
-      await runner.editWorkspaceRule({ rule, usersByName: __usersByName });
-    } else {
-      logger.info(`Skipping edition of workspace rule ${rule.permission}`);
-    }
-  }
-  async function createGroup(group) {
-    let isEdit = false;
-    const existingGroup = groupsByName[group.name];
-    const isApprovingPendingGroup = existingGroup && existingGroup.status === "PENDING" && group.status !== "PENDING";
-    if (existingGroup) {
-      if (existingGroup && existingGroup.status === "ACTIVE") {
-        if (!gateManifest.groups) {
-          throw new Error(`No groups in gate manifest`);
-        }
-        const groupFromGateManifest = gateManifest.groups.find((g) => g.name === group.name);
-        if (!groupFromGateManifest) {
-          throw new Error(`Can't find group ${group.name}`);
-        }
-        isEdit = areGroupsDifferent(groupFromGateManifest, group);
-      }
-      if (!isEdit && !isApprovingPendingGroup) {
-        logger.info(`Skipping creation of group ${group.name}`);
-        return;
-      }
-    }
-    const data = {
-      group,
-      usersByDevice: __usersByDevice,
-      usersByName: __usersByName,
-      existingGroup
-    };
-    const existingRequest = !!isApprovingPendingGroup && !!existingGroup && existingGroup.last_request || null;
-    const noApproval = shouldNotApprove(group) || shouldRejectRequest(group);
-    const bakeGroupParams = {
-      group,
-      data,
-      noApproval,
-      existingRequest
-    };
-    const request = isEdit ? await runner.editGroup(bakeGroupParams) : await runner.createGroup(bakeGroupParams);
-    __groupsIDsByName[group.name] = existingGroup && existingGroup.id || request.group.id;
-    if (shouldRejectRequest(group)) {
-      const admin = await pool.login(4);
-      admin.rejectRequest(request.id);
-      logger.info(`(+) Rejected group ${group.name}`);
-    } else {
-      logger.info(`(+) ${isEdit ? "Edited" : "Created"} group ${group.name}`);
-    }
-  }
-  async function createTradelinkCustodian(tradelinkEntity) {
-    const existingCustodian = tradelinkCustodiansByName[tradelinkEntity.name];
-    if (existingCustodian) {
-      logger.info(`Skipping creation of tradelink custodian ${tradelinkEntity.name}`);
-      return;
-    }
-    const bakeTLCustodianParams = {
-      tradelinkEntity,
-      type: "custodians"
-    };
-    await runner.createTradelinkEntity(bakeTLCustodianParams);
-    logger.info(`(+) Created Tradelink custodian ${tradelinkEntity.name}`);
-  }
-  async function approveContracts(approval) {
-    const { contractNames, user: deviceIndex } = approval;
-    const user = await pool.login(deviceIndex);
-    try {
-      const unapproved = await user.get(
-        "/contracts/unapproved"
-      );
-      const contracts = unapproved.filter((c) => contractNames.includes(c.contract_name));
-      const promises = contracts.map((c) => {
-        logger.info(`Approving contract "${c.contract_name}" with user ${deviceIndex}`);
-        return user.post("/contracts/approve", c);
-      });
-      await Promise.all(promises);
-    } catch (e) {
-      logger.error(`Error approving contracts by user ${deviceIndex}`, e);
-    }
-  }
-  async function createTradelinkExchange(tradelinkEntity) {
-    const existingExchange = tradelinkExchangesByName[tradelinkEntity.name];
-    if (existingExchange) {
-      logger.info(`Skipping creation of tradelink exchange ${tradelinkEntity.name}`);
-      return;
-    }
-    const bakeTLCustodianParams = {
-      tradelinkEntity,
-      type: "exchanges"
-    };
-    await runner.createTradelinkEntity(bakeTLCustodianParams);
-    logger.info(`(+) Created Tradelink exchange ${tradelinkEntity.name}`);
-  }
-  async function createTradelinkAssetManager(tradelinkEntity) {
-    const existingCustodian = tradelinkAssetManagersByName[tradelinkEntity.name];
-    if (existingCustodian) {
-      logger.info(`Skipping creation of tradelink asset manager ${tradelinkEntity.name}`);
-      return;
-    }
-    const bakeTLCustodianParams = {
-      tradelinkEntity,
-      type: "asset_managers"
-    };
-    await runner.createTradelinkEntity(bakeTLCustodianParams);
-    logger.info(`(+) Created Tradelink asset manager ${tradelinkEntity.name}`);
-  }
-  function formatTradelinkNetworkParams(manifestTLEntity) {
-    const operators = [];
-    if (manifestTLEntity.users.operators) {
-      manifestTLEntity.users.operators.forEach((operator) => {
-        const user = __usersByDevice[operator];
-        if (user) operators.push(user.pub_key);
-      });
-    }
-    if (manifestTLEntity.users.apiV2) {
-      manifestTLEntity.users.apiV2.forEach((apiV2) => {
-        const user = __usersByName[apiV2];
-        if (user) operators.push(user.pub_key);
-      });
-    }
-    return {
-      id: manifestTLEntity.id,
-      name: manifestTLEntity.name,
-      operators
-    };
-  }
-  function formatTradelinkNetworkParamsWithAddresses(manifestTLEntity) {
-    const data = formatTradelinkNetworkParams(manifestTLEntity);
-    return {
-      ...data,
-      addresses: manifestTLEntity.addresses
-    };
-  }
-  async function createTradelinkNetwork(tradelink) {
-    const custodians = tradelink.custodians.map((custodian) => {
-      return formatTradelinkNetworkParams(custodian);
-    });
-    const exchanges = tradelink.exchanges.map((exchange) => {
-      return formatTradelinkNetworkParamsWithAddresses(exchange);
-    });
-    const assetManagers = tradelink.assetManagers.map((am) => {
-      return formatTradelinkNetworkParamsWithAddresses(am);
-    });
-    if (custodians.length === 0) {
-      throw new Error(`Custodian ${tradelink.custodians} not found`);
-    }
-    const bakeTLNetworkParams = { custodians, exchanges, assetManagers };
-    await runner.createTradelinkNetwork(bakeTLNetworkParams);
-    logger.info(`(+) Created Tradelink network`);
-  }
-  async function onboardTradelinkNetwork(tradelink) {
-    if (tradelinkOnboardingStatus.status == "CUSTODIAN_ONBOARDED" || tradelinkOnboardingStatus.status == "EXCHANGE_ONBOARDED" || tradelinkOnboardingStatus.status == "HSM_READY") {
-      logger.info(`Skipping onboarding of custodian`);
-      return;
-    }
-    const custodian = tradelink.custodians.map((custodian2) => {
-      return formatTradelinkNetworkParams(custodian2);
-    })[0];
-    if (!custodian) {
-      throw new Error(`Custodian ${tradelink.custodians} not found`);
-    }
-    const request = await runner.createTradelink({
-      type: "CREATE_TRADELINK",
-      operators: custodian.operators
-    });
-    __hsmCustodiansIDsByName[custodian.name] = request.tradelink.id;
-    logger.info(`(+) ${custodian.name} Tradelink custodian Onboarded`);
-  }
-  async function onboardTradelinkEntity(entity, entityType) {
-    if (tradelinkHSMAssetManagersByName[entity.name]?.status === "ACTIVE") {
-      logger.info(`Skipping onboarding of asset manager ${entity.name}`);
-      return;
-    }
-    if (tradelinkHSMExchangesByName[entity.name]?.status === "ACTIVE") {
-      logger.info(`Skipping onboarding of exchange ${entity.name}`);
-      return;
-    }
-    let approver;
-    if (entity.users.apiV2 && entity.users.apiV2.length > 0) {
-      const userName = entity.users.apiV2[0];
-      approver = __usersByName[userName];
-    }
-    if (!approver) {
-      throw new Error(`No approver found for ${entity.name}`);
-    }
-    const { name, operators, addresses } = formatTradelinkNetworkParamsWithAddresses(entity);
-    const bakeParams = {
-      tradelinkEntity: { name, operators, addresses },
-      type: entityType,
-      tradelinkEntityApprover: { name: approver.username, role: approver.role }
-    };
-    const request = await runner.onboardTradelinkEntity(bakeParams);
-    if (entityType === "asset_managers")
-      __hsmAMsIDsByName[entity.name] = request.tradelink_asset_manager.id;
-    else
-      __hsmExchangesIDsByName[entity.name] = request.tradelink_exchange.id;
-    logger.info(`(+) ${entity.name} Tradelink ${entityType} Onboarded`);
-  }
-  async function createWhitelist(whitelist) {
-    let isEdit = false;
-    const existingWhitelist = whitelistsByName[whitelist.name];
-    const isApprovingPendingWhitelist = existingWhitelist && existingWhitelist.status === "PENDING" && whitelist.status !== "PENDING";
-    if (existingWhitelist && existingWhitelist.status === "ACTIVE") {
-      if (!gateManifest.whitelists) {
-        throw new Error(`No whitelists in gate manifest`);
-      }
-      const whitelistFromGateManifest = gateManifest.whitelists.find(
-        (w) => w.name === whitelist.name
-      );
-      if (!whitelistFromGateManifest) {
-        throw new Error(`Can't find whitelist ${whitelist.name}`);
-      }
-      isEdit = areWhitelistsDifferent(whitelistFromGateManifest, whitelist);
-      if (!isEdit && !isApprovingPendingWhitelist) {
-        logger.info(`Skipping creation of whitelist ${whitelist.name}`);
-        return;
-      }
-    }
-    const noApproval = shouldNotApprove(whitelist) || shouldRejectRequest(whitelist);
-    const existingRequest = !!isApprovingPendingWhitelist && !!existingWhitelist && existingWhitelist.last_request || null;
-    const data = { whitelist, existingWhitelist };
-    const bakeWLParams = { whitelist, data, existingRequest, noApproval };
-    const request = isEdit ? await runner.editWhitelist(bakeWLParams) : await runner.createWhitelist(bakeWLParams);
-    __whitelistsIDsByName[whitelist.name] = existingWhitelist && existingWhitelist.id || request.whitelist.id;
-    if (shouldRejectRequest(whitelist)) {
-      const admin = await pool.login(4);
-      admin.rejectRequest(request.id);
-      logger.info(`(+) Rejected whitelist ${whitelist.name}`);
-    } else {
-      logger.info(`(+) ${isEdit ? "Edited" : "Created"} whitelist ${whitelist.name}`);
-    }
-  }
-  function getTradelinkAPIUserFromAssetManager(entity) {
-    const entityAM = manifest.tradelink?.assetManagers.filter((am) => am.name === entity.name)[0];
-    if (!entityAM) {
-      throw new Error(`AssetManager ${entity.name} not found`);
-    }
-    const approverUserName = entityAM.users.apiV2[0];
-    if (!approverUserName) {
-      throw new Error(`No approver found for ${entity.name}`);
-    }
-    const user = __usersByName[approverUserName];
-    if (!user) {
-      throw new Error(`User ${approverUserName} not found`);
-    }
-    return { name: user.username, role: user.role };
-  }
-  async function createAccount(accountDesc) {
-    let isEdit = false;
-    const existingAccount = __accountsByName[accountDesc.name] || findAccountByCurrencyAndIndex({ accountDesc, __accountsByName }) || findExistingChildrenAccount({ accountDesc, __accountsByName });
-    const isApprovingPendingAccount = existingAccount && existingAccount.status === "PENDING" && accountDesc.status !== "PENDING";
-    if (existingAccount) {
-      if (existingAccount.status === "VIEW_ONLY") {
-        isEdit = true;
-      } else if (existingAccount.status === "ACTIVE") {
-        if (!gateManifest.accounts) {
-          throw new Error("No accounts in gate manifest");
-        }
-        const accountFromGateManifest = gateManifest.accounts.find(
-          (a) => a.name === accountDesc.name || "currency" in accountDesc && "index" in accountDesc && "currency" in a && "index" in a && accountDesc.currency === a.currency && accountDesc.index === a.index && (!("contractAddress" in accountDesc) && !("contractAddress" in a) || "contractAddress" in accountDesc && "contractAddress" in a && accountDesc.contractAddress === a.contractAddress)
-        );
-        if (!accountFromGateManifest) {
-          throw new Error(`Can't find account ${accountDesc.name}`);
-        }
-        isEdit = areAccountsDifferent(accountFromGateManifest, accountDesc);
-      }
-      if (!isEdit && !isApprovingPendingAccount) {
-        logger.info(`Skipping creation of account ${accountDesc.name}`);
-        return;
-      }
-    }
-    const data = {
-      account: accountDesc,
-      existingAccount,
-      usersByDevice: __usersByDevice,
-      usersByName: __usersByName,
-      groupsIDsByName: __groupsIDsByName,
-      whitelistsIDsByName: __whitelistsIDsByName,
-      accountsByName: __accountsByName,
-      hsmAssetManagersIDsByName: __hsmAMsIDsByName,
-      hsmExchangesIDsByName: __hsmExchangesIDsByName,
-      hsmCustodiansIDsByName: __hsmCustodiansIDsByName,
-      tokens
-    };
-    const existingRequest = isApprovingPendingAccount && !!existingAccount && existingAccount.last_request || null;
-    const noApproval = shouldNotApprove(accountDesc) || shouldRejectRequest(accountDesc);
-    let tradelinkAM;
-    if ("tradelink" in manifest && "tradelink_data" in accountDesc && accountDesc.tradelink_data) {
-      const assetManager = manifest.tradelink?.assetManagers[0];
-      if (!assetManager) {
-        throw new Error(`AssetManager not found`);
-      }
-      tradelinkAM = getTradelinkAPIUserFromAssetManager(assetManager);
-    }
-    const bakeAccountParams = {
-      account: accountDesc,
-      data,
-      existingRequest,
-      noApproval,
-      waitForActive,
-      tradelinkAM
-    };
-    const request = isEdit ? await runner.editAccount(bakeAccountParams) : await runner.createAccount(bakeAccountParams);
-    __accountsByName[accountDesc.name] = request.account;
-    if (shouldRejectRequest(accountDesc)) {
-      const admin = await pool.login(4);
-      admin.rejectRequest(request.id);
-      logger.info(`(+) Rejected account ${accountDesc.name}`);
-    } else {
-      logger.info(`(+) ${isEdit ? "Edited" : "Created"} account ${accountDesc.name}`);
-    }
-    if ("config" in accountDesc && !!accountDesc.config) {
-      const { config } = accountDesc;
-      const admin = await pool.login(4);
-      const account = __accountsByName[accountDesc.name];
-      if (config.nftGallery) {
-        await admin.post(`/accounts/${account.id}/nfts/activate`, {});
-        logger.info(`(+) Enabled NFT Gallery on ${accountDesc.name}`);
-      }
-    }
-  }
-  async function createVaultEntity(vaultEntity) {
-    let isEdit = false;
-    const existingVaultEntity = vaultEntitiesByName[vaultEntity.name];
-    const isApprovingPendingVaultEntity = existingVaultEntity && existingVaultEntity.status === "PENDING" && vaultEntity.status !== "PENDING";
-    if (existingVaultEntity) {
-      if (existingVaultEntity && existingVaultEntity.status === "ACTIVE") {
-        if (!gateManifest.entities) {
-          throw new Error(`No entities in gate manifest`);
-        }
-        const vaultEntityFromGateManifest = gateManifest.entities.find(
-          (e) => e.name === vaultEntity.name
-        );
-        if (!vaultEntityFromGateManifest) {
-          throw new Error(`Can't find entity ${vaultEntity.name}`);
-        }
-        isEdit = areVaultEntitiesDifferent(vaultEntityFromGateManifest, vaultEntity);
-      }
-      if (!isEdit && !isApprovingPendingVaultEntity) {
-        logger.info(`Skipping creation of entity ${vaultEntity.name}`);
-        return;
-      }
-    }
-    const data = {
-      vaultEntity,
-      accountsByName: __accountsByName,
-      existingVaultEntity
-    };
-    const existingRequest = !!isApprovingPendingVaultEntity && !!existingVaultEntity && existingVaultEntity.last_request || null;
-    const noApproval = shouldNotApprove(vaultEntity) || shouldRejectRequest(vaultEntity);
-    const bakeVaultEntityParams = {
-      vaultEntity,
-      data,
-      noApproval,
-      existingRequest
-    };
-    const request = isEdit ? await runner.editVaultEntity(bakeVaultEntityParams) : await runner.createVaultEntity(bakeVaultEntityParams);
-    if (shouldRejectRequest(vaultEntity)) {
-      const admin = await pool.login(4);
-      await admin.rejectRequest(request.id);
-      logger.info(`(+) Rejected entity ${vaultEntity.name}`);
-    } else {
-      logger.info(`(+) ${isEdit ? "Edited" : "Created"} entity ${vaultEntity.name}`);
-    }
-  }
-  async function createVaultExchange(exchange) {
-    const existingExchange = exchangesByName[exchange.name];
-    const isApprovingPendingExchange = existingExchange && existingExchange.status === "PENDING" && exchange.status !== "PENDING";
-    if (existingExchange) {
-      if (existingExchange && existingExchange.status === "ACTIVE") {
-        if (!gateManifest.exchanges) {
-          throw new Error(`No exchanges in gate manifest`);
-        }
-        const exchangeFromGateManifest = gateManifest.exchanges.find(
-          (e) => e.name === exchange.name
-        );
-        if (!exchangeFromGateManifest) {
-          throw new Error(`Can't find exchange ${exchange.name}`);
-        }
-      }
-      if (!isApprovingPendingExchange) {
-        logger.info(`Skipping creation of exchange ${exchange.name}`);
-        return;
-      }
-    }
-    const data = {
-      exchange,
-      usersByDevice: __usersByDevice,
-      usersByName: __usersByName,
-      groupsIDsByName: __groupsIDsByName,
-      existingExchange
-    };
-    const existingRequest = !!isApprovingPendingExchange && !!existingExchange && existingExchange.last_request || null;
-    const noApproval = shouldNotApprove(exchange) || shouldRejectRequest(exchange);
-    const bakeExchangeParams = {
-      exchange,
-      data,
-      noApproval,
-      existingRequest
-    };
-    const request = await runner.createExchange(bakeExchangeParams);
-    if (shouldRejectRequest(exchange)) {
-      const admin = await pool.login(4);
-      await admin.rejectRequest(request.id);
-      logger.info(`(+) Rejected exchange ${exchange.name}`);
-    } else {
-      logger.info(`(+) Created exchange ${exchange.name}`);
-    }
-  }
-  async function createVaultPolicy(policy) {
-    const existingPolicy = policiesByName[policy.name];
-    const isApprovingPendingPolicy = existingPolicy && existingPolicy.status === "PENDING" && policy.status !== "PENDING";
-    if (existingPolicy) {
-      if (existingPolicy && existingPolicy.status === "ACTIVE") {
-        if (!gateManifest.policies) {
-          throw new Error(`No policies in gate manifest`);
-        }
-        const policyFromGateManifest = gateManifest.policies.find((e) => e.name === policy.name);
-        if (!policyFromGateManifest) {
-          throw new Error(`Can't find policy ${policy.name}`);
-        }
-      }
-      if (!isApprovingPendingPolicy) {
-        logger.info(`Skipping creation of policy ${policy.name}`);
-        return;
-      }
-    }
-    const data = {
-      policy,
-      usersByDevice: __usersByDevice,
-      usersByName: __usersByName,
-      whitelistsIDsByName: __whitelistsIDsByName,
-      groupsIDsByName: __groupsIDsByName,
-      existingPolicy
-    };
-    const existingRequest = !!isApprovingPendingPolicy && !!existingPolicy && existingPolicy.last_request || null;
-    const noApproval = shouldNotApprove(policy) || shouldRejectRequest(policy);
-    const bakePolicyParams = {
-      policy,
-      data,
-      noApproval,
-      existingRequest
-    };
-    const request = await runner.createPolicy(bakePolicyParams);
-    if (shouldRejectRequest(policy)) {
-      const admin = await pool.login(4);
-      await admin.rejectRequest(request.id);
-      logger.info(`(+) Rejected policy ${policy.name}`);
-    } else {
-      logger.info(`(+) Created policy ${policy.name}`);
-    }
-  }
-}
-var shouldNotApprove = (manifestEntity) => manifestEntity.status === "PENDING";
-var shouldRejectRequest = (manifestEntity) => manifestEntity.status === "ABORTED";
-var findExistingChildrenAccount = ({
-  accountDesc,
-  __accountsByName
-}) => {
-  if (!("parentAccount" in accountDesc) || !("contractAddress" in accountDesc)) return;
-  const accounts = Object.keys(__accountsByName).map((name) => {
-    return __accountsByName[name];
-  }).filter(Boolean);
-  const parent = accounts.find((a) => !!a && a.name === accountDesc.parentAccount);
-  if (!parent) return;
-  const children = accounts.filter((a) => !!a && a.parent === parent.id);
-  if (children.length === 0) return;
-  return children.find((c) => !!c && c.contract_address === accountDesc.contractAddress);
-};
-var findAccountByCurrencyAndIndex = ({
-  accountDesc,
-  __accountsByName
-}) => {
-  if (!("currency" in accountDesc) || !("index" in accountDesc)) return;
-  const accounts = Object.values(__accountsByName);
-  return accounts.find(
-    (account) => account.currency === accountDesc.currency && account.index === accountDesc.index && ("contractAddress" in accountDesc ? accountDesc.contractAddress === account.contract_address : !account.contract_address)
-  );
-};
-
-// src/configcat.ts
-import { SILENT_LOGGER as SILENT_LOGGER3 } from "@ledgerhq/vault-utils";
-import axios from "axios";
-var configCatEndpoint = "https://api.configcat.com/v1";
-async function createConfigCatEnvironment(ccConfig, environmentName) {
-  const {
-    data: { environmentId }
-  } = await axios.post(
-    `${configCatEndpoint}/products/${ccConfig.productId}/environments`,
-    {
-      name: environmentName,
-      color: "#DADBEE",
-      description: "Created by ledger-vault CLI"
-    },
-    {
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Basic ${ccConfig.apiKey}`
-      }
-    }
-  );
-  const { data: getCredentialsResponse } = await axios.get(
-    `${configCatEndpoint}/configs/${ccConfig.configId}/environments/${environmentId}`,
-    {
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Basic ${ccConfig.apiKey}`
-      }
-    }
-  );
-  return {
-    sdkKey: getCredentialsResponse.primary,
-    productId: ccConfig.productId,
-    configId: ccConfig.configId,
-    environmentId
-  };
-}
-async function getEnvironmentIDFromEnvironmentName(ccConfig, environmentName) {
-  const { data: getEnvironmentsResponse } = await axios.get(`${configCatEndpoint}/products/${ccConfig.productId}/environments`, {
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Basic ${ccConfig.apiKey}`
-    }
-  });
-  const environment = getEnvironmentsResponse?.find(
-    (environment2) => environment2.name === environmentName
-  );
-  return environment?.environmentId;
-}
-async function deleteConfigCatEnvironment(ccConfig, environmentName) {
-  const environmentID = await getEnvironmentIDFromEnvironmentName(ccConfig, environmentName);
-  if (environmentID === void 0) {
-    throw Error(`Unable to find ConfigCat environment '${environmentName}'`);
-  }
-  await axios.delete(`${configCatEndpoint}/environments/${environmentID}`, {
-    headers: {
-      Authorization: `Basic ${ccConfig.apiKey}`
-    }
-  });
-}
-async function setConfigCatFeatureFlagValues(ccConfig, environmentName, flagValues, { logger = SILENT_LOGGER3 } = {}) {
-  const environmentID = await getEnvironmentIDFromEnvironmentName(ccConfig, environmentName);
-  if (environmentID === void 0) {
-    throw Error(`Unable to find ConfigCat environment '${environmentName}'`);
-  }
-  const { data: getFlagsResponse } = await axios.get(
-    `${configCatEndpoint}/configs/${ccConfig.configId}/settings`,
-    {
-      headers: {
-        Authorization: `Basic ${ccConfig.apiKey}`
-      }
-    }
-  );
-  const settingValues = getFlagsResponse.filter((configCatFlag) => Object.keys(flagValues).includes(configCatFlag.key)).map((configCatFlag) => {
-    let flagValue = flagValues[configCatFlag.key];
-    if (configCatFlag.settingType == "string" && typeof flagValue != "string") {
-      flagValue = JSON.stringify(flagValue);
-    }
-    return { settingId: configCatFlag.settingId, value: flagValue };
-  });
-  try {
-    await axios.post(
-      `${configCatEndpoint}/configs/${ccConfig.configId}/environments/${environmentID}/values`,
-      { settingValues },
-      { headers: { Authorization: `Basic ${ccConfig.apiKey}` } }
-    );
-  } catch (err) {
-    logger.error(`Could not set feature flags`);
-    logger.error(err);
-  }
-}
-
-// src/createDevicesPool.ts
-import { SILENT_LOGGER as SILENT_LOGGER4 } from "@ledgerhq/vault-utils";
-import invariant2 from "invariant";
-import io from "socket.io-client";
-
-// src/device/index.ts
-var device_exports = {};
-__export(device_exports, {
-  createRunner: () => createRunner
-});
-import { openTransportReplayer } from "@ledgerhq/hw-transport-mocker";
-import { registerTransportModule, withDevicePolling } from "@ledgerhq/live-common-stub";
-import { listen } from "@ledgerhq/logs";
-import { from } from "rxjs";
-var mockTransport = Promise.resolve({
-  open: () => Promise.resolve(),
-  close: () => Promise.resolve()
-});
-listen(
-  /* istanbul ignore next */
-  (log) => {
-    if (log.type === "apdu" && process.env.DEBUG === "1") {
-      console.log(`${log.type}: ${log.message ? log.message : ""}`);
-    }
-  }
-);
-registerTransportModule({
-  id: "software",
-  open: (id) => {
-    if (id !== "software") return;
-    return mockTransport;
-  },
-  disconnect: () => null
-});
-var createRunner = (allInteractions, { readOnly, transport, recordStore, acceptPollingError } = {
-  transport: "software"
-}) => async (_interactions, _data, options) => {
-  const interactions = [...readOnly ? [] : [allInteractions.getU2FPublicKey], ..._interactions];
-  const responses = { ..._data };
-  for (let i = 0; i < interactions.length; i++) {
-    const interaction = interactions[i];
-    if (!interaction) throw new Error("Invalid interaction");
-    if (recordStore) {
-      const replayer = await openTransportReplayer(recordStore);
-      const response = await interaction.action({
-        ...responses,
-        transport: replayer
-      });
-      responses[interaction.responseKey] = response;
-    } else {
-      const obs = withDevicePolling(transport)(
-        (transport2) => {
-          return from(interaction.action({ ...responses, transport: transport2 }));
-        },
-        // always throw on error:
-        // eslint-disable-next-line
-        acceptPollingError ?? (() => false)
-      );
-      if (options?.onStepStart) {
-        options.onStepStart(interaction.responseKey);
-      }
-      const res = await obs.toPromise();
-      responses[interaction.responseKey] = res;
-      if (options?.onStepDone) {
-        options.onStepDone({ responseKey: interaction.responseKey, value: res });
-      }
-    }
-  }
-  return responses;
-};
-
-// src/device/createAPIDevice.ts
-import { nanoid } from "nanoid";
-var ROLE_TO_BYTES = {
-  shared_owner: Buffer.from([2]),
-  admin: Buffer.from([1]),
-  operator: Buffer.from([0])
-};
-var ENDPOINTS = {
-  GET_PUBLIC_KEY: "/get-public-key",
-  GET_ATTESTATION: "/get-attestation",
-  OPEN_SESSION: "/open-session",
-  AUTHENTICATE: "/authenticate",
-  REGISTER: "/register",
-  VALIDATE_VAULT_OPERATION: "/validate-vault-operation",
-  GENERATE_KEY_FRAGMENTS: "/generate-key-fragments",
-  REGISTER_DATA: "/u2f-register-data",
-  GET_CURRENT_DEVICE: "/current-device",
-  // NEW SECURE CHANNEL ENDPOINTS
-  INITIATE_PAIRING_HANDSHAKE: "/initiate-pairing-handshake",
-  GENERATE_SEED_COMPONENT: "/generate-key-component",
-  FINALIZE_PAIRING_HANDSHAKE: "/finalize-pairing-handshake",
-  START_K_PATTERN_AS_RESPONDER: "/start-k-pattern-as-responder",
-  START_KK_PATTERN_AS_RESPONDER: "/start-kk-pattern-as-responder",
-  VALIDATE_OP: "/validate-op"
-};
-var deviceTypeBufferFromPsdModel = {
-  BLUE: Buffer.from([0]),
-  STAX: Buffer.from([2])
-};
-var pathArrayToString = (path) => {
-  if (!path[0] || !path[1]) throw new Error("Invalid path array");
-  return `${path[0] & 268435455}'/${path[1] & 268435455}'`;
-};
-var __DEVICE_API_NETWORK__ = createNetwork({
-  baseURL: process.env.VAULT_DEVICE_API_URL || "https://localhost:8443/device-api"
-});
-function setDeviceAPIEndpoint(url) {
-  __DEVICE_API_NETWORK__ = createNetwork({ baseURL: url });
-}
-function createAPIDevice(options = {}) {
-  const { deviceAPISessionID, overrideSeeds, deviceAPIURL, psdModel = "STAX" } = options;
-  let { salt = "" } = options;
-  let __CURRENT_SEED__ = "";
-  let __PSD_MODEL__ = psdModel;
-  const __DEVICE_API_SESSION_ID__ = deviceAPISessionID || nanoid();
-  const setSeed = (seed) => {
-    __CURRENT_SEED__ = seed;
-  };
-  const setSalt = (newSalt) => {
-    salt = newSalt;
-  };
-  const deviceNetwork = (method, url, _data = {}, requestOptions = {}) => {
-    const data = {
-      seed: __CURRENT_SEED__,
-      sessionID: __DEVICE_API_SESSION_ID__,
-      psd_model: deviceTypeBufferFromPsdModel[__PSD_MODEL__].toString("hex"),
-      ..._data,
-      version: 3
-      // This is used to choose Noise Channel mode
-    };
-    const deviceAPINetwork = deviceAPIURL ? createNetwork({ baseURL: deviceAPIURL }) : __DEVICE_API_NETWORK__;
-    return deviceAPINetwork(method, url, data, requestOptions);
-  };
-  const getPublicKey = async (transport, path, secp256k1 = true) => {
-    const data = await deviceNetwork("POST", ENDPOINTS.GET_PUBLIC_KEY, {
-      path: pathArrayToString(path),
-      secp256k1
-    });
-    return {
-      pubKey: data.pubKey,
-      signature: Buffer.from(data.attestation, "hex")
-    };
-  };
-  const registerData = async (transport, challenge) => {
-    const data = await deviceNetwork("POST", ENDPOINTS.REGISTER_DATA, {
-      challenge: challenge.toString("hex")
-    });
-    return Buffer.from(data, "hex");
-  };
-  const switchDevice = async (id) => {
-    setSeed(genSeed_default(salt, id, { overrideSeeds }));
-  };
-  const register = async (transport, challenge, application, name, userRole, registerData2) => {
-    const data = await deviceNetwork("POST", ENDPOINTS.REGISTER, {
-      challenge: challenge.toString("hex"),
-      name,
-      role: ROLE_TO_BYTES[userRole].toString("hex"),
-      hsm_data: registerData2,
-      type: deviceTypeBufferFromPsdModel[__PSD_MODEL__].toString("hex"),
-      application
-    });
-    const response = Buffer.from(data, "hex");
-    let i = 0;
-    const rfu = response.slice(i, i += 1)[0];
-    const pubKey = response.slice(i, i += 65).toString("hex");
-    const keyHandleLength = response.slice(i, ++i)[0];
-    if (typeof keyHandleLength === "undefined") throw new Error("Invalid key handle length");
-    const keyHandle = response.slice(i, i += keyHandleLength);
-    return {
-      u2f_register: response.slice(0, response.length - 2),
-      keyHandle,
-      rfu,
-      pubKey
-    };
-  };
-  const getAttestationCertificate = async () => {
-    const data = await deviceNetwork("POST", ENDPOINTS.GET_ATTESTATION);
-    return Buffer.from(data, "hex");
-  };
-  const validateVaultOperation = async (transport, path, channel) => {
-    const data = await deviceNetwork("POST", ENDPOINTS.VALIDATE_OP, {
-      path: pathArrayToString(path),
-      actions: channel.w_actions
-    });
-    return data;
-  };
-  const authenticate2 = async (transport, challenge, application, keyHandle, userName, role, workspace) => {
-    const data = await deviceNetwork("POST", ENDPOINTS.AUTHENTICATE, {
-      challenge: challenge.toString("hex"),
-      application,
-      key_handle: keyHandle.toString("hex"),
-      name: userName,
-      // @ts-ignore
-      role: ROLE_TO_BYTES[role.toLowerCase()].toString("hex"),
-      type: deviceTypeBufferFromPsdModel[__PSD_MODEL__].toString("hex"),
-      workspaceName: workspace
-    });
-    const response = Buffer.concat([Buffer.from(data, "hex"), Buffer.from("9000", "hex")]);
-    const userPresence = response.slice(0, 1);
-    const counter = response.slice(1, 5);
-    const signature = response.slice(5, response.length - 2).toString("hex");
-    return {
-      userPresence,
-      counter,
-      signature,
-      rawResponse: response.slice(0, response.length - 2).toString("hex")
-    };
-  };
-  const getUserID = async () => {
-    const { blue_device_id } = await deviceNetwork("POST", "/blue-device-id");
-    return blue_device_id.toUpperCase();
-  };
-  const initiatePairingHandshake = async () => {
-    return deviceNetwork("POST", ENDPOINTS.INITIATE_PAIRING_HANDSHAKE, {});
-  };
-  const finalizePairingHandshake = async (transport, handshake, ciphertext) => {
-    const data = {
-      handshake,
-      ciphertext
-    };
-    return deviceNetwork("POST", ENDPOINTS.FINALIZE_PAIRING_HANDSHAKE, data);
-  };
-  const startKpatternAsResponder = async (transport, scriptID, handshake, handshakeAttestation, partitionID) => {
-    const data = {
-      script_id: scriptID,
-      handshake,
-      // FIXME apparently for device-api it's normal to have empty string as handshake_attestation
-      handshake_attestation: "",
-      partition_id: partitionID
-    };
-    return deviceNetwork("POST", ENDPOINTS.START_K_PATTERN_AS_RESPONDER, data);
-  };
-  const hasPartitionID = async () => {
-    const partitionIDs = await deviceNetwork("POST", "/get-partition-ids");
-    return partitionIDs.length > 0;
-  };
-  const getConfidentialityKey = () => deviceNetwork("POST", "/get-confidentiality-key");
-  const updatePSDPartitionPairing = (p) => deviceNetwork("POST", "/set-partition-key", p.pairingData);
-  return {
-    getPsdModel: () => __PSD_MODEL__,
-    setPsdModel: (psdModel2) => __PSD_MODEL__ = psdModel2,
-    setSeed,
-    setSalt,
-    authenticate: authenticate2,
-    getAttestationCertificate,
-    getPublicKey,
-    getUserID,
-    register,
-    registerData,
-    switchDevice,
-    // NEW SECURE CHANNEL ENDPOINTS
-    validateVaultOperation,
-    initiatePairingHandshake,
-    finalizePairingHandshake,
-    startKpatternAsResponder,
-    hasPartitionID,
-    getConfidentialityKey,
-    updatePSDPartitionPairing
-  };
-}
-var isAPIDevice = (device) => {
-  return "getPsdModel" in device;
-};
-var createAPIDevice_default = createAPIDevice;
-
-// src/device/createHWDevice.ts
-import { TransportStatusError } from "@ledgerhq/hw-transport";
-import chalk2 from "chalk";
-import invariant from "invariant";
-import readline from "readline";
-
-// src/device/constants.ts
-var all61xxStatus = [];
-for (let i = 24832; i <= 25087; i++) {
-  all61xxStatus.push(i);
-}
-var PAGINATED_STATUS = all61xxStatus;
-var U2F_PATH = [2153139284, 2153067078];
-var CONFIDENTIALITY_PATH = [2153139284, 2151894598];
-var VALIDATION_PATH = [2153139284, 2153136460];
-var ACCOUNT_MANAGER_SESSION = 2;
-var STREAMING_RESPONSE = 2;
-var STREAMING_NEXT_ACTION = 1;
-var APPID_VAULT_ADMINISTRATOR = "ad5be1a1fe011ce7f53ae081a22ae000a42021f3f94106a3bac9f76e8230e4b9";
-
-// src/device/createHWDevice.ts
-var STATUS_LENGTH = 2;
-var MAX_CHUNK_LENGTH = 250;
-var removeStatus = (result) => result.slice(0, result.length - STATUS_LENGTH);
-var buildAttestation = (cliMsg, attestation, partitionID) => {
-  const sigBuffer = Buffer.from(attestation.signature, "base64");
-  const sigLengthBuffer = Buffer.alloc(1);
-  sigLengthBuffer.writeUIntBE(sigBuffer.length, 0, 1);
-  const certBuffer = Buffer.from(attestation.certificate, "base64");
-  const certLengthBuffer = Buffer.alloc(1);
-  certLengthBuffer.writeUIntBE(certBuffer.length, 0, 1);
-  const pubBuffer = Buffer.from(attestation.attestation_pub, "base64");
-  const certChainData = Buffer.concat([
-    sigLengthBuffer,
-    sigBuffer,
-    pubBuffer,
-    certLengthBuffer,
-    certBuffer
-  ]);
-  const cliMsgBuffer = Buffer.from(cliMsg, "hex");
-  const cliMsgLengthBuffer = Buffer.alloc(1);
-  cliMsgLengthBuffer.writeUIntBE(cliMsgBuffer.length, 0, 1);
-  const pidBuffer = Buffer.from(partitionID, "hex");
-  const pidLengthBuffer = Buffer.alloc(1);
-  pidLengthBuffer.writeUIntBE(pidBuffer.length, 0, 1);
-  const certChainDataLengthBuff = Buffer.alloc(2);
-  certChainDataLengthBuff.writeUInt16BE(certChainData.length, 0);
-  const data = Buffer.concat([
-    cliMsgLengthBuffer,
-    cliMsgBuffer,
-    certChainDataLengthBuff,
-    certChainData,
-    pidLengthBuffer,
-    pidBuffer
-  ]);
-  const totalLengthBuffer = Buffer.alloc(2);
-  totalLengthBuffer.writeUInt16BE(data.length, 0);
-  const toSend = Buffer.concat([totalLengthBuffer, data]);
-  return toSend;
-};
-function promptUserInput(query) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  return new Promise(
-    (resolve) => rl.question(query, (ans) => {
-      rl.close();
-      resolve(ans);
-    })
-  );
-}
-var splits = (chunk, buffer) => {
-  const chunks = [];
-  for (let i = 0, size = chunk; i < buffer.length; i += size, size = chunk) {
-    chunks.push(buffer.slice(i, i + size));
-  }
-  return chunks;
-};
-var sendByChunk = async (transport, command, data, chunkSize = MAX_CHUNK_LENGTH) => {
-  const chunks = splits(chunkSize, data);
-  let response = Buffer.from([]);
-  for (let i = 0; i < chunks.length; i++) {
-    const chunk = chunks[i];
-    const apdu = [...command];
-    apdu[2] = i && 128;
-    response = await transport.send(
-      apdu[0],
-      apdu[1],
-      apdu[2],
-      apdu[3],
-      chunk,
-      [36864, ...PAGINATED_STATUS]
-    );
-  }
-  return response;
-};
-var ROLE_TO_BYTES2 = {
-  shared_owner: Buffer.from([2]),
-  admin: Buffer.from([1]),
-  operator: Buffer.from([0])
-};
-function createHWDevice(options) {
-  const { promptToSwitch } = options;
-  const getPublicKey = async (transport, path, secp256k1 = true) => {
-    const data = Buffer.concat([
-      Buffer.from([path.length]),
-      ...path.map((derivation) => {
-        const buf = Buffer.alloc(4);
-        buf.writeUInt32BE(derivation, 0);
-        return buf;
-      })
-    ]);
-    let curve = 1;
-    if (!secp256k1) {
-      curve = 2;
-    }
-    const response = await transport.send(224, 64, curve, 0, data);
-    const pubKeyLength = response.readInt8(0);
-    const pubKey = response.slice(1, pubKeyLength + 1).toString("hex").toUpperCase();
-    const signature = response.slice(pubKeyLength + 1, response.length - STATUS_LENGTH);
-    return { pubKey, signature };
-  };
-  const registerData = async (transport, challenge) => {
-    invariant(challenge.length === 32, "challenge hex is expected to have 32 bytes");
-    const response = await transport.send(224, 3, 0, 0, challenge);
-    return removeStatus(response);
-  };
-  const register = async (transport, challenge, application, userName, userRole) => {
-    invariant(challenge.length === 32, "challenge hex is expected to have 32 bytes");
-    const applicationBuf = Buffer.from(application, "hex");
-    invariant(applicationBuf.length === 32, "application hex is expected to have 32 bytes");
-    const userNameBuff = Buffer.from(userName);
-    const keyHandleData = Buffer.concat([
-      ROLE_TO_BYTES2[userRole.toLowerCase()],
-      Buffer.from([userNameBuff.length]),
-      userNameBuff
-    ]);
-    const keyHandleDataLength = Buffer.alloc(2);
-    keyHandleDataLength.writeUInt16BE(keyHandleData.length, 0);
-    const data = Buffer.concat([challenge, applicationBuf, keyHandleDataLength, keyHandleData]);
-    const response = await sendByChunk(transport, [224, 1, 0, 0], data);
-    let i = 0;
-    const rfu = response.slice(i, i += 1)[0];
-    const pubKey = response.slice(i, i += 65).toString("hex");
-    const keyHandleLength = response.slice(i, ++i)[0];
-    const keyHandle = response.slice(i, i += keyHandleLength);
-    return {
-      u2f_register: removeStatus(response),
-      keyHandle,
-      rfu,
-      pubKey
-    };
-  };
-  const getAttestationCertificate = async (transport) => {
-    const response = await transport.send(224, 65, 0, 0);
-    return removeStatus(response);
-  };
-  const authenticate2 = async (transport, challenge, application, keyHandle, name, role, workspace) => {
-    invariant(challenge.length === 32, "challenge hex is expected to have 32 bytes");
-    const applicationBuf = Buffer.from(application, "hex");
-    invariant(applicationBuf.length === 32, "application hex is expected to have 32 bytes");
-    const nameBuf = Buffer.from(name);
-    const workspaceBuf = Buffer.from(workspace);
-    const roleBuf = ROLE_TO_BYTES2[role.toLowerCase()];
-    const keyHandleData = Buffer.concat([
-      roleBuf,
-      Buffer.from([nameBuf.length]),
-      nameBuf,
-      Buffer.from([workspaceBuf.length]),
-      workspaceBuf
-    ]);
-    const keyHandleDataLength = Buffer.alloc(2);
-    keyHandleDataLength.writeUInt16BE(keyHandleData.length, 0);
-    const data = Buffer.concat([
-      challenge,
-      applicationBuf,
-      Buffer.from([keyHandle.length]),
-      keyHandle,
-      keyHandleDataLength,
-      keyHandleData
-    ]);
-    const response = await sendByChunk(transport, [224, 2, 0, 0], data);
-    const userPresence = response.slice(0, 1);
-    const counter = response.slice(1, 5);
-    const signature = response.slice(5, response.length - STATUS_LENGTH).toString("hex");
-    return {
-      userPresence,
-      counter,
-      signature,
-      rawResponse: removeStatus(response).toString("hex")
-    };
-  };
-  const switchDevice = async () => {
-    if (promptToSwitch) {
-      await promptUserInput(
-        chalk2`{red.green [SWITCH DEVICE]} press {red ENTER} when the device is plugged on.`
-      );
-    }
-  };
-  const initiatePairingHandshake = async (transport) => {
-    const res = await transport.send(224, 70, 0, 0);
-    const pubKeyLength = res.readInt8(0);
-    const pubKey = res.slice(1, pubKeyLength + 1).toString("hex").toUpperCase();
-    const attestation = res.slice(pubKeyLength + 1, res.length - STATUS_LENGTH);
-    return { pubKey, attestation };
-  };
-  const validateVaultOperation = async (transport, path, channel) => {
-    const paths = Buffer.concat([
-      Buffer.from([path.length]),
-      ...path.map((derivation) => {
-        const buf = Buffer.alloc(4);
-        buf.writeUInt32BE(derivation, 0);
-        return buf;
-      })
-    ]);
-    let nextActionId = 1;
-    let finalResponse;
-    while (!finalResponse) {
-      const screen = Buffer.from(channel.w_actions[nextActionId - 1], "base64");
-      const length = Buffer.alloc(2);
-      length.writeUInt16BE(screen.length, 0);
-      const data = Buffer.concat([paths, length, screen]);
-      const response = await sendByChunk(transport, [224, 69, 0, 0], data);
-      const responseType = response.readInt8(0);
-      let responseStatus = response.readUInt16BE(response.length - 2);
-      if (responseType === STREAMING_NEXT_ACTION) {
-        nextActionId = response.readUIntBE(1, 2);
-      } else if (responseType === STREAMING_RESPONSE) {
-        finalResponse = response.slice(3, response.length - 2);
-        while (responseStatus !== 36864) {
-          const resp = await transport.send(0, 192, 0, 0);
-          responseStatus = resp.readUInt16BE(resp.length - 2);
-          finalResponse = Buffer.concat([finalResponse, removeStatus(resp)]);
-        }
-      } else {
-        throw Error(`${responseType}`);
-      }
-    }
-    return finalResponse.toString("base64");
-  };
-  const finalizePairingHandshake = async (transport, handshake, ciphertext, handshakeAttestation) => {
-    const response = await sendByChunk(
-      transport,
-      [224, 71, 0, 2],
-      buildAttestation(handshake, handshakeAttestation, ciphertext)
-    );
-    return removeStatus(response).toString("hex");
-  };
-  const startKpatternAsResponder = async (transport, scriptID, handshake, handshakeAttestation, partitionID) => {
-    const data = buildAttestation(handshake, handshakeAttestation, partitionID);
-    const response = await sendByChunk(transport, [224, 73, 0, scriptID], data);
-    return removeStatus(response).toString("hex");
-  };
-  const getUserID = () => Promise.resolve("");
-  const hasPartitionID = async ({ transport }) => {
-    const apdu = [224, 81, 0, 0, 181];
-    const res = await transport.exchange(Buffer.from(apdu));
-    const hex2 = Buffer.from(res).toString("hex");
-    return hex2 !== "6f45" && hex2 !== "6a87";
-  };
-  const getConfidentialityKey = async ({ transport }) => {
-    const apdu = [224, 77, 0, 0];
-    const bufWithStatus = await transport.send(...apdu);
-    const status = bufWithStatus.readUInt16BE(bufWithStatus.length - 2);
-    if (status !== 36864) {
-      throw new TransportStatusError(status);
-    }
-    const buf = removeStatus(bufWithStatus);
-    const keyLength = buf[0];
-    const key = buf.slice(1, 1 + keyLength);
-    const sig = buf.slice(1 + keyLength + 1);
-    const res = {
-      confidentiality_key_curve25519: key.toString("hex"),
-      confidentiality_key_signature: sig.toString("hex")
-    };
-    return res;
-  };
-  const updatePSDPartitionPairing = async ({
-    transport,
-    pairingData
-  }) => {
-    const psdPayload = Buffer.from(pairingData.blob, "base64");
-    const length = Buffer.alloc(2);
-    length.writeUInt16BE(psdPayload.length, 0);
-    const final = Buffer.concat([length, psdPayload]);
-    await sendByChunk(transport, [224, 78, 0, 0], final);
-  };
-  return {
-    authenticate: authenticate2,
-    switchDevice,
-    getAttestationCertificate,
-    getPublicKey,
-    register,
-    registerData,
-    initiatePairingHandshake,
-    validateVaultOperation,
-    finalizePairingHandshake,
-    startKpatternAsResponder,
-    getUserID,
-    hasPartitionID,
-    getConfidentialityKey,
-    updatePSDPartitionPairing
-  };
-}
-var createHWDevice_default = createHWDevice;
-
-// src/device/createInteractions.ts
-function noValidChannel(channels) {
-  const keys = Object.keys(channels);
-  return keys.length === 0 || keys.length === 1 && keys[0] === "success";
-}
-function buildCertif(attestation, signature) {
-  const certLen = attestation.readInt8(32 + 65 + 1);
-  return {
-    code_hash: attestation.slice(0, 32).toString("base64"),
-    attestation_pub: attestation.slice(32, 32 + 65).toString("base64"),
-    certificate: attestation.slice(32 + 65, 32 + 65 + 2 + certLen).toString("base64"),
-    signature: Buffer.from(signature, "hex").toString("base64")
-  };
-}
-function createInteractions(device) {
-  const {
-    getPublicKey,
-    getAttestationCertificate,
-    register,
-    registerData,
-    authenticate: authenticate2,
-    validateVaultOperation,
-    initiatePairingHandshake,
-    finalizePairingHandshake,
-    startKpatternAsResponder,
-    hasPartitionID,
-    getConfidentialityKey,
-    updatePSDPartitionPairing
-  } = device;
-  const initPairing = {
-    responseKey: "psd_ephemeral_pubkey",
-    action: ({ transport }) => initiatePairingHandshake(transport)
-  };
-  const getU2FPublicKey = {
-    responseKey: "u2f_key",
-    action: ({ transport }) => getPublicKey(transport, U2F_PATH, false)
-  };
-  const getSecureChannel = {
-    responseKey: "secure_channels",
-    action: async ({ request_id, network }) => network("GET", `/requests/${request_id}/challenge`, {})
-  };
-  const doStartKpatternAsResponder = {
-    responseKey: "start-k-pattern",
-    action: async ({ transport, secure_channels, u2f_key }) => {
-      if (noValidChannel(secure_channels)) {
-        throw new Error("Request finished");
-      }
-      const channel = secure_channels[u2f_key.pubKey.toUpperCase()];
-      if (!channel) {
-        throw new Error("No channel for device");
-      }
-      await startKpatternAsResponder(
-        transport,
-        ACCOUNT_MANAGER_SESSION,
-        channel.handshake,
-        channel.handshake_attestation,
-        channel.partition_id
-      );
-    }
-  };
-  const validateDevice = {
-    responseKey: "validate_device",
-    action: ({ transport, secure_channels, u2f_key }) => {
-      const channel = secure_channels[u2f_key.pubKey.toUpperCase()];
-      return validateVaultOperation(transport, VALIDATION_PATH, channel);
-    }
-  };
-  const validatePayload = {
-    responseKey: "validate_payload",
-    action: ({ secure_channels, u2f_key, validate_device }) => {
-      const channel = secure_channels[u2f_key.pubKey.toUpperCase()];
-      const handshake_attestation = {
-        code_hash: channel.handshake_attestation.code_hash,
-        attestation_pub: channel.handshake_attestation.attestation_pub,
-        certificate: channel.handshake_attestation.certificate,
-        signature: channel.handshake_attestation.signature
-      };
-      return Promise.resolve({
-        public_key: u2f_key.pubKey,
-        challenge_response: validate_device,
-        handshake: Buffer.from(channel.handshake, "hex").toString("base64"),
-        handshake_attestation
-      });
-    }
-  };
-  const postApproval = {
-    responseKey: "post",
-    action: async ({ request_id, u2f_key: { pubKey }, validate_payload, network }) => network("POST", `/requests/${request_id}/approve`, {
-      requestId: request_id,
-      ...validate_payload,
-      public_key: pubKey.toString("hex")
-    })
-  };
-  const postSimpleApproval = {
-    responseKey: "post",
-    action: async ({ request_id, u2f_key: { pubKey }, network }) => network("POST", `/requests/${request_id}/approve`, {
-      requestId: request_id,
-      public_key: pubKey.toString("hex")
-    })
-  };
-  const getConfidentialityPublicKey = {
-    responseKey: "confidentiality_key",
-    action: ({ transport }) => getPublicKey(transport, CONFIDENTIALITY_PATH)
-  };
-  const getAttestation = {
-    responseKey: "attestation",
-    action: ({ transport }) => getAttestationCertificate(transport)
-  };
-  const getU2FChallenge = {
-    responseKey: "u2f_challenge",
-    action: async ({ u2f_key: { pubKey }, network }) => {
-      const challenge = await network("GET", `/u2f/authentications/${pubKey}/challenge`);
-      if (!challenge.key_handle) {
-        throw new Error("Unknown device");
-      }
-      return challenge;
-    }
-  };
-  const getValidationPublicKey = {
-    responseKey: "validation_key",
-    action: ({ transport }) => getPublicKey(transport, VALIDATION_PATH)
-  };
-  const u2fAuthenticate = {
-    device: true,
-    responseKey: "u2f_authenticate",
-    action: ({ transport, u2f_challenge: { challenge, key_handle, role, name }, workspace }) => authenticate2(
-      transport,
-      Buffer.from(challenge, "base64"),
-      APPID_VAULT_ADMINISTRATOR,
-      Buffer.from(key_handle, "hex"),
-      name,
-      role,
-      workspace
-    )
-  };
-  const readOnlyLogin = (username) => ({
-    responseKey: "u2f_sign",
-    action: async ({ network }) => {
-      const gateUsers = await network("GET", "/dev/people/pub_keys");
-      const currentUser = gateUsers.find((u) => u.username === username);
-      if (!currentUser) {
-        throw new Error(`Can't find user ${username}`);
-      }
-      return network("POST", `/dev/authentication/view_only/${currentUser.pub_key}`);
-    }
-  });
-  const postU2FSignature = {
-    responseKey: "u2f_sign",
-    action: ({ u2f_authenticate, network }) => network("POST", `/u2f/authentications/authenticate`, {
-      authentication: u2f_authenticate.rawResponse
-    })
-  };
-  const finalizePairing = {
-    responseKey: "pairing_payload",
-    action: ({ onboardingRegisterChallenge, transport, u2f_key }) => {
-      const secure_channel = extractSecureChannel(
-        onboardingRegisterChallenge,
-        u2f_key.pubKey.toUpperCase()
-      );
-      return finalizePairingHandshake(
-        transport,
-        secure_channel.handshake,
-        secure_channel.ciphertext,
-        secure_channel.handshake_attestation
-      );
-    }
-  };
-  const onboardingRegisterDevice = {
-    responseKey: "u2f_register",
-    action: async ({ u2f_key, onboardingRegisterChallenge, role, username, transport }) => {
-      const secure_channel = extractSecureChannel(
-        onboardingRegisterChallenge,
-        u2f_key.pubKey.toUpperCase()
-      );
-      return register(
-        transport,
-        Buffer.from(secure_channel.challenge, "hex"),
-        APPID_VAULT_ADMINISTRATOR,
-        username,
-        role,
-        secure_channel.u2f_register_data
-      );
-    }
-  };
-  const onboardingRegisterData = {
-    responseKey: "register_data",
-    action: ({ transport, u2f_key, onboardingRegisterChallenge }) => {
-      const register_challenge = onboardingRegisterChallenge[u2f_key.pubKey.toString("hex").toUpperCase()] || onboardingRegisterChallenge;
-      return registerData(transport, Buffer.from(register_challenge.challenge, "hex"));
-    }
-  };
-  const onboardingPostResult = {
-    responseKey: "register_input",
-    action: ({
-      register_data,
-      pairing_payload,
-      validation_key,
-      u2f_register,
-      attestation,
-      u2f_key
-    }) => {
-      const attestationOffset = 67 + u2f_register.u2f_register.readInt8(66);
-      const registration_payload = Buffer.concat([
-        u2f_register.u2f_register.slice(0, attestationOffset),
-        Buffer.from([attestation.length]),
-        attestation,
-        u2f_register.u2f_register.slice(attestationOffset)
-      ]);
-      const data = {
-        public_key: u2f_key.pubKey.toString("hex"),
-        key_handle: u2f_register.keyHandle.toString("hex"),
-        validation_key: validation_key.pubKey.toString("hex"),
-        register_data: register_data.toString("hex"),
-        u2f_register: registration_payload.toString("hex"),
-        certificate: buildCertif(attestation, validation_key.signature),
-        pairing_payload
-      };
-      return Promise.resolve(data);
-    }
-  };
-  const postUserRegistration = {
-    responseKey: "result",
-    action: ({ urlID, register_input, member, network }) => network("POST", `/requests/registration/${urlID}/authenticate`, {
-      ...register_input,
-      name: member.user.username
-    })
-  };
-  const operatorGetChallenge = {
-    responseKey: "onboardingRegisterChallenge",
-    action: ({
-      u2f_key,
-      confidentiality_key,
-      attestation,
-      urlID,
-      network,
-      psd_ephemeral_pubkey
-    }) => {
-      const data = {
-        public_key: u2f_key.pubKey,
-        confidentiality_key: confidentiality_key.pubKey,
-        ...isAPIDevice(device) && device.getPsdModel() === "STAX" ? { device_type: "02" } : (
-          /* istanbul ignore next */
-          {}
-        ),
-        ...{
-          psd_ephemeral_key: psd_ephemeral_pubkey.pubKey,
-          psd_ephemeral_key_attestation: buildCertif(attestation, psd_ephemeral_pubkey.attestation)
-        }
-      };
-      return network("POST", `/requests/registration/${urlID}/challenge`, data);
-    }
-  };
-  const ensurePartitionPairing = {
-    responseKey: "hasPairing",
-    action: async ({ transport, network }) => {
-      if (!await hasPartitionID({ transport })) {
-        const payload = await getConfidentialityKey({ transport });
-        const url = "/authentications/prepare-psd-key-update";
-        const pairingData = await network("POST", url, payload);
-        await updatePSDPartitionPairing({ transport, pairingData });
-      }
-      return true;
-    }
-  };
-  const validateOperation = [
-    getU2FPublicKey,
-    doStartKpatternAsResponder,
-    validateDevice,
-    validatePayload
-  ];
-  const approveFlow = [getSecureChannel, ...validateOperation, postApproval];
-  const approveFlowWithoutHSM = [postSimpleApproval];
-  const loginFlow = [
-    getU2FPublicKey,
-    getU2FChallenge,
-    u2fAuthenticate,
-    postU2FSignature,
-    ensurePartitionPairing
-  ];
-  const readOnlyLoginFlow = (username) => [readOnlyLogin(username)];
-  const registerUserFlow = [
-    getAttestation,
-    getU2FPublicKey,
-    getConfidentialityPublicKey,
-    initPairing,
-    operatorGetChallenge,
-    finalizePairing,
-    onboardingRegisterDevice,
-    getValidationPublicKey,
-    onboardingRegisterData,
-    onboardingPostResult,
-    postUserRegistration
-  ];
-  return {
-    approveFlow,
-    approveFlowWithoutHSM,
-    doStartKpatternAsResponder,
-    getSecureChannel,
-    getU2FChallenge,
-    getU2FPublicKey,
-    initPairing,
-    loginFlow,
-    readOnlyLoginFlow,
-    registerUserFlow,
-    u2fAuthenticate,
-    validateOperation,
-    ensurePartitionPairing,
-    finalizePairing,
-    getAttestation,
-    getConfidentialityPublicKey,
-    getValidationPublicKey,
-    operatorGetChallenge,
-    postU2FSignature,
-    postUserRegistration,
-    validateDevice,
-    validatePayload,
-    postApproval,
-    postSimpleApproval
-  };
-}
-
-// src/createDevicesPool.ts
-var createDevicesPool = (options, { logger = SILENT_LOGGER4 } = {}) => {
-  const {
-    salt = "",
-    gate,
-    apiGateway,
-    overrideSeeds,
-    lamURL,
-    lamAPIKey,
-    notifierURL,
-    deviceAPISessionID,
-    networkDelay,
-    readOnlyUser,
-    transport = "software",
-    recordStore,
-    deviceAPIURL,
-    psdModel = "STAX"
-  } = options;
-  let adminDevicesCache = [];
-  const device = transport === "software" ? createAPIDevice_default({
-    deviceAPISessionID,
-    salt,
-    overrideSeeds,
-    deviceAPIURL,
-    psdModel
-  }) : createHWDevice_default({ promptToSwitch: transport !== "nodehid-replayer" });
-  const setSalt = (salt2) => {
-    invariant2(
-      transport === "software",
-      `Tried to use \`setSalt\` with transport not being "software"`
-    );
-    const apiDevice = device;
-    apiDevice.setSalt(salt2);
-  };
-  const interactions = createInteractions(device);
-  let deviceRun = createRunner(interactions, {
-    readOnly: !!readOnlyUser,
-    transport,
-    recordStore
-  });
-  const { loginFlow, readOnlyLoginFlow, registerUserFlow, approveFlow, approveFlowWithoutHSM } = interactions;
-  const workspace = getWorkspaceFromGate(gate);
-  const network = createNetwork({
-    baseURL: gate,
-    networkDelay
-  });
-  const runWithDevice = async (deviceIndex, interactions2, data) => {
-    await device.switchDevice(deviceIndex);
-    invariant2(deviceRun, "deviceRun not initialized");
-    return deviceRun(interactions2, data);
-  };
-  const getUserID = async (deviceIndex) => {
-    await device.switchDevice(deviceIndex);
-    return device.getUserID();
-  };
-  const registerDevice = async (deviceIndex, request) => {
-    const data = {
-      network,
-      workspace,
-      username: request.user.username,
-      role: request.user.role.toLowerCase(),
-      // FIXME absolutely wrong name (legacy code)
-      member: request,
-      urlID: request.url_id
-    };
-    return runWithDevice(deviceIndex, registerUserFlow, data);
-  };
-  const tokensByDeviceIndex = {};
-  const login = async (deviceIndex) => {
-    const isReadOnlyUser = typeof deviceIndex === "string" || !!readOnlyUser;
-    deviceRun = createRunner(interactions, {
-      readOnly: isReadOnlyUser,
-      transport,
-      recordStore
-    });
-    if (typeof deviceIndex === "number") {
-      await device.switchDevice(deviceIndex);
-    }
-    let _token = tokensByDeviceIndex[deviceIndex] || null;
-    const interceptToken = (token) => {
-      tokensByDeviceIndex[deviceIndex] = token;
-      _token = token;
-    };
-    const injectToken = () => _token;
-    if (!_token || process.env.NODE_ENV === "test") {
-      const network2 = createNetwork({
-        baseURL: gate,
-        interceptToken,
-        injectToken,
-        networkDelay
-      });
-      await deviceRun(
-        typeof deviceIndex === "string" ? readOnlyLoginFlow(deviceIndex) : readOnlyUser ? readOnlyLoginFlow(readOnlyUser) : loginFlow,
-        { network: network2, workspace }
-      );
-      if (!_token) {
-        throw new Error("Could not extract token from login");
-      }
-    }
-    const authNetwork = createNetwork({
-      baseURL: gate,
-      token: _token,
-      networkDelay
-    });
-    const authRun = async (interactions2, data) => {
-      if (typeof deviceIndex === "number") {
-        await runWithDevice(deviceIndex, interactions2, data);
-      } else {
-        throw new Error(`Can't authRun on read-only mode (deviceIdentifier: ${deviceIndex})`);
-      }
-    };
-    const post = async (url, payload) => authNetwork("POST", url, payload);
-    const rejectRequest = async (requestID) => post(`/requests/${requestID}/abort`, {});
-    const approveRequest = (request) => authRun(approveFlow, { request_id: request.id, network: authNetwork });
-    const approveRequestWithoutHSM = (request) => authRun(approveFlowWithoutHSM, {
-      request_id: request.id,
-      network: authNetwork
-    });
-    let socket = null;
-    return {
-      network: authNetwork,
-      run: authRun,
-      get: async (url, requestOptions) => authNetwork("GET", url, void 0, requestOptions),
-      post,
-      rejectRequest,
-      approveRequest,
-      approveRequestWithoutHSM,
-      getToken: () => _token,
-      connectSocket: async () => {
-        if (!socket) {
-          if (!notifierURL) {
-            throw new Error("No notifierURL specified");
-          }
-          if (!_token) {
-            throw new Error("No token");
-          }
-          socket = createSocket(_token, notifierURL);
-          const { pub_key } = await authNetwork("GET", "/people/me");
-          socket.emit("join", { username: pub_key, workspace });
-          logger.success("Socket connected");
-        }
-        return socket;
-      },
-      onEvent: (cb) => {
-        if (!socket) {
-          throw new Error("Call connectSocket() first");
-        }
-        socket.on("notification", cb);
-      }
-    };
-  };
-  const bruteforceDeviceIndex = async (userID) => {
-    for (let i = 1; i < 100; i++) {
-      const found = await getUserID(i);
-      if (found.toUpperCase() === userID.toUpperCase()) return i;
-    }
-    throw new Error(`Could not find device index for user ${userID}`);
-  };
-  async function getOnboardingAdminDevices() {
-    if (adminDevicesCache.length > 0) return adminDevicesCache;
-    adminDevicesCache = [
-      ["Admin 1", 4],
-      ["Admin 2", 5],
-      ["Admin 3", 6]
-    ];
-    return adminDevicesCache;
-  }
-  const collectQuorumDevices = async () => {
-    const devices = adminDevicesCache.map((adminDevice) => adminDevice[1]).slice(0, 2);
-    const admin = await login(devices[0]);
-    const org = await admin.get("/organization", {});
-    const { quorum } = org;
-    if (quorum > 2) {
-      const adminsC = await admin.get(
-        "/people?status=ACTIVE&role=ADMIN&pageSize=-1",
-        {}
-      );
-      let admins = adminsC.edges.map((e) => e.node);
-      admins.sort((a, b) => a.id > b.id ? 1 : -1);
-      admins = admins.slice(2, quorum);
-      for (const adm of admins) {
-        const deviceIndex = await bruteforceDeviceIndex(adm.user_id);
-        devices.push(deviceIndex);
-      }
-    }
-    return devices;
-  };
-  const runWithQuorum = async (iteratee) => {
-    const devices = await collectQuorumDevices();
-    for (let i = 0; i < devices.length; i++) {
-      const device2 = devices[i];
-      if (!device2) throw new Error("Invalid device");
-      const admin = await login(device2);
-      try {
-        await iteratee(admin);
-      } catch (err) {
-        const reqAlreadyExistsErr = "REQUEST_ALREADY_APPROVED_OR_ABORTED_BY_THIS_MEMBER_EXCEPTION";
-        if (err.name === reqAlreadyExistsErr) continue;
-        throw err;
-      }
-    }
-  };
-  const apiNetwork = createNetwork({
-    baseURL: lamURL || "",
-    networkDelay
-  });
-  const headersAPILam = lamAPIKey ? { headers: { "X-Ledger-API-Key": lamAPIKey } } : {};
-  const createInvitation = async (name) => {
-    try {
-      const r = await apiNetwork("POST", `/api_users/${name}`, {}, headersAPILam);
-      return r;
-    } catch (e) {
-      return apiNetwork("GET", `/api_users/${name}`, {}, headersAPILam);
-    }
-  };
-  const registerUser = async (name, uuid) => {
-    return apiNetwork("POST", `/api_users/${name}/register/${uuid}`, {}, headersAPILam);
-  };
-  const lamAPI = {
-    createInvitation,
-    registerUser
-  };
-  const createSocket = (token, notifierURL2) => {
-    const client = io(notifierURL2, {
-      transportOptions: {
-        polling: {
-          extraHeaders: {
-            Cookie: `ledger_workspace=${workspace}; ledger_token=${token}`
-          }
-        }
-      }
-    });
-    return client;
-  };
-  const getRevaultCompatOptions = () => {
-    return {
-      workspace,
-      deviceApiUrl: deviceAPIURL ?? process.env.VAULT_DEVICE_API_URL ?? "https://localhost:8443/device-api",
-      salt
-    };
-  };
-  return {
-    getRevaultCompatOptions,
-    workspace,
-    network,
-    gate,
-    apiGateway,
-    login,
-    lamAPI,
-    getUserID,
-    bruteforceDeviceIndex,
-    setSalt,
-    registerDevice,
-    runWithDevice,
-    runWithQuorum,
-    device,
-    interactions,
-    getOnboardingAdminDevices,
-    psdModel
-  };
-};
-var createDevicesPool_default = createDevicesPool;
-
-// src/createFaucet.ts
-var createPralineFaucet = (url) => async (opts) => {
-  const network = createNetwork({
-    baseURL: url
-  });
-  const { recipient, amount } = opts;
-  const endpoint = `/chain/faucet/${recipient}/${amount}`;
-  const res = await network("POST", endpoint);
-  return res.tx;
-};
-function createFaucet(opts) {
-  const implems = {};
-  if (opts.pralineBTCTestnetURL) {
-    implems["bitcoin_testnet"] = createPralineFaucet(opts.pralineBTCTestnetURL);
-  }
-  const faucet = (opts2) => {
-    const { currency, ...rest } = opts2;
-    const implem = implems[currency];
-    if (!implem) {
-      throw new Error(`Unsupported faucet currency ${opts2.currency}`);
-    }
-    return implem(rest);
-  };
-  return faucet;
-}
-var createFaucet_default = createFaucet;
-
-// src/createPledge.ts
-import { SILENT_LOGGER as SILENT_LOGGER5 } from "@ledgerhq/vault-utils";
-async function createPledge({
-  pool,
-  account,
-  accountsByName,
-  exchange,
-  amount,
-  apiUser,
-  gate,
-  apiGateway
-}, { logger = SILENT_LOGGER5 } = {}) {
-  const gateAccount = accountsByName[account.name];
-  if (!gateAccount) throw new Error(`Can't find account with name ${account.name}`);
-  const apiNetwork = createNetwork({
-    baseURL: apiGateway
-  });
-  logger.info(`Authenticate for ${apiUser.name}`);
-  const workspace = getWorkspaceFromGate(gate);
-  const bearerToken = await authenticate(pool, apiNetwork, workspace, apiUser, logger);
-  const pledge = await getTradelinkPledge({
-    apiNetwork,
-    workspace,
-    gateAccount,
-    bearerToken,
-    exchange
-  });
-  logger.info("Create pledge");
-  let tokens = [];
-  const shouldLoadTokens = !!gateAccount.contract_address;
-  if (shouldLoadTokens) {
-    const admin = await pool.login(4);
-    tokens = await fetchTokens_default(admin, { logger });
-  }
-  const unit = getAccountUnit(account, tokens);
-  const serializedAmount = serializeUnitValue(unit, amount);
-  const data = {
-    type: "CREATE_PLEDGE_INCREMENT",
-    data: {
-      pledge_subaccount_id: pledge.pledge_subaccount_id,
-      pledge_data: {
-        amount: serializedAmount,
-        account_name: account.name,
-        currency: gateAccount.currency,
-        exchange_name: exchange
-      }
-    }
-  };
-  if (shouldLoadTokens) {
-    data.data.pledge_data.contract_address = gateAccount.contract_address;
-  }
-  const pledgeRequestResp = await apiNetwork("POST", "/requests", data, {
-    headers: {
-      "X-Ledger-Workspace": workspace,
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${bearerToken}`
-    }
-  });
-  logger.info(`Approving pledge ${pledgeRequestResp.id}`);
-  logger.info("Decode challenge");
-  const apiChallenge = await decodeChallenge({
-    apiNetwork,
-    workspace,
-    bearerToken,
-    requestID: pledgeRequestResp.id,
-    reviewType: "APPROVE"
-  });
-  logger.info(apiChallenge.decodedChallenge);
-  logger.info("Sign and approve");
-  return await signAndApprove({
-    apiNetwork,
-    workspace,
-    bearerToken,
-    requestID: pledgeRequestResp.id,
-    apiUser,
-    challenge: apiChallenge.challenge,
-    reviewType: "APPROVE"
-  });
-}
-var createPledge_default = createPledge;
-
-// src/createSettlement.ts
-import { SILENT_LOGGER as SILENT_LOGGER6 } from "@ledgerhq/vault-utils";
-import { v4 as uuidv4 } from "uuid";
-async function createSettlement({
-  pool,
-  account,
-  accountsByName,
-  exchange,
-  percentage,
-  apiUser,
-  gate,
-  apiGateway
-}, { logger = SILENT_LOGGER6 } = {}) {
-  const gateAccount = accountsByName[account.name];
-  if (!gateAccount) throw new Error(`Can't find account with name ${account.name}`);
-  const apiNetwork = createNetwork({
-    baseURL: apiGateway
-  });
-  logger.info(`Authenticate for ${apiUser.name}`);
-  const workspace = getWorkspaceFromGate(gate);
-  const bearerToken = await authenticate(pool, apiNetwork, workspace, apiUser, logger);
-  const pledge = await getTradelinkPledge({
-    apiNetwork,
-    workspace,
-    gateAccount,
-    bearerToken,
-    exchange
-  });
-  const recipient = await getTradelinkRecipient({ pool, gateAccount, pledge });
-  const settlementAmount = Math.floor(pledge.amount * percentage / 100);
-  let txIntent = {
-    account_id: gateAccount.id,
-    fees_strategy: {
-      type: "SPEED",
-      data: {
-        speed: "FAST"
-      }
-    },
-    transaction_data: {
-      account_name: gateAccount.name,
-      amount: String(settlementAmount),
-      max_fees: "0",
-      recipient
-    }
-  };
-  if (gateAccount.account_type === "Ethereum" || gateAccount.account_type === "Erc20") {
-    txIntent = {
-      ...txIntent,
-      transaction_data: {
-        ...txIntent.transaction_data,
-        currency: gateAccount.currency
-      },
-      transaction_type: "ETHEREUM_LIKE_SEND"
-    };
-  } else {
-    throw new Error("Unsupported account type for outbound transactions");
-  }
-  const maxFeesResp = await apiNetwork(
-    "POST",
-    "/transactions/estimate-fees",
-    {
-      type: "CREATE_TRANSACTION",
-      data: txIntent
-    },
-    {
-      headers: {
-        "X-Ledger-Workspace": workspace,
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${bearerToken}`
-      }
-    }
-  );
-  txIntent.transaction_data.max_fees = maxFeesResp.max_fees;
-  const settlementIntent = {
-    id: String(uuidv4()),
-    from_pledge_id: pledge.id,
-    inbound_transaction_intent: null,
-    outbound_transaction_intent: txIntent,
-    meta: {}
-  };
-  logger.info("Post settlement");
-  return await apiNetwork("POST", "/settlements", settlementIntent, {
-    headers: {
-      "X-Ledger-Workspace": workspace,
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${bearerToken}`
-    }
-  });
-}
-var createSettlement_default = createSettlement;
-
-// src/deployInstance.ts
-import { SILENT_LOGGER as SILENT_LOGGER7 } from "@ledgerhq/vault-utils";
-import duration from "humanize-duration";
-import isEqual2 from "lodash/isEqual";
-import io2 from "socket.io-client";
-
-// src/constants.ts
-var DEFAULT_VAULT_REMOTE_URL = "https://remote.minivault.ledger-sbx.com";
-var DEFAULT_SPAWN_WATCH_TIMEOUT_MINUTES = 10;
-
-// src/deployInstance.ts
-var toSimplifiedState = (deployment) => {
-  return {
-    error: deployment.error,
-    status: deployment.status,
-    currentStep: deployment.currentStep,
-    totalPods: deployment.instance.pods.length,
-    totalHealthyPods: deployment.instance.pods.filter(
-      // TODO centralize types with vault-remote
-      (p) => p.status === "HEALTHY"
-    ).length
-  };
-};
-async function deploy(opts, { logger = SILENT_LOGGER7 } = {}) {
-  const {
-    remoteURL = DEFAULT_VAULT_REMOTE_URL,
-    watchTimeoutMinutes = DEFAULT_SPAWN_WATCH_TIMEOUT_MINUTES,
-    useHTTPPolling = false,
-    ...payload
-  } = opts;
-  const now = Date.now();
-  logger.step(`Deploying ${payload.name}`);
-  const url = remoteURL.replace(/https:\/\/(.*?)\./, `https://${payload.name}.`);
-  const network = createNetwork({ baseURL: `${remoteURL}/api` });
-  const deployment = await network("POST", "/deploy", payload);
-  const gateURL = `https://${deployment.instance.name}.${deployment.instance.host}/gate/minivault`;
-  const gateNetwork = createNetwork({ baseURL: gateURL });
-  let state = toSimplifiedState(deployment);
-  const logState = () => {
-    const step = deployment.steps.find((s) => s.key === state.currentStep);
-    logger.info(`[${step.labelCurrent}] (${state.totalHealthyPods}/${state.totalPods})`);
-  };
-  let resolve = null, reject = null;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  const deployTimeout = setTimeout(
-    () => reject(new Error(`Waited for ${watchTimeoutMinutes}min, too long, exiting`)),
-    watchTimeoutMinutes * 60 * 1e3
-  );
-  const onState = (p) => {
-    const newState = toSimplifiedState(p);
-    if (!isEqual2(state, newState)) {
-      state = newState;
-      logState();
-    }
-    if (newState.error) {
-      reject(newState.error);
-    } else if (newState.status === "SUCCESS") {
-      const elapsed = Date.now() - now;
-      const displayDuration = duration(elapsed, { round: true });
-      logger.success(`Successfully deployed instance in ${displayDuration}`);
-      logger.success(url);
-      clearTimeout(deployTimeout);
-      resolve();
-    }
-  };
-  async function pollGate() {
-    try {
-      logger.info(`Polling onboarding state on ${gateURL}/onboarding/state ...`);
-      await gateNetwork("GET", "/onboarding/state");
-      resolve();
-    } catch {
-      await wait(3e3);
-      pollGate();
-    }
-  }
-  if (useHTTPPolling) {
-    logger.info("Using HTTP polling strategy (will not output deployment steps)");
-    logger.info("Waiting 30 seconds for domain to be deployed...");
-    await wait(3e4);
-    logger.info("Waiting for Gate to be ready...");
-    pollGate();
-  } else {
-    logState();
-    const socket = io2(remoteURL, { transports: ["polling"] });
-    socket.on("deployment-state", onState);
-    socket.emit("join-deployment", deployment.id);
-    socket.on("disconnect", () => {
-      reject(new Error("Socket disconnected!"));
-    });
-  }
-  await promise;
-  return { url };
-}
-
-// src/destroy.ts
-import { SILENT_LOGGER as SILENT_LOGGER8 } from "@ledgerhq/vault-utils";
-async function destroy(opts, { logger = SILENT_LOGGER8 } = {}) {
-  const { remoteURL = DEFAULT_VAULT_REMOTE_URL, name } = opts;
-  const network = createNetwork({ baseURL: `${remoteURL}/api` });
-  await network("DELETE", `/instances/${name}`);
-  logger.success(`Successfully destroyed instance ${name}`);
-  if (opts.wait) {
-    logger.info("Waiting for namespace to disappear...");
-    while (await isInstanceAlive(name)) {
-      await new Promise((r) => setTimeout(r, 2e3));
-    }
-    logger.info("Done");
-  }
-  async function isInstanceAlive(name2) {
-    try {
-      await network("GET", `/instances/${name2}`);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-}
-
-// src/getMVInstances.ts
-import { SILENT_LOGGER as SILENT_LOGGER9 } from "@ledgerhq/vault-utils";
-async function getMVInstances(opts, { logger = SILENT_LOGGER9 } = {}) {
-  const { remoteURL = DEFAULT_VAULT_REMOTE_URL } = opts;
-  logger.info("Fetching instances...");
-  const network = createNetwork({ baseURL: `${remoteURL}/api` });
-  const instances = await network("GET", "/instances");
-  return instances;
-}
-
-// src/send.ts
-import { SILENT_LOGGER as SILENT_LOGGER10 } from "@ledgerhq/vault-utils";
-import BigNumber from "bignumber.js";
-var SUPPORTED_ACCOUNT_TYPES = [
-  "Bitcoin",
-  "Ethereum",
-  "Tezos",
-  "Polkadot",
-  "Stellar",
-  "Erc20",
-  "Solana"
-];
-async function send({
-  pool,
-  transaction,
-  account,
-  accountsByName,
-  whitelistsByName,
-  noApproval,
-  groups = []
-}, { logger = SILENT_LOGGER10 } = {}) {
-  const gateAccount = accountsByName[account.name];
-  if (!gateAccount) throw new Error(`Can't find account with name ${account.name}`);
-  if (transaction.feesLevel === "CUSTOM" && gateAccount.account_type !== "Ethereum" && gateAccount.account_type !== "Erc20") {
-    throw new Error("Custom fees are only supported for Ethereum and ERC20 accounts");
-  }
-  if (transaction.feesLevel === "CUSTOM" && (!transaction.gasPrice || !transaction.gasLimit)) {
-    throw new Error("Gas price and gas limit are required when using custom fees");
-  }
-  if (SUPPORTED_ACCOUNT_TYPES.indexOf(gateAccount.account_type) === -1) {
-    throw new Error(`Account type ${gateAccount.account_type} is not supported YET`);
-  }
-  let tokens = [];
-  const shouldLoadTokens = !!gateAccount.contract_address;
-  if (shouldLoadTokens) {
-    const admin = await pool.login(4);
-    tokens = await fetchTokens_default(admin, { logger });
-  }
-  const unit = getAccountUnit(account, tokens);
-  const serializedAmount = serializeUnitValue(unit, transaction.amount);
-  const matchingRule = getMatchingMultiAuthRule({
-    account,
-    transaction,
-    whitelistsByName
-  });
-  const { steps } = matchingRule;
-  const usedUsers = [];
-  const firstStep = steps[0];
-  if (!firstStep) throw new Error(`No creator step found`);
-  const creator = await loginWithStepUser({ pool, groups, step: firstStep, usedUsers });
-  const feesPayload = {
-    amount: serializedAmount,
-    recipient: transaction.recipient,
-    fees_level: transaction.feesLevel || "NORMAL",
-    ...transaction.transactionType ? { type: transaction.transactionType } : {}
-  };
-  if (gateAccount.account_type === "Bitcoin" && transaction.utxosPickingStrategy) {
-    Object.assign(feesPayload, {
-      utxo_picking_strategy: transaction.utxosPickingStrategy
-    });
-  }
-  let fees = {
-    fees_per_byte: "0",
-    fees: transaction.feesLevel || "NORMAL",
-    gas_limit: transaction.gasLimit,
-    gas_price: transaction.gasPrice
-  };
-  let feesEIP1559 = {
-    base_fees: transaction.feesLevel || "NORMAL",
-    gas_limit: transaction.gasLimit,
-    max_fees: transaction.maxFees,
-    max_fees_buffer_factor: transaction.maxFeesBufferFactor,
-    priority_fees: transaction.priorityFees
-  };
-  if (transaction.feesLevel !== "CUSTOM") {
-    const feesResponse = await creator.network(
-      "POST",
-      `/accounts/${gateAccount.id}/transactions/fees`,
-      feesPayload
-    );
-    "priority_fees" in feesResponse ? feesEIP1559 = feesResponse : fees = feesResponse;
-  }
-  let txFees = {};
-  if ((gateAccount.account_type === "Ethereum" || gateAccount.account_type === "Erc20") && !feesEIP1559.priority_fees) {
-    txFees = {
-      fees_level: feesPayload.fees_level,
-      max_fees: new BigNumber(fees.gas_price).times(fees.gas_limit).toFixed(),
-      gas_price: new BigNumber(fees.gas_price).toFixed(),
-      gas_limit: new BigNumber(fees.gas_limit).toFixed()
-    };
-  }
-  if ((gateAccount.account_type === "Ethereum" || gateAccount.account_type === "Erc20") && feesEIP1559.priority_fees) {
-    txFees = {
-      fees_level: feesPayload.fees_level,
-      max_fees: new BigNumber(feesEIP1559.max_fees).toFixed(),
-      gas_limit: new BigNumber(feesEIP1559.gas_limit).toFixed(),
-      priority_fees: new BigNumber(feesEIP1559.priority_fees).toFixed(),
-      max_fees_buffer_factor: new BigNumber(feesEIP1559.max_fees_buffer_factor).toFixed()
-    };
-  }
-  if (gateAccount.account_type === "Bitcoin") {
-    txFees = {
-      fees_level: feesPayload.fees_level,
-      fees_per_byte: new BigNumber(fees.fees_per_byte).toFixed(),
-      max_fees: new BigNumber(fees.fees).toFixed()
-    };
-    if (transaction.utxosPickingStrategy) {
-      Object.assign(txFees, {
-        utxo_picking_strategy: transaction.utxosPickingStrategy
-      });
-    }
-  }
-  if (gateAccount.account_type === "Tezos") {
-    txFees = {
-      fees_level: feesPayload.fees_level,
-      gas_limit: new BigNumber(fees.gas_limit).toFixed(),
-      max_fees: new BigNumber(fees.fees).toFixed(),
-      storage_limit: fees.storage_limit
-    };
-  }
-  if (gateAccount.account_type === "Polkadot") {
-    txFees = {
-      fees_level: feesPayload.fees_level,
-      max_fees: new BigNumber(fees.fees).toFixed()
-    };
-  }
-  if (gateAccount.account_type === "Stellar") {
-    txFees = {
-      fees_level: feesPayload.fees_level,
-      max_fees: new BigNumber(fees.fees).toFixed()
-    };
-  }
-  if (gateAccount.account_type === "Solana") {
-    txFees = {
-      fees_level: feesPayload.fees_level,
-      max_fees: new BigNumber(fees.fees).toFixed()
-    };
-  }
-  const payload = {
-    type: "CREATE_TRANSACTION",
-    account_id: gateAccount.id,
-    transaction: {
-      ...transaction.transactionType ? { type: transaction.transactionType } : {},
-      recipient: transaction.recipient,
-      amount: serializedAmount,
-      ...txFees
-    }
-  };
-  if (transaction.contractPayload) {
-    Object.assign(payload.transaction, {
-      contract_payload: transaction.contractPayload
-    });
-  }
-  if (transaction.title || transaction.comment) {
-    Object.assign(payload.transaction, {
-      note: {
-        title: transaction.title || "",
-        content: transaction.comment || ""
-      }
-    });
-  }
-  logger.info("Creating transaction request");
-  const request = await creator.post("/requests", payload);
-  if (noApproval) {
-    logger.info("Transaction created (skipped approval)");
-  } else {
-    logger.info("Approving request");
-    await creator.approveRequest(request);
-    for (let i = 1; i < steps.length; i++) {
-      const step = steps[i];
-      if (!step) throw new Error(`No step at index ${i}`);
-      for (let j = 0; j < step.quorum; j++) {
-        const approver = await loginWithStepUser({ pool, step, usedUsers, groups });
-        logger.info("Approving request");
-        await approver.approveRequest(request);
-      }
-    }
-    logger.success("Transaction created & approved");
-  }
-  const tx = await creator.network("GET", `/transactions/${request.target_id}`);
-  return tx;
-}
-var TX_TYPE_TO_PRESET = {
-  DELEGATE: "TEZOS_DELEGATION",
-  UNDELEGATE: "TEZOS_DELEGATION"
-};
-function getMatchingMultiAuthRule({
-  account,
-  transaction,
-  whitelistsByName
-}) {
-  let multiAuthRule;
-  if (!account.rules) {
-    throw new Error(`No rules defined in account '${account.name}'`);
-  }
-  const rulesSet = account.rules.filter((rules) => {
-    if (!transaction.transactionType || !Object.keys(TX_TYPE_TO_PRESET).includes(transaction.transactionType)) {
-      return !rules.some((r) => Object.values(TX_TYPE_TO_PRESET).includes(r.type));
-    }
-    return rules.some(
-      // @ts-ignore
-      (r) => r.type === TX_TYPE_TO_PRESET[transaction.transactionType]
-    );
-  });
-  rulesSet.find((rules) => {
-    const multiAuth = rules.find(
-      (r) => r.type === "MULTI_AUTHORIZATIONS"
-    );
-    const threshold = rules.find((r) => r.type === "THRESHOLD");
-    const whitelist = rules.find((r) => r.type === "WHITELIST");
-    if (threshold) {
-      const amount = new BigNumber(transaction.amount);
-      if (threshold.min && amount.isLessThan(threshold.min)) {
-        return false;
-      }
-      if (threshold.max && amount.isGreaterThan(threshold.max)) {
-        return false;
-      }
-    }
-    if (whitelist) {
-      const allowedAddresses = whitelist.whitelists.reduce(
-        (acc, curr) => {
-          const w = whitelistsByName[curr];
-          if (!w) return [];
-          return [...acc, ...w.addresses];
-        },
-        []
-      );
-      if (!allowedAddresses.find((a) => a.address === transaction.recipient)) {
-        throw new Error(`Can't find ${transaction.recipient} in account whitelist(s)`);
-      }
-    }
-    multiAuthRule = multiAuth;
-    return true;
-  });
-  if (!multiAuthRule) {
-    throw new Error(`Can't find matching rule for transaction`);
-  }
-  return multiAuthRule;
-}
-function loginWithStepUser({
-  pool,
-  step,
-  usedUsers,
-  groups
-}) {
-  const user = "group" in step ? groups.find((g) => g.name === step.group).users.find((u) => usedUsers.indexOf(u) === -1) : step.users.find((u) => usedUsers.indexOf(u) === -1);
-  if (!user) {
-    throw new Error(`No available user to approve`);
-  }
-  if (typeof user === "string") {
-    throw new Error(`Sending with API user is not supported YET`);
-  }
-  usedUsers.push(user);
-  return pool.login(user);
-}
-var send_default = send;
-
-// src/upgradeInstance.ts
-import { SILENT_LOGGER as SILENT_LOGGER11 } from "@ledgerhq/vault-utils";
-import duration2 from "humanize-duration";
-import io3 from "socket.io-client";
-async function upgrade(opts, { logger = SILENT_LOGGER11 } = {}) {
-  const {
-    remoteURL = DEFAULT_VAULT_REMOTE_URL,
-    watchTimeoutMinutes = DEFAULT_SPAWN_WATCH_TIMEOUT_MINUTES,
-    ...payload
-  } = opts;
-  const now = Date.now();
-  logger.step(`Upgrading ${payload.name}`);
-  const socket = io3(remoteURL);
-  const network = createNetwork({ baseURL: remoteURL });
-  const { jobID } = await network("PUT", "/api/upgrade", payload);
-  let resolve = null;
-  let reject = null;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  const upgradeTimeout = setTimeout(
-    () => reject(new Error(`Waited for ${watchTimeoutMinutes}min, too long, exiting`)),
-    watchTimeoutMinutes * 60 * 1e3
-  );
-  socket.on("job-log", (msg) => logger[msg.type](`(remote log)> ${msg.msg}`));
-  socket.on("job-success", () => {
-    const elapsed = Date.now() - now;
-    const displayDuration = duration2(elapsed, { round: true });
-    logger.success(`Successfully upgraded instance in ${displayDuration}`);
-    clearTimeout(upgradeTimeout);
-    resolve();
-  });
-  socket.on("job-error", (errMsg) => reject(new Error(errMsg)));
-  socket.emit("join-job", jobID);
-  await promise;
-}
-
-// src/validateManifest.ts
-import sortBy3 from "lodash/sortBy";
-function validateManifest(_manifest) {
-  const manifest = deserializeManifest_default(_manifest);
-  if (manifest.users) {
-    const allRegularUsers = sortBy3(
-      [...manifest.users.operators || [], ...manifest.users.admins || []],
-      (u) => u.device
-    );
-    if (allRegularUsers.length) {
-      allRegularUsers.forEach((u, i) => {
-        if (i > 0) {
-          const user = allRegularUsers[i];
-          if (!user) throw new Error(`Can't find user with index ${i}`);
-          const prevUser = allRegularUsers[i - 1];
-          if (!prevUser) throw new Error(`Can't find user with index ${i - 1}`);
-          if (user.device !== prevUser.device + 1) {
-            throw new Error("Users indexes are not contiguous");
-          }
-        } else {
-          if (u.device !== 10) {
-            throw new Error(`Users devices indexes must start at 10`);
-          }
-        }
-      });
-    }
-  }
-  if (manifest.groups) {
-    manifest.groups.forEach((group) => {
-      group.users.forEach((id) => {
-        if (!manifest.users || typeof id === "number" && (!manifest.users.operators || !manifest.users.operators.find((i) => i.device === id)) || typeof id === "string" && (!manifest.users.api || !manifest.users.api.find((i) => i.name === id)) && (!manifest.users.apiV2 || !manifest.users.apiV2.find((i) => i.name === id))) {
-          throw new Error(`Group ${group.name} is referring to unknown operator ${id}`);
-        }
-      });
-    });
-  }
-  if (manifest.accounts) {
-    manifest.accounts.forEach((account) => {
-      if (!("currency" in account) && !("contractAddress" in account)) {
-        throw new Error(
-          // @ts-ignore
-          `No currency or contractAddress in account "${account.name}"`
-        );
-      }
-      if ("currency" in account) {
-        try {
-          getCryptoCurrencyById(account.currency);
-        } catch (e) {
-          throw Error(`Invalid account currency: "${account.currency}"`);
-        }
-      }
-      if (account.rules && account.rules.length) {
-        account.rules.forEach((rule) => {
-          rule.forEach((r, j) => {
-            if (r.type === "MULTI_AUTHORIZATIONS") {
-              r.steps.forEach((step, i) => {
-                if ("group" in step && "users" in step) {
-                  throw new Error(
-                    `Can't have both 'users' and 'group' in step ${i + 1} of MULTI_AUTHORIZATIONS rule of rules set ${j + 1} of account "${account.name}"`
-                  );
-                } else if ("group" in step) {
-                  if (!manifest.groups || !manifest.groups.find((group) => group.name === step.group)) {
-                    throw new Error(
-                      `Account "${account.name}": Group "${step.group}" does not exist`
-                    );
-                  }
-                } else if ("users" in step) {
-                  step.users.forEach((userId) => {
-                    if (!manifest.users || typeof userId === "number" && (!manifest.users.operators || !manifest.users.operators.find((o) => o.device === userId)) || typeof userId === "string" && (!manifest.users.api || !manifest.users.api.find((o) => o.name === userId)) && (!manifest.users.apiV2 || !manifest.users.apiV2.find((o) => o.name === userId))) {
-                      throw new Error(
-                        `Account "${account.name}": User with id ${userId} does not exist`
-                      );
-                    }
-                  });
-                } else {
-                  throw new Error(
-                    `No group or users in step ${i + 1} of MULTI_AUTHORIZATIONS rule of rules set ${j + 1} of account "${account.name}"`
-                  );
-                }
-              });
-            }
-            if (r.type === "WHITELIST") {
-              r.whitelists.forEach((whitelist) => {
-                if (!manifest.whitelists || !manifest.whitelists.find((w) => w.name === whitelist)) {
-                  throw new Error(
-                    `Account "${account.name}": whitelist "${whitelist}" does not exist`
-                  );
-                }
-              });
-            }
-          });
-        });
-      } else {
-        if (!manifest.users || !manifest.users.operators || !manifest.users.operators.length) {
-          throw new Error("Need at least 1 operator");
-        }
-      }
-      if (account.tradelink_data) {
-        const accountTradelinkData = account.tradelink_data;
-        if (!manifest.tradelink) {
-          throw new Error("Account has tradelink_data but manifest does not");
-        }
-        const { exchanges, assetManagers, custodians } = manifest.tradelink;
-        accountTradelinkData.exchanges.forEach((exchange) => {
-          if (!exchanges.find((e) => e.name === exchange.name)) {
-            throw new Error(
-              `Account "${account.name}": exchange "${exchange.name}" does not exist`
-            );
-          }
-        });
-        if (!assetManagers.find((e) => e.name === accountTradelinkData.asset_manager.name)) {
-          throw new Error(
-            `Account "${account.name}": asset manager "${account.tradelink_data.asset_manager.name}" does not exist`
-          );
-        }
-        if (!custodians.find((e) => e.name === accountTradelinkData.custodian.name)) {
-          throw new Error(
-            `Account "${account.name}": custodian "${account.tradelink_data.custodian.name}" does not exist`
-          );
-        }
-      }
-    });
-  }
-  if (manifest.entities) {
-    manifest.entities.forEach((entity) => {
-      entity.accounts?.forEach((accountName) => {
-        if (!manifest.accounts || !manifest.accounts.find(({ name }) => accountName === name)) {
-          throw new Error(
-            `Entity ${entity.name} is referring to an unknown account ${accountName}`
-          );
-        }
-      });
-    });
-  }
-  if (manifest.whitelists) {
-    manifest.whitelists.forEach((whitelist) => {
-      whitelist.addresses.map((address) => {
-        try {
-          getCryptoCurrencyById(address.currency);
-        } catch (e) {
-          throw Error(`Invalid whitelist currency: "${address.currency}"`);
-        }
-      });
-    });
-  }
-  if (manifest.tradelink) {
-    manifest.tradelink.exchanges.forEach((exchange) => {
-      const operators = exchange.users?.operators || [];
-      const apiV2 = exchange.users?.apiV2 || [];
-      if (!operators.length && !apiV2.length) {
-        throw new Error(`Exchange ${exchange.name} has no users`);
-      }
-      operators.forEach((operator) => {
-        if (!manifest.users?.operators?.find((o) => o.device === operator)) {
-          throw new Error(`Exchange ${exchange.name} refers to unknown operator ${operator}`);
-        }
-      });
-      apiV2.forEach((api) => {
-        if (!manifest.users?.apiV2?.find((o) => o.name === api)) {
-          throw new Error(`Exchange ${exchange.name} refers to unknown API User ${api}`);
-        }
-      });
-    });
-    manifest.tradelink.assetManagers.forEach((assetManager) => {
-      const operators = assetManager.users?.operators || [];
-      const apiV2 = assetManager.users?.apiV2 || [];
-      if (!operators.length && !apiV2.length) {
-        throw new Error(`Asset Manager ${assetManager.name} has no users`);
-      }
-      operators.forEach((operator) => {
-        if (!manifest.users?.operators?.find((o) => o.device === operator)) {
-          throw new Error(
-            `Asset Manager ${assetManager.name} refers to unknown operator ${operator}`
-          );
-        }
-      });
-      apiV2.forEach((api) => {
-        if (!manifest.users?.apiV2?.find((o) => o.name === api)) {
-          throw new Error(`Asset Manager ${assetManager.name} refers to unknown API User ${api}`);
-        }
-      });
-    });
-    manifest.tradelink.custodians.forEach((custodian) => {
-      const operators = custodian.users?.operators || [];
-      const apiV2 = custodian.users?.apiV2 || [];
-      if (!operators.length && !apiV2.length) {
-        throw new Error(`Custodian ${custodian.name} has no users`);
-      }
-      operators.forEach((operator) => {
-        if (!manifest.users?.operators?.find((o) => o.device === operator)) {
-          throw new Error(`Custodian ${custodian.name} refers to unknown operator ${operator}`);
-        }
-      });
-      apiV2.forEach((api) => {
-        if (!manifest.users?.apiV2?.find((o) => o.name === api)) {
-          throw new Error(`Custodian ${custodian.name} refers to unknown API User ${api}`);
-        }
-      });
-    });
-  }
-}
-
-// src/wipeBackend.ts
-import { SILENT_LOGGER as SILENT_LOGGER12 } from "@ledgerhq/vault-utils";
-async function wipeBackend(wipeOpts, runnableOpts = {}) {
-  const { logger = SILENT_LOGGER12 } = runnableOpts;
-  if (!wipeOpts.hsmEndpoint) {
-    throw new Error("HSM endpoint is empty, please provide one");
-  }
-  logger.step("Wiping backend data");
-  const gateNetworkOptions = { baseURL: wipeOpts.gate };
-  const gateNetwork = createNetwork(gateNetworkOptions);
-  try {
-    await gateNetwork("POST", "/maintenance/wipe");
-  } catch {
-    logger.info(
-      "[WARN] POST for /maintenance/wipe did not worked, attempting legacy GET (see VG-8670)"
-    );
-    await gateNetwork("GET", "/maintenance/wipe");
-    logger.info("[WARN] legacy GET /maintenance/wipe successful");
-  }
-  if (wipeOpts.lam) {
-    const lamNetworkOptions = { baseURL: wipeOpts.lam };
-    const headersAPILam = wipeOpts.lamAPIKey ? { headers: { "X-Ledger-API-Key": wipeOpts.lamAPIKey } } : {};
-    const lamNetwork = createNetwork(lamNetworkOptions);
-    logger.step("Wiping LAM data");
-    try {
-      const lamWipeResponse = await lamNetwork(
-        "DELETE",
-        "/api_users/maintenance/wipe",
-        {},
-        headersAPILam
-      );
-      if (!lamWipeResponse) {
-        logger.info("[WARN] LAM wipe did not work as expected!");
-      }
-    } catch (err) {
-      logger.info(`Error while wiping the LAM: ${err.toString()}`);
-    }
-  }
-  logger.step("Resetting HSM compartment");
-  const hsmBridge = createHSMBridge_default(wipeOpts);
-  await hsmBridge.resetCompartment(wipeOpts.hsmCompartmentID, runnableOpts);
-  logger.success("Wiped backend data");
-}
-var wipeBackend_default = wipeBackend;
-export {
-  DEFAULT_SPAWN_WATCH_TIMEOUT_MINUTES,
-  DEFAULT_VAULT_REMOTE_URL,
-  GateGroupRequestTypeDefs,
-  LIGHT_EVM_CURRENCIES,
-  bakeManifest,
-  createAPIDevice_default as createAPIDevice,
-  createConfigCatEnvironment,
-  createDevicesPool_default as createDevicesPool,
-  createFaucet_default as createFaucet,
-  createInteractions,
-  createNetwork,
-  createPledge_default as createPledge,
-  createSettlement_default as createSettlement,
-  deleteConfigCatEnvironment,
-  deploy,
-  deserializeUnitValue,
-  destroy,
-  device_exports as device,
-  extractSecureChannel,
-  feesLevels,
-  fetchTokens_default as fetchTokens,
-  genSeed_default as genSeed,
-  getAccountTypeByCurrency,
-  getAccountUnit,
-  getAuthTokens,
-  getCryptoCurrencyById,
-  getCurrencyOrToken,
-  getCurrencyUnit,
-  getDefaultUsername,
-  getGateAccountUnit,
-  getMVInstances,
-  getTokenUnit,
-  getWorkspaceFromGate,
-  listCryptoCurrencies,
-  performRequest,
-  prepareRequest_default as prepareRequest,
-  queue,
-  recipeManifest,
-  reviewAPIRequest_default as reviewAPIRequest,
-  send_default as send,
-  serializeUnitValue,
-  setConfigCatFeatureFlagValues,
-  setDeviceAPIEndpoint,
-  unwrapConnection,
-  upgrade,
-  validateManifest,
-  vaultCoins,
-  wait,
-  wipeBackend_default as wipeBackend,
-  xpubToExtendedPubKey
-};
-//# sourceMappingURL=index.mjs.map