@ledgerhq/revault-sdk 0.21.2 → 0.21.4

package/lib/bake.js

@@ -1,7 +1,7 @@
 import {
   createDeviceIndexResolver,
   fetchAll
-} from "./chunk-PEHCVOGV.js";
+} from "./chunk-IHGVWOD7.js";
 import {
   genKeys
 } from "./chunk-CZLZUISN.js";
@@ -44,6 +44,17 @@ async function createAndApproveRequest(input, approvers, logger) {
   const request = await creator.client.requests.create.mutate({ request: input });
   return approveRequest(request, approvers, logger);
 }
+function stripUndefinedDeep(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(stripUndefinedDeep);
+  }
+  if (obj && typeof obj === "object") {
+    return Object.fromEntries(
+      Object.entries(obj).filter(([_2, v]) => v !== void 0).map(([k, v]) => [k, stripUndefinedDeep(v)])
+    );
+  }
+  return obj;
+}
 
 // src/bake/bake-pledge.ts
 var flattenApprovers = (groups) => {
@@ -97,7 +108,7 @@ async function bakePledgeAdjustment(options, logger) {
   );
   await createAndApproveRequest(
     {
-      type: "ADJUST_PLEDGE",
+      type: "TRADELINK_ADJUST_PLEDGE",
       data: {
         accountId: account.id,
         exchangeId: exchange.id,
@@ -214,12 +225,14 @@ async function bakeWorkspace(options, logger) {
   const [
     existingUsers,
     existingGroups,
+    existingWhitelists,
     existingPolicies,
     existingAccounts,
     tradelinkNetworkBlueprint
   ] = await Promise.all([
     fetchAll(admin1.client.users.list.query, { status: "ACTIVE" }),
     fetchAll(admin1.client.groups.list.query, { status: "ACTIVE" }),
+    fetchAll(admin1.client.whitelists.list.query, { status: "ACTIVE" }),
     fetchAll(admin1.client.policies.list.query, { isPrivate: false }),
     fetchAll(admin1.client.accounts.list.query, { status: "ACTIVE" }),
     admin1.client.tradelink.getNetworkBlueprint.query()
@@ -275,9 +288,6 @@ async function bakeWorkspace(options, logger) {
     }
   }
   async function createWhitelists(whitelists) {
-    const existingWhitelists = await fetchAll(admin1.client.whitelists.list.query, {
-      status: "ACTIVE"
-    });
     for (const whitelist of whitelists) {
       await createWhitelist(whitelist);
     }
@@ -291,8 +301,10 @@ async function bakeWorkspace(options, logger) {
         type: "CREATE_WHITELIST",
         data: whitelist
       };
-      await createAndApproveRequest(input, [admin1, admin2], logger);
+      const req = await createAndApproveRequest(input, [admin1, admin2], logger);
       logSubStep(`Whitelist "${whitelist.name}" has been created`);
+      const createdWhitelist = await admin1.client.whitelists.findById.query({ id: req.targetId });
+      existingWhitelists.push(createdWhitelist);
     }
   }
   function govRuleFromManifest(rule) {
@@ -309,17 +321,17 @@ async function bakeWorkspace(options, logger) {
           quorum: step.quorum,
           userIds: step.members.map(userIdFromDeviceIndexOrName)
         };
-      })
+      }),
+      threshold: rule.threshold,
+      whitelistIds: rule.whitelistNames?.map(whitelistIdFromName)
     };
   }
   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}"`);
-    const input = {
+    let req = null;
+    const existing = existingAccounts.find(
+      (a) => a.currency === account.currency && a.index === account.index && (a.contractAddress ?? null) === (account.contractAddress ?? null)
+    );
+    const createInput = {
       type: "CREATE_ACCOUNT",
       data: {
         // general fields
@@ -342,8 +354,43 @@ async function bakeWorkspace(options, logger) {
         }
       }
     };
-    const req = await createAndApproveRequest(input, [admin1, admin2], logger);
-    if (account.governance.type === "TRADELINK") {
+    if (existing) {
+      const editInput = {
+        ...createInput,
+        type: "EDIT_ACCOUNT",
+        targetId: existing.id
+      };
+      const previousAccountRequests = await admin1.client.requests.list.query({
+        type: ["CREATE_ACCOUNT", "EDIT_ACCOUNT"],
+        targetId: existing.id,
+        state: "EXECUTED",
+        sortBy: "createdAt",
+        sortOrder: "desc"
+      });
+      if (previousAccountRequests?.results && previousAccountRequests.results.length > 0) {
+        const stateRequest = previousAccountRequests.results?.[0];
+        invariant3(
+          stateRequest && (stateRequest.type === "EDIT_ACCOUNT" || stateRequest.type === "CREATE_ACCOUNT"),
+          "State request should be an edit account request"
+        );
+        if (_.isEqual(
+          stripUndefinedDeep(createInput.data.governance),
+          stripUndefinedDeep(stateRequest.data.governance)
+        ) && createInput.data.name === stateRequest.data.name) {
+          logger.info(`[SKIPPED] Account "${account.name}" has not changed`);
+          return;
+        }
+        req = await createAndApproveRequest(editInput, [admin1, admin2], logger);
+        logger.info(`[EDITED] Account "${account.name}" has been edited`);
+        return;
+      }
+    } else {
+      logStep(`Creating account "${account.name}"`);
+      req = await createAndApproveRequest(createInput, [admin1, admin2], logger);
+      const createdAccount = await admin1.client.accounts.findById.query({ id: req.targetId });
+      existingAccounts.push(createdAccount);
+    }
+    if (account.governance.type === "TRADELINK" && req) {
       logStep(`Activating tradelink account "${account.name}"`);
       const assetManagerId = assetManagerIdFromName(account.governance.assetManager);
       const assetManager = existingTradelinkNetwork?.assetManagers.find(
@@ -359,7 +406,7 @@ async function bakeWorkspace(options, logger) {
         )
       );
       await createAndApproveRequest(
-        { type: "ACTIVATE_TRADELINK_ACCOUNT", targetId: req.targetId, data: {} },
+        { type: "TRADELINK_ACTIVATE_ACCOUNT", targetId: req.targetId, data: null },
         loggedAssetManagerOperators,
         logger
       );
@@ -495,7 +542,7 @@ async function bakeWorkspace(options, logger) {
         logSubStep("Creating request...");
         const request = await admin1.client.requests.create.mutate({
           request: {
-            type: "CREATE_TRADELINK_CUSTODIAN",
+            type: "TRADELINK_CREATE_CUSTODIAN",
             data
           }
         });
@@ -538,7 +585,7 @@ async function bakeWorkspace(options, logger) {
       logSubStep("Creating request...");
       const request = await admin1.client.requests.create.mutate({
         request: {
-          type: "CREATE_TRADELINK_EXCHANGE",
+          type: "TRADELINK_CREATE_EXCHANGE",
           data: {
             tradelinkId: exchangeId,
             groups: exchange.groups.map(tradelinkReviewStepFromManifest),
@@ -578,7 +625,7 @@ async function bakeWorkspace(options, logger) {
       logSubStep("Creating request...");
       const request = await admin1.client.requests.create.mutate({
         request: {
-          type: "CREATE_TRADELINK_ASSET_MANAGER",
+          type: "TRADELINK_CREATE_ASSET_MANAGER",
           data: {
             tradelinkId: assetManagerId,
             groups: assetManager.groups.map(tradelinkReviewStepFromManifest),
@@ -632,6 +679,11 @@ async function bakeWorkspace(options, logger) {
     invariant3(group, `Group ${groupName} not found`);
     return group.id;
   }
+  function whitelistIdFromName(whitelistName) {
+    const whitelist = existingWhitelists.find((w) => w.name === whitelistName);
+    invariant3(whitelist, `Whitelist ${whitelistName} not found`);
+    return whitelist.id;
+  }
   function assetManagerIdFromName(assetManagerName) {
     const orgAssetManager = tradelinkOrgAssetManagersByName[assetManagerName];
     invariant3(
@@ -666,32 +718,32 @@ async function bakeWorkspace(options, logger) {
 
 // src/bake/types.ts
 import z from "zod";
-var zManifestUser = z.number().describe("User device index");
-var zManifestUserName = z.string().describe("User name");
+var zManifestUser = z.number().meta({ description: "User device index" });
+var zManifestUserName = z.string().meta({ description: "User name" });
 var zManifestApiUser = z.object({
-  name: z.string().describe("API user name"),
-  role: z.enum(["ADMIN", "OPERATOR"]).describe("API user role").default("OPERATOR"),
-  pubKey: z.string().describe(
-    "API user public key. If not provided, one will be generated using the name as entropy"
-  ).optional(),
-  viewAll: z.boolean().describe("Whether the API user can view all accounts")
+  name: z.string().meta({ description: "API user name" }),
+  role: z.enum(["ADMIN", "OPERATOR"]).meta({ description: "API user role" }).default("OPERATOR"),
+  pubKey: z.string().meta({
+    description: "API user public key. If not provided, one will be generated using the name as entropy"
+  }).optional(),
+  viewAll: z.boolean().meta({ description: "Whether the API user can view all accounts" })
 });
 var zManifestGroup = z.object({
-  name: z.string().describe("Group name"),
-  members: z.array(z.union([zManifestUser, zManifestUserName])).describe("Group members")
-}).strict().describe("Operators group");
+  name: z.string().meta({ description: "Group name" }),
+  members: z.array(z.union([zManifestUser, zManifestUserName])).meta({ description: "Group members" })
+}).strict().meta({ description: "Operators group" });
 var zManifestWhitelistAddress = z.object({
-  name: z.string().describe("Whitelist address name"),
-  currency: z.string().describe("Whitelist address currency"),
-  address: z.string().describe("Whitelist address"),
-  destinationTags: z.array(z.string()).optional().describe("List of destination tags (applicable for Ripple currency)")
+  name: z.string().meta({ description: "Whitelist address name" }),
+  currency: z.string().meta({ description: "Whitelist address currency" }),
+  address: z.string().meta({ description: "Whitelist address" }),
+  destinationTags: z.array(z.string()).optional().meta({ description: "List of destination tags (applicable for Ripple currency)" })
 }).strict();
 var zManifestWhitelist = z.object({
-  name: z.string().describe("Whitelist name"),
-  description: z.string().optional().default("").describe("Whitelist description"),
-  type: z.enum(["TRANSACTION", "SMART_CONTRACT"]).optional().default("TRANSACTION").describe("Whitelist type"),
-  addresses: z.array(zManifestWhitelistAddress).describe("Whitelist addresses")
-}).strict().describe("Whitelist");
+  name: z.string().meta({ description: "Whitelist name" }),
+  description: z.string().optional().default("").meta({ description: "Whitelist description" }),
+  type: z.enum(["TRANSACTION", "SMART_CONTRACT"]).optional().default("TRANSACTION").meta({ description: "Whitelist type" }),
+  addresses: z.array(zManifestWhitelistAddress).meta({ description: "Whitelist addresses" })
+}).strict().meta({ description: "Whitelist" });
 var zManifestGovernanceStepWithUsers = z.object({
   quorum: z.number(),
   members: z.array(z.union([zManifestUser, zManifestUserName]))
@@ -708,11 +760,16 @@ var zManifestGovernanceRule = z.object({
   // TODO see if there is a way to import this from `api` package
   // (the challenge there is that enums are not transpiled)
   type: z.enum(["SEND", "STAKE", "DEPLOY_CONTRACT", "EXECUTE_CONTRACT", "SIGN_MESSAGE"]),
-  steps: z.array(zManifestGovernanceStep).min(1)
+  steps: z.array(zManifestGovernanceStep).min(1),
+  threshold: z.object({
+    min: z.string(),
+    max: z.string()
+  }).optional(),
+  whitelistNames: z.array(z.string()).optional()
 }).strict();
 var zManifestPolicy = z.object({
   name: z.string(),
-  currency: z.string(),
+  currency: z.string().nullable(),
   rules: z.array(zManifestGovernanceRule)
 }).strict();
 var zManifestClassicAccountGovernance = z.object({
@@ -720,13 +777,13 @@ var zManifestClassicAccountGovernance = z.object({
   rules: z.array(zManifestGovernanceRule)
 }).strict();
 var zManifestTradelinkExchangeConfig = z.object({
-  name: z.string().describe("Exchange name"),
-  repledgeAuthorized: z.boolean().optional().describe("Whether repledge is authorized"),
-  needsAssetManagerApprovalForSettlements: z.boolean().optional().describe("Whether asset manager pre approval is needed")
+  name: z.string().meta({ description: "Exchange name" }),
+  repledgeAuthorized: z.boolean().optional().meta({ description: "Whether repledge is authorized" }),
+  needsAssetManagerApprovalForSettlements: z.boolean().optional().meta({ description: "Whether asset manager pre approval is needed" })
 }).strict();
 var zManifestTradelinkAccountGovernance = z.object({
   type: z.literal("TRADELINK"),
-  assetManager: z.string().describe("Asset manager name"),
+  assetManager: z.string().meta({ description: "Asset manager name" }),
   exchanges: z.array(zManifestTradelinkExchangeConfig)
 }).strict();
 var zManifestAccountGovernance = z.discriminatedUnion("type", [
@@ -736,7 +793,7 @@ var zManifestAccountGovernance = z.discriminatedUnion("type", [
 var zManifestAccount = z.object({
   name: z.string(),
   currency: z.string(),
-  index: z.number().nonnegative().optional(),
+  index: z.number().nonnegative(),
   contractAddress: z.string().optional(),
   governance: zManifestAccountGovernance
 }).strict();
@@ -748,14 +805,14 @@ var zManifestPledgeAdjustment = z.object({
 var zManifestTradelinkGroup = z.object({
   members: z.array(zManifestUser),
   quorum: z.number()
-}).strict().describe("Tradelink group");
+}).strict().meta({ description: "Tradelink group" });
 var zManifestTradelinkGroups = z.array(zManifestTradelinkGroup);
 var zManifestTradelinkWhitelistAddress = z.object({
   name: z.string().min(1),
   currency: z.string().min(1),
   address: z.string().min(1)
-}).strict().describe("Tradelink whitelist address");
-var zManifestTradelinkWhitelist = z.array(zManifestTradelinkWhitelistAddress).describe("Tradelink whitelist");
+}).strict().meta({ description: "Tradelink whitelist address" });
+var zManifestTradelinkWhitelist = z.array(zManifestTradelinkWhitelistAddress).meta({ description: "Tradelink whitelist" });
 var zManifestTradelinkEntity = z.object({
   name: z.string(),
   groups: zManifestTradelinkGroups,
@@ -776,7 +833,7 @@ var zManifestTradelinkNetwork = z.object({
   custodian: zManifestTradelinkCustodian.optional(),
   exchanges: z.array(zManifestTradelinkEntity).optional(),
   assetManagers: z.array(zManifestTradelinkEntity).optional()
-}).strict().describe("Tradelink network configuration");
+}).strict().meta({ description: "Tradelink network configuration" });
 var zManifestWorkspace = z.object({
   tradelink: zManifestTradelinkNetwork.optional(),
   users: z.object({
@@ -789,17 +846,17 @@ var zManifestWorkspace = z.object({
   policies: z.array(zManifestPolicy).optional(),
   accounts: z.array(zManifestAccount).optional(),
   pledges: z.array(zManifestPledgeAdjustment).optional()
-}).strict().describe("Workspace configuration");
+}).strict().meta({ description: "Workspace configuration" });
 var zManifestTradelinkOrgEntity = z.object({
   name: z.string(),
   code: z.string(),
   logo: z.string()
-}).strict().describe("Tradelink organization entity");
+}).strict().meta({ description: "Tradelink organization entity" });
 var zManifestTradelinkOrg = z.object({
   exchanges: z.array(zManifestTradelinkOrgEntity).optional(),
   assetManagers: z.array(zManifestTradelinkOrgEntity).optional(),
   custodians: z.array(zManifestTradelinkOrgEntity).optional()
-}).strict().describe("Tradelink organization configuration");
+}).strict().meta({ description: "Tradelink organization configuration" });
 var zManifest = z.object({
   manifestVersion: z.literal(2),
   tradelink: zManifestTradelinkOrg.optional(),