@ledgerhq/revault-sdk 0.12.0

package/lib/bake.cjs

@@ -0,0 +1,812 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkQOP5LA3Ecjs = require('./chunk-QOP5LA3E.cjs');
+
+// src/bake/index.ts
+var _invariant = require('invariant'); var _invariant2 = _interopRequireDefault(_invariant);
+
+// src/bake/bake-pledge.ts
+
+
+// src/bake/utils.ts
+
+function createBakeLogHelpers(logger) {
+  return {
+    logTitle(title) {
+      logger.info(`:: ${title} ::`);
+    },
+    logStep(msg) {
+      logger.info(`=> ${msg}`);
+    },
+    logSubStep(msg) {
+      logger.info(`   -> ${msg}`);
+    }
+  };
+}
+async function approveRequest(request, approvers, logger) {
+  const { logSubStep } = createBakeLogHelpers(logger);
+  for (let i = 0; i < approvers.length; i++) {
+    logSubStep(`Collecting approval (${i + 1}/${approvers.length})...`);
+    const approver = approvers[i];
+    request = await approver.approve(request);
+  }
+  return request;
+}
+async function createAndApproveRequest(input, approvers, logger) {
+  const { logSubStep } = createBakeLogHelpers(logger);
+  const creator = approvers[0];
+  _invariant2.default.call(void 0, creator, "Need at least 1 user to create a request");
+  logSubStep(`Creating request of type ${input.type}...`);
+  const request = await creator.client.requests.create.mutate({ request: input });
+  return approveRequest(request, approvers, logger);
+}
+
+// src/bake/bake-pledge.ts
+var flattenApprovers = (groups) => {
+  return groups.reduce((acc, cur) => {
+    acc.push(...cur.userIds.slice(0, cur.quorum));
+    return acc;
+  }, []);
+};
+async function bakePledgeAdjustment(options, logger) {
+  const { pledgeAdjustment, engine } = options;
+  const getDeviceIndex = _chunkQOP5LA3Ecjs.createDeviceIndexResolver.call(void 0, engine);
+  logger.info("Logging in with admin...");
+  const admin = await engine.withDeviceIndex(4).login();
+  logger.info("Fetching account, tradelink blueprint and network...");
+  const [matchingAccounts, blueprint, network] = await Promise.all([
+    _chunkQOP5LA3Ecjs.fetchAll.call(void 0, admin.client.accounts.list.query, { name: pledgeAdjustment.account }),
+    admin.client.tradelink.getNetworkBlueprint.query(),
+    admin.client.tradelink.getNetwork.query()
+  ]);
+  const account = matchingAccounts.find((account2) => account2.name === pledgeAdjustment.account);
+  _invariant2.default.call(void 0, account, `Account ${pledgeAdjustment.account} not found`);
+  _invariant2.default.call(void 0, blueprint, "Tradelink blueprint is not created yet");
+  _invariant2.default.call(void 0, network, "Tradelink network is not created yet");
+  const exchange = network.exchanges.find((exchange2) => {
+    const blueprintExchange = blueprint.exchanges.find(
+      (blueprintExchange2) => blueprintExchange2.tradelinkId === exchange2.tradelinkId
+    );
+    _invariant2.default.call(void 0, blueprintExchange, `Exchange ${exchange2.tradelinkId} not found in blueprint`);
+    return blueprintExchange.name === pledgeAdjustment.exchange;
+  });
+  _invariant2.default.call(void 0, exchange, `Exchange ${pledgeAdjustment.exchange} not found in network`);
+  const governance = account.governance;
+  _invariant2.default.call(void 0, governance.type === "TRADELINK", "Account governance is not TRADELINK");
+  const assetManager = network.assetManagers.find((am) => am.id === governance.assetManagerId);
+  _invariant2.default.call(void 0, assetManager, `Asset manager ${governance.assetManagerId} not found in network`);
+  const exchangeIsConfiguredForAccount = !!governance.exchangeConfigs.find(
+    (e) => e.exchangeId === exchange.id
+  );
+  _invariant2.default.call(void 0, 
+    exchangeIsConfiguredForAccount,
+    `Exchange ${exchange.id} is not configured for account ${account.id}`
+  );
+  const approverIds = [
+    ...flattenApprovers(assetManager.groups),
+    ...flattenApprovers(exchange.groups)
+  ];
+  const approvers = await Promise.all(
+    approverIds.map(
+      (id) => admin.client.users.findById.query({ id }).then((user) => getDeviceIndex(user.deviceUserId)).then((index) => engine.withDeviceIndex(index).login())
+    )
+  );
+  await createAndApproveRequest(
+    {
+      type: "ADJUST_PLEDGE",
+      data: {
+        accountId: account.id,
+        exchangeId: exchange.id,
+        amount: pledgeAdjustment.amount
+      }
+    },
+    approvers,
+    logger
+  );
+  logger.info(
+    `Successfully adjusted pledge for account ${pledgeAdjustment.account} on exchange ${pledgeAdjustment.exchange}`
+  );
+}
+
+// src/bake/bake-tradelink-organization.ts
+async function bakeTradelinkOrganization(options, logger) {
+  const { tradelink, engine, rootAuthToken, networkBlueprint } = options;
+  const { logStep } = createBakeLogHelpers(logger);
+  const rootClient = engine.createClient({ rootAuthToken });
+  if (tradelink.exchanges) {
+    logStep("Creating Tradelink organization exchanges...");
+    const existingOrgExchanges = await rootClient.tradelink.root.listOrgExchanges.query();
+    for (const orgExchange of tradelink.exchanges) {
+      const existingOrgExchange = existingOrgExchanges.find((e) => e.name === orgExchange.name);
+      if (existingOrgExchange) {
+        logger.info(
+          `[SKIPPED] Organization exchange ${existingOrgExchange.name} (${existingOrgExchange.code}) already exists`
+        );
+      } else {
+        await rootClient.tradelink.root.createOrgExchange.mutate({
+          code: orgExchange.code,
+          name: orgExchange.name,
+          logoUrl: orgExchange.logo
+        });
+        logger.info(`Created organization exchange ${orgExchange.name} (${orgExchange.code})`);
+      }
+    }
+  }
+  if (tradelink.assetManagers) {
+    logStep("Creating Tradelink organization asset managers...");
+    const existingAssetManagers = await rootClient.tradelink.root.listOrgAssetManagers.query();
+    for (const orgAssetManager of tradelink.assetManagers) {
+      const existingOrgAssetManager = existingAssetManagers.find(
+        (e) => e.name === orgAssetManager.name
+      );
+      if (existingOrgAssetManager) {
+        logger.info(
+          `[SKIPPED] Organization asset manager ${existingOrgAssetManager.name} (${existingOrgAssetManager.code}) already exists`
+        );
+      } else {
+        await rootClient.tradelink.root.createOrgAssetManager.mutate({
+          code: orgAssetManager.code,
+          name: orgAssetManager.name,
+          logoUrl: orgAssetManager.logo
+        });
+        logger.info(
+          `Created organization asset manager ${orgAssetManager.name} (${orgAssetManager.code})`
+        );
+      }
+    }
+  }
+  if (tradelink.custodians) {
+    logStep("Creating Tradelink organization custodians...");
+    const existingCustodians = await rootClient.tradelink.root.listOrgCustodians.query();
+    for (const orgCustodian of tradelink.custodians) {
+      const existingOrgCustodian = existingCustodians.find((e) => e.name === orgCustodian.name);
+      if (existingOrgCustodian) {
+        logger.info(
+          `[SKIPPED] Organization custodian ${existingOrgCustodian.name} (${existingOrgCustodian.code}) already exists`
+        );
+      } else {
+        await rootClient.tradelink.root.createOrgCustodian.mutate({
+          code: orgCustodian.code,
+          name: orgCustodian.name,
+          logoUrl: orgCustodian.logo
+        });
+        logger.info(`Created organization custodian ${orgCustodian.name} (${orgCustodian.code})`);
+      }
+    }
+  }
+  if (networkBlueprint) {
+    logStep("Creating Tradelink network blueprint...");
+    const { workspaceName, blueprint } = networkBlueprint;
+    const existingBlueprints = await rootClient.tradelink.root.listNetworkBlueprints.query();
+    const existingBlueprint = existingBlueprints.find((e) => e.workspaceName === workspaceName);
+    if (existingBlueprint) {
+      logger.info(`[SKIPPED] Network blueprint for ${workspaceName} workspace already exists`);
+    } else {
+      await rootClient.tradelink.root.createNetworkBlueprint.mutate({
+        workspaceName,
+        custodian: { name: blueprint.custodian },
+        exchanges: blueprint.exchanges.map((_2) => ({ name: _2 })),
+        assetManagers: blueprint.assetManagers.map((_2) => ({ name: _2 }))
+      });
+      logger.info(`Created network blueprint for ${networkBlueprint.workspaceName} workspace`);
+    }
+  }
+}
+
+// src/bake/bake-workspace.ts
+
+var _lodash = require('lodash'); var _lodash2 = _interopRequireDefault(_lodash);
+async function bakeWorkspace(options, logger) {
+  const { workspace, engine, workspaceName } = options;
+  const workspaceEngine = engine.withWorkspace(workspaceName);
+  const { logTitle, logStep, logSubStep } = createBakeLogHelpers(logger);
+  const findDeviceIndex = _chunkQOP5LA3Ecjs.createDeviceIndexResolver.call(void 0, workspaceEngine);
+  logger.info("Authenticating with two admins...");
+  const [admin1, admin2] = await Promise.all([
+    workspaceEngine.withDeviceIndex(4).login(),
+    workspaceEngine.withDeviceIndex(5).login()
+  ]);
+  logger.info("Fetching existing data...");
+  const [
+    existingAdmins,
+    existingOperators,
+    existingGroups,
+    existingPolicies,
+    existingAccounts,
+    tradelinkNetworkBlueprint
+  ] = await Promise.all([
+    _chunkQOP5LA3Ecjs.fetchAll.call(void 0, admin1.client.users.list.query, { status: "ACTIVE", role: "ADMIN" }),
+    _chunkQOP5LA3Ecjs.fetchAll.call(void 0, admin1.client.users.list.query, { status: "ACTIVE", role: "OPERATOR" }),
+    _chunkQOP5LA3Ecjs.fetchAll.call(void 0, admin1.client.groups.list.query, { status: "ACTIVE" }),
+    _chunkQOP5LA3Ecjs.fetchAll.call(void 0, admin1.client.policies.list.query, { isPrivate: false }),
+    _chunkQOP5LA3Ecjs.fetchAll.call(void 0, admin1.client.accounts.list.query, { status: "ACTIVE", skipLiveData: true }),
+    admin1.client.tradelink.getNetworkBlueprint.query()
+  ]);
+  const tradelinkOrgExchangesByName = _lodash2.default.keyBy(_optionalChain([tradelinkNetworkBlueprint, 'optionalAccess', _3 => _3.exchanges]), "name");
+  const tradelinkOrgAssetManagersByName = _lodash2.default.keyBy(_optionalChain([tradelinkNetworkBlueprint, 'optionalAccess', _4 => _4.assetManagers]), "name");
+  let existingTradelinkNetwork = await admin1.client.tradelink.getNetwork.query();
+  const existingUsers = [...existingAdmins, ...existingOperators];
+  const usersWithDeviceIndex = await resolveDevicesIndexes(existingUsers);
+  if (workspace.users) {
+    logTitle("Users");
+    if (workspace.users.admins) {
+      for (const deviceIndex of workspace.users.admins) {
+        await createUser("ADMIN", deviceIndex);
+      }
+    }
+    if (workspace.users.operators) {
+      for (const deviceIndex of workspace.users.operators) {
+        await createUser("OPERATOR", deviceIndex);
+      }
+    }
+  }
+  if (workspace.groups) {
+    logTitle("Groups");
+    for (const group of workspace.groups) {
+      await createGroup(group);
+    }
+  }
+  if (workspace.whitelists) {
+    logTitle("Whitelists");
+    await createWhitelists(workspace.whitelists);
+  }
+  if (workspace.policies) {
+    logTitle("Policies");
+    for (const policy of workspace.policies) {
+      await createPolicy(policy);
+    }
+  }
+  if (workspace.tradelink) {
+    logTitle("Tradelink");
+    await createTradelink(workspace.tradelink);
+  }
+  if (workspace.accounts) {
+    logTitle("Accounts");
+    for (const account of workspace.accounts) {
+      await createAccount(account);
+    }
+  }
+  async function createWhitelists(whitelists) {
+    const existingWhitelists = await _chunkQOP5LA3Ecjs.fetchAll.call(void 0, admin1.client.whitelists.list.query, {
+      status: "ACTIVE"
+    });
+    for (const whitelist of whitelists) {
+      await createWhitelist(whitelist);
+    }
+    async function createWhitelist(whitelist) {
+      const existing = existingWhitelists.find((w) => w.name === whitelist.name);
+      if (existing) {
+        logger.info(`[SKIPPED] Whitelist "${whitelist.name}" already exists`);
+        return;
+      }
+      const input = {
+        type: "CREATE_WHITELIST",
+        data: whitelist
+      };
+      await createAndApproveRequest(input, [admin1, admin2], logger);
+      logSubStep(`Whitelist "${whitelist.name}" has been created`);
+    }
+  }
+  function govRuleFromManifest(rule) {
+    return {
+      operationType: rule.type,
+      reviewSteps: rule.steps.map((step) => {
+        if ("group" in step) {
+          return {
+            quorum: step.quorum,
+            groupId: groupIdFromName(step.group)
+          };
+        }
+        return {
+          quorum: step.quorum,
+          userIds: step.members.map(userIdFromDeviceIndex)
+        };
+      })
+    };
+  }
+  async function createAccount(account) {
+    const existing = existingAccounts.find((a) => a.name === account.name);
+    if (existing) {
+      logger.info(`[SKIPPED] Account "${account.name}" already exists`);
+      return;
+    }
+    logStep(`Creating account "${account.name}"`);
+    logSubStep("Fetching account asset...");
+    const asset = await fetchAsset({
+      currency: account.currency,
+      contractAddress: account.contractAddress
+    });
+    const input = {
+      type: "CREATE_ACCOUNT",
+      data: {
+        // general fields
+        name: account.name,
+        // asset fields
+        type: asset.type,
+        currency: account.currency,
+        contractAddress: account.contractAddress,
+        // governance fields
+        governance: account.governance.type === "TRADELINK" ? {
+          type: "TRADELINK",
+          assetManagerId: assetManagerIdFromName(account.governance.assetManager),
+          exchangeConfigs: account.governance.exchanges.map((exchangeConfig) => ({
+            exchangeId: exchangeIdFromName(exchangeConfig.name),
+            repledgeAuthorized: exchangeConfig.repledgeAuthorized === true,
+            needsAssetManagerApprovalForSettlements: exchangeConfig.needsAssetManagerApprovalForSettlements === true
+          }))
+        } : {
+          type: "CLASSIC",
+          policy: {
+            type: "ACCOUNT_PRIVATE_POLICY",
+            rules: account.governance.rules.map(govRuleFromManifest)
+          }
+        }
+      }
+    };
+    const req = await createAndApproveRequest(input, [admin1, admin2], logger);
+    if (account.governance.type === "TRADELINK") {
+      logStep(`Activating tradelink account "${account.name}"`);
+      const assetManagerId = assetManagerIdFromName(account.governance.assetManager);
+      const assetManager = _optionalChain([existingTradelinkNetwork, 'optionalAccess', _5 => _5.assetManagers, 'access', _6 => _6.find, 'call', _7 => _7(
+        (assetManager2) => assetManager2.id === assetManagerId
+      )]);
+      _invariant2.default.call(void 0, assetManager, `Asset manager for account exists`);
+      const loggedAssetManagerOperators = await Promise.all(
+        assetManager.groups.flatMap(
+          ({ quorum, userIds }) => userIds.slice(0, quorum).map((userId) => {
+            const deviceIndex = _optionalChain([usersWithDeviceIndex, 'access', _8 => _8.find, 'call', _9 => _9((o) => o.user.id === userId), 'optionalAccess', _10 => _10.deviceIndex]);
+            return workspaceEngine.withDeviceIndex(deviceIndex).login();
+          })
+        )
+      );
+      await createAndApproveRequest(
+        { type: "ACTIVATE_TRADELINK_ACCOUNT", targetId: req.targetId, data: {} },
+        loggedAssetManagerOperators,
+        logger
+      );
+    }
+    logSubStep(`Account ${account.name} has been created`);
+  }
+  async function fetchAsset(params) {
+    const { currency, contractAddress } = params;
+    if (contractAddress) {
+      const tokens = await admin1.client.assets.tokens.query({ search: contractAddress });
+      const t = tokens.results.find(
+        (t2) => t2.contractAddress === contractAddress && t2.currency === currency
+      );
+      _invariant2.default.call(void 0, t, `Token ${contractAddress} (${currency}) not found`);
+      return t;
+    } else {
+      const currencies = await admin1.client.assets.currencies.query({ search: currency });
+      const c = currencies.results.find((c2) => c2.id === currency);
+      _invariant2.default.call(void 0, c, `Currency ${currency} not found`);
+      return c;
+    }
+  }
+  async function createUser(role, deviceIndex) {
+    const userEngine = workspaceEngine.withDeviceIndex(deviceIndex);
+    const deviceId = await userEngine.device.getDeviceUserId();
+    const existing = existingUsers.find((user) => user.deviceUserId === deviceId);
+    if (existing) {
+      logger.info(`[SKIPPED] User with device index ${deviceIndex} already exists`);
+      return;
+    }
+    const name = `${role === "ADMIN" ? "Admin" : "Operator"} ${deviceIndex}`;
+    logStep(`Creating ${name}`);
+    logSubStep("Creating request...");
+    let req = await admin1.client.requests.create.mutate({
+      request: {
+        type: role === "ADMIN" ? "CREATE_ADMIN" : "CREATE_OPERATOR",
+        data: {
+          deviceUserId: deviceId,
+          name,
+          deviceType: "PSD"
+        }
+      }
+    });
+    logSubStep("Registering user...");
+    req = await userEngine.register({ requestId: req.id, name, role });
+    req = await approveRequest(req, [admin1, admin2], logger);
+    logSubStep(`${name} has been created`);
+    const createdUser = await admin1.client.users.findById.query({ id: req.targetId });
+    existingUsers.push(createdUser);
+    usersWithDeviceIndex.push({ user: createdUser, deviceIndex });
+  }
+  async function createGroup(group) {
+    const existing = existingGroups.find((g) => g.name === group.name);
+    if (existing) {
+      logger.info(`[SKIPPED] Group "${group.name}" already exists`);
+      return;
+    }
+    logStep(`Creating group ${group.name}...`);
+    const members = group.members.map(userIdFromDeviceIndex);
+    logSubStep("Creating request...");
+    let request = await admin1.client.requests.create.mutate({
+      request: {
+        type: "CREATE_GROUP",
+        data: {
+          name: group.name,
+          description: "",
+          members
+        }
+      }
+    });
+    request = await approveRequest(request, [admin1, admin2], logger);
+    logSubStep(`${group.name} has been created`);
+    const createdGroup = await admin1.client.groups.findById.query({ id: request.targetId });
+    existingGroups.push(createdGroup);
+  }
+  async function createPolicy(policy) {
+    const existing = existingPolicies.find((p) => p.name === policy.name);
+    if (existing) {
+      logger.info(`[SKIPPED] Policy "${policy.name}" already exists`);
+      return;
+    }
+    logStep(`Creating policy ${policy.name}...`);
+    logSubStep("Creating request...");
+    let request = await admin1.client.requests.create.mutate({
+      request: {
+        type: "CREATE_POLICY",
+        data: {
+          name: policy.name,
+          currency: policy.currency,
+          description: "",
+          govRules: policy.rules.map(govRuleFromManifest)
+        }
+      }
+    });
+    request = await approveRequest(request, [admin1, admin2], logger);
+    logSubStep(`${policy.name} has been created`);
+    const createdPolicy = await admin1.client.policies.findById.query({ id: request.targetId });
+    existingPolicies.push(createdPolicy);
+  }
+  async function createTradelink(tradelink) {
+    if (tradelink.custodian) {
+      if (existingTradelinkNetwork === null) {
+        logStep("Creating custodian config...");
+        const { settlement, withdraw, arbitration } = tradelink.custodian;
+        const data = {
+          settlement: settlement.map(tradelinkReviewStepFromManifest),
+          withdraw: withdraw.map(tradelinkReviewStepFromManifest),
+          arbitration: arbitration.map(tradelinkReviewStepFromManifest)
+        };
+        logSubStep("Creating request...");
+        const request = await admin1.client.requests.create.mutate({
+          request: {
+            type: "CREATE_TRADELINK_CUSTODIAN",
+            data
+          }
+        });
+        await approveRequest(request, [admin1, admin2], logger);
+        logSubStep("Tradelink custodian config has been created");
+        existingTradelinkNetwork = await admin1.client.tradelink.getNetwork.query();
+      } else {
+        logger.info("[SKIPPED] Custodian config already exists");
+      }
+      const networkBlueprint = await admin1.client.tradelink.getNetworkBlueprint.query();
+      if (networkBlueprint !== null) {
+        if (tradelink.exchanges !== void 0) {
+          await createTradelinkExchanges(networkBlueprint, tradelink.exchanges);
+        }
+        if (tradelink.assetManagers !== void 0) {
+          await createTradelinkAssetManagers(networkBlueprint, tradelink.assetManagers);
+        }
+      } else {
+        logger.error(
+          "Will not create exchanges and asset managers because there is no network blueprint for current workspace"
+        );
+      }
+    }
+  }
+  async function createTradelinkExchanges(networkBlueprint, exchanges) {
+    _invariant2.default.call(void 0, existingTradelinkNetwork !== null, "Network should exist");
+    const blueprintExchanges = networkBlueprint.exchanges;
+    for (const exchange of exchanges) {
+      const blueprintExchange = blueprintExchanges.find(({ name }) => name === exchange.name);
+      _invariant2.default.call(void 0, 
+        blueprintExchange !== void 0,
+        `Exchange ${exchange.name} does not exist in network blueprint`
+      );
+      const exchangeId = blueprintExchange.tradelinkId;
+      logStep(`Creating exchange ${exchange.name}...`);
+      if (existingTradelinkNetwork.exchanges.find(({ tradelinkId }) => tradelinkId === exchangeId) !== void 0) {
+        logger.info(`[SKIPPED] Exchange "${exchange.name}" already exists`);
+        continue;
+      }
+      logSubStep("Creating request...");
+      const request = await admin1.client.requests.create.mutate({
+        request: {
+          type: "CREATE_TRADELINK_EXCHANGE",
+          data: {
+            tradelinkId: exchangeId,
+            groups: exchange.groups.map(tradelinkReviewStepFromManifest),
+            whitelist: exchange.whitelist
+          }
+        }
+      });
+      const loggedExchangeOperators = await Promise.all(
+        exchange.groups.flatMap(
+          ({ quorum, members }) => members.slice(0, quorum).map((deviceIndex) => workspaceEngine.withDeviceIndex(deviceIndex).login())
+        )
+      );
+      await approveRequest(request, [admin1, admin2, ...loggedExchangeOperators], logger);
+      existingTradelinkNetwork = await admin1.client.tradelink.getNetwork.query();
+      _invariant2.default.call(void 0, existingTradelinkNetwork !== null, "Tradelink network exists");
+    }
+  }
+  async function createTradelinkAssetManagers(networkBlueprint, assetManagers) {
+    _invariant2.default.call(void 0, existingTradelinkNetwork !== null, "Network should exist");
+    const blueprintAssetManagers = networkBlueprint.assetManagers;
+    for (const assetManager of assetManagers) {
+      const blueprintAssetManager = blueprintAssetManagers.find(
+        ({ name }) => name === assetManager.name
+      );
+      _invariant2.default.call(void 0, 
+        blueprintAssetManager !== void 0,
+        `AssetManager ${assetManager.name} does not exist in network blueprint`
+      );
+      const assetManagerId = blueprintAssetManager.tradelinkId;
+      logStep(`Creating assetManager ${assetManager.name}...`);
+      if (existingTradelinkNetwork.assetManagers.find(
+        ({ tradelinkId }) => tradelinkId === assetManagerId
+      ) !== void 0) {
+        logger.info(`[SKIPPED] Asset manager "${assetManager.name}" already exists`);
+        continue;
+      }
+      logSubStep("Creating request...");
+      const request = await admin1.client.requests.create.mutate({
+        request: {
+          type: "CREATE_TRADELINK_ASSET_MANAGER",
+          data: {
+            tradelinkId: assetManagerId,
+            groups: assetManager.groups.map(tradelinkReviewStepFromManifest),
+            whitelist: assetManager.whitelist
+          }
+        }
+      });
+      const loggedAssetManagerOperators = await Promise.all(
+        assetManager.groups.flatMap(
+          ({ quorum, members }) => members.slice(0, quorum).map((deviceIndex) => workspaceEngine.withDeviceIndex(deviceIndex).login())
+        )
+      );
+      await approveRequest(request, [admin1, admin2, ...loggedAssetManagerOperators], logger);
+      existingTradelinkNetwork = await admin1.client.tradelink.getNetwork.query();
+      _invariant2.default.call(void 0, existingTradelinkNetwork !== null, "Tradelink network exists");
+    }
+  }
+  async function resolveDevicesIndexes(users) {
+    const usersWithDeviceIndex2 = await users.reduce(
+      (acc, cur) => acc.then(async (acc2) => {
+        acc2.push(await withDeviceIndex(cur));
+        return acc2;
+      }),
+      Promise.resolve([])
+    );
+    return usersWithDeviceIndex2;
+  }
+  async function withDeviceIndex(user) {
+    _invariant2.default.call(void 0, user.deviceUserId, `User ${user.id} does not have any device user id`);
+    const deviceIndex = await findDeviceIndex(user.deviceUserId);
+    return { user, deviceIndex };
+  }
+  function userIdFromDeviceIndex(deviceIndex) {
+    const corresponding = usersWithDeviceIndex.find((o) => o.deviceIndex === deviceIndex);
+    _invariant2.default.call(void 0, corresponding, `No user with device index ${deviceIndex}`);
+    return corresponding.user.id;
+  }
+  function groupIdFromName(groupName) {
+    const group = existingGroups.find((g) => g.name === groupName);
+    _invariant2.default.call(void 0, group, `Group ${groupName} not found`);
+    return group.id;
+  }
+  function assetManagerIdFromName(assetManagerName) {
+    const orgAssetManager = tradelinkOrgAssetManagersByName[assetManagerName];
+    _invariant2.default.call(void 0, 
+      orgAssetManager,
+      `Can't find Tradelink organization asset manager ${assetManagerName}`
+    );
+    const assetManager = _optionalChain([existingTradelinkNetwork, 'optionalAccess', _11 => _11.assetManagers, 'access', _12 => _12.find, 'call', _13 => _13(
+      (assetManager2) => assetManager2.tradelinkId === orgAssetManager.tradelinkId
+    )]);
+    _invariant2.default.call(void 0, assetManager, `Can't find Tradelink assetManager ${assetManagerName}`);
+    return assetManager.id;
+  }
+  function exchangeIdFromName(exchangeName) {
+    const exchange = _optionalChain([existingTradelinkNetwork, 'optionalAccess', _14 => _14.exchanges, 'access', _15 => _15.find, 'call', _16 => _16((exchange2) => {
+      const orgExchange = tradelinkOrgExchangesByName[exchangeName];
+      _invariant2.default.call(void 0, orgExchange, `Can't find Tradelink organization exchange ${exchange2.tradelinkId}`);
+      return orgExchange.name === exchangeName;
+    })]);
+    _invariant2.default.call(void 0, exchange, `Can't find Tradelink exchange ${exchangeName}`);
+    return exchange.id;
+  }
+  function tradelinkReviewStepFromManifest({
+    members,
+    quorum
+  }) {
+    return {
+      userIds: members.map(userIdFromDeviceIndex),
+      quorum
+    };
+  }
+}
+
+// src/bake/types.ts
+var _zod = require('zod'); var _zod2 = _interopRequireDefault(_zod);
+var zManifestUser = _zod2.default.number().describe("User device index");
+var zManifestGroup = _zod2.default.object({
+  name: _zod2.default.string().describe("Group name"),
+  members: _zod2.default.array(zManifestUser).describe("Group members")
+}).describe("Operators group");
+var zManifestWhitelistAddress = _zod2.default.object({
+  name: _zod2.default.string().describe("Whitelist address name"),
+  currency: _zod2.default.string().describe("Whitelist address currency"),
+  address: _zod2.default.string().describe("Whitelist address"),
+  destinationTags: _zod2.default.array(_zod2.default.string()).optional().describe("List of destination tags (applicable for Ripple currency)")
+});
+var zManifestWhitelist = _zod2.default.object({
+  name: _zod2.default.string().describe("Whitelist name"),
+  description: _zod2.default.string().optional().default("").describe("Whitelist description"),
+  type: _zod2.default.enum(["TRANSACTION", "SMART_CONTRACT"]).optional().default("TRANSACTION").describe("Whitelist type"),
+  addresses: _zod2.default.array(zManifestWhitelistAddress).describe("Whitelist addresses")
+}).describe("Whitelist");
+var zManifestGovernanceStepWithUsers = _zod2.default.object({
+  quorum: _zod2.default.number(),
+  members: _zod2.default.array(zManifestUser)
+});
+var zManifestGovernanceStepWithGroup = _zod2.default.object({
+  quorum: _zod2.default.number(),
+  group: _zod2.default.string()
+});
+var zManifestGovernanceStep = _zod2.default.union([
+  zManifestGovernanceStepWithUsers,
+  zManifestGovernanceStepWithGroup
+]);
+var zManifestGovernanceRule = _zod2.default.object({
+  // TODO see if there is a way to import this from `api` package
+  // (the challenge there is that enums are not transpiled)
+  type: _zod2.default.enum([
+    "SEND",
+    "STAKE",
+    "DEPLOY_CONTRACT",
+    "EXECUTE_CONTRACT",
+    "SIGN_DIGESTS",
+    "SIGN_MESSAGE"
+  ]),
+  steps: _zod2.default.array(zManifestGovernanceStep).min(1)
+});
+var zManifestPolicy = _zod2.default.object({
+  name: _zod2.default.string(),
+  currency: _zod2.default.string(),
+  rules: _zod2.default.array(zManifestGovernanceRule)
+});
+var zManifestClassicAccountGovernance = _zod2.default.object({
+  type: _zod2.default.literal("CLASSIC"),
+  rules: _zod2.default.array(zManifestGovernanceRule)
+});
+var zManifestTradelinkExchangeConfig = _zod2.default.object({
+  name: _zod2.default.string().describe("Exchange name"),
+  repledgeAuthorized: _zod2.default.boolean().optional().describe("Whether repledge is authorized"),
+  needsAssetManagerApprovalForSettlements: _zod2.default.boolean().optional().describe("Whether asset manager pre approval is needed")
+});
+var zManifestTradelinkAccountGovernance = _zod2.default.object({
+  type: _zod2.default.literal("TRADELINK"),
+  assetManager: _zod2.default.string().describe("Asset manager name"),
+  exchanges: _zod2.default.array(zManifestTradelinkExchangeConfig)
+});
+var zManifestAccountGovernance = _zod2.default.discriminatedUnion("type", [
+  zManifestClassicAccountGovernance,
+  zManifestTradelinkAccountGovernance
+]);
+var zManifestAccount = _zod2.default.object({
+  name: _zod2.default.string(),
+  currency: _zod2.default.string(),
+  contractAddress: _zod2.default.string().optional(),
+  governance: zManifestAccountGovernance
+});
+var zManifestPledgeAdjustment = _zod2.default.object({
+  account: _zod2.default.string(),
+  exchange: _zod2.default.string(),
+  amount: _zod2.default.string()
+});
+var zManifestTradelinkGroup = _zod2.default.object({
+  members: _zod2.default.array(zManifestUser),
+  quorum: _zod2.default.number()
+}).describe("Tradelink group");
+var zManifestTradelinkGroups = _zod2.default.array(zManifestTradelinkGroup);
+var zManifestTradelinkWhitelistAddress = _zod2.default.object({
+  name: _zod2.default.string().min(1),
+  currency: _zod2.default.string().min(1),
+  address: _zod2.default.string().min(1)
+}).describe("Tradelink whitelist address");
+var zManifestTradelinkWhitelist = _zod2.default.array(zManifestTradelinkWhitelistAddress).describe("Tradelink whitelist");
+var zManifestTradelinkEntity = _zod2.default.object({
+  name: _zod2.default.string(),
+  groups: zManifestTradelinkGroups,
+  whitelist: zManifestTradelinkWhitelist
+});
+var zManifestTradelinkCustodian = _zod2.default.object({
+  settlement: zManifestTradelinkGroups,
+  withdraw: zManifestTradelinkGroups,
+  arbitration: zManifestTradelinkGroups
+});
+var zManifestTradelinkNetworkBlueprint = _zod2.default.object({
+  custodian: _zod2.default.string(),
+  exchanges: _zod2.default.array(_zod2.default.string()),
+  assetManagers: _zod2.default.array(_zod2.default.string())
+});
+var zManifestTradelinkNetwork = _zod2.default.object({
+  networkBlueprint: zManifestTradelinkNetworkBlueprint.optional(),
+  custodian: zManifestTradelinkCustodian.optional(),
+  exchanges: _zod2.default.array(zManifestTradelinkEntity).optional(),
+  assetManagers: _zod2.default.array(zManifestTradelinkEntity).optional()
+}).describe("Tradelink network configuration");
+var zManifestWorkspace = _zod2.default.object({
+  tradelink: zManifestTradelinkNetwork.optional(),
+  users: _zod2.default.object({
+    admins: _zod2.default.array(zManifestUser).optional(),
+    operators: _zod2.default.array(zManifestUser).optional()
+  }).optional(),
+  groups: _zod2.default.array(zManifestGroup).optional(),
+  whitelists: _zod2.default.array(zManifestWhitelist).optional(),
+  policies: _zod2.default.array(zManifestPolicy).optional(),
+  accounts: _zod2.default.array(zManifestAccount).optional(),
+  pledges: _zod2.default.array(zManifestPledgeAdjustment).optional()
+}).describe("Workspace configuration");
+var zManifestTradelinkOrgEntity = _zod2.default.object({
+  name: _zod2.default.string(),
+  code: _zod2.default.string(),
+  logo: _zod2.default.string()
+}).describe("Tradelink organization entity");
+var zManifestTradelinkOrg = _zod2.default.object({
+  exchanges: _zod2.default.array(zManifestTradelinkOrgEntity).optional(),
+  assetManagers: _zod2.default.array(zManifestTradelinkOrgEntity).optional(),
+  custodians: _zod2.default.array(zManifestTradelinkOrgEntity).optional()
+}).describe("Tradelink organization configuration");
+var zManifest = _zod2.default.object({
+  manifestVersion: _zod2.default.literal(2),
+  tradelink: zManifestTradelinkOrg.optional(),
+  workspace: zManifestWorkspace.optional()
+});
+
+// src/bake/index.ts
+async function bakeManifest(options, logger) {
+  const {
+    engine,
+    workspaceName,
+    rootAuthToken,
+    manifest: { tradelink, workspace }
+  } = options;
+  if (tradelink) {
+    _invariant2.default.call(void 0, rootAuthToken, `rootAuthToken is required to create Tradelink org entities`);
+    await bakeTradelinkOrganization(
+      {
+        engine,
+        tradelink,
+        rootAuthToken,
+        ..._optionalChain([workspace, 'optionalAccess', _17 => _17.tradelink, 'optionalAccess', _18 => _18.networkBlueprint]) && workspaceName ? { networkBlueprint: { blueprint: workspace.tradelink.networkBlueprint, workspaceName } } : {}
+      },
+      logger
+    );
+  }
+  if (workspace) {
+    _invariant2.default.call(void 0, workspaceName, `Can't bake workspace without specifying a workspace name`);
+    await bakeWorkspace({ engine, workspace, workspaceName }, logger);
+    if (workspace.pledges) {
+      const engineWithWorkspace = engine.withWorkspace(workspaceName);
+      for (const pledgeAdjustment of workspace.pledges) {
+        await bakePledgeAdjustment({ engine: engineWithWorkspace, pledgeAdjustment }, logger);
+      }
+    }
+  }
+  logger.info("Successfully baked");
+}
+
+
+
+
+
+
+exports.bakeManifest = bakeManifest; exports.bakePledgeAdjustment = bakePledgeAdjustment; exports.createAndApproveRequest = createAndApproveRequest; exports.zManifest = zManifest; exports.zManifestPolicy = zManifestPolicy;
+//# sourceMappingURL=bake.cjs.map