@ledgerhq/revault-api 1.43.1 → 1.44.0

package/lib/fakes.mjs

@@ -1,10 +1,11 @@
 import { __export } from './chunk-J5LGTIGS.mjs';
 import { faker } from '@faker-js/faker';
-import { AccountType, ChallengeType, PsdModel, UserRole, UserRegistrationState, AllowedAction, AdminPermission, RequestType, AccountGovernanceType, ActivationStatus, MessageType, WhitelistType, RequestReviewStatus, RequestState, GateAccountType } from '@prisma/client';
-import 'ts-pattern';
+import { ChallengeType, PsdModel, UserRole, UserRegistrationState, AllowedAction, AdminPermission, RequestType, AccountGovernanceType, ActivationStatus, AccountType, MessageType, WhitelistType, UserDeviceType, RequestReviewStatus, RequestState, GateAccountType, GateUserType } from '@prisma/client';
+import { match, P } from 'ts-pattern';
 import z14, { z } from 'zod';
-import { omit, times, get, isPlainObject } from 'lodash';
 import invariant8 from 'invariant';
+import elliptic from 'elliptic';
+import { omit, times, get, isPlainObject } from 'lodash-es';
 import 'axios';
 
 var zHexString = z.string().regex(/^[0-9a-fA-F]+$/);
@@ -27,7 +28,21 @@ z.codec(z.iso.datetime(), z.date(), {
 });
 
 // src/networks/common.ts
-var NetworkFamily = omit(AccountType, ["RAW_SIGNING"]);
+var NetworkFamily = {
+  BITCOIN_LIKE: "BITCOIN_LIKE",
+  CANTON_LIKE: "CANTON_LIKE",
+  CARDANO_LIKE: "CARDANO_LIKE",
+  ETHEREUM_LIKE: "ETHEREUM_LIKE",
+  GENERIC_LIKE: "GENERIC_LIKE",
+  HEDERA_LIKE: "HEDERA_LIKE",
+  POLKADOT_LIKE: "POLKADOT_LIKE",
+  RIPPLE_LIKE: "RIPPLE_LIKE",
+  SOLANA_LIKE: "SOLANA_LIKE",
+  STELLAR_LIKE: "STELLAR_LIKE",
+  SUI_LIKE: "SUI_LIKE",
+  TEZOS_LIKE: "TEZOS_LIKE",
+  TRON_LIKE: "TRON_LIKE"
+};
 var zHexDataString = z14.codec(z14.string().regex(/^(?:0x|0X)?[a-fA-F0-9]+$/), z14.string(), {
   decode: (hex) => `0x${hex.toLowerCase().replace("0x", "")}`,
   encode: (hex) => hex
@@ -89,19 +104,22 @@ var zBitcoinLikeSendData = zCommonTransactionData.extend({
   id: "BitcoinLikeSendData"
 });
 var zBitcoinLikeTransactionData = z14.discriminatedUnion("type", [zBitcoinLikeSendData]);
+var zBitcoinLikeEstimatedFees = z14.object({
+  type: z14.literal(NetworkFamily.BITCOIN_LIKE),
+  fee: zIntString
+}).meta({ description: "Bitcoin-like fees" });
 var zBitcoinLikeTransactionResponse = z14.discriminatedUnion("type", [
   zCommonTransactionResponse.extend({ type: zBitcoinLikeTransactionType }).meta({ description: "Bitcoin-like transaction" })
 ]);
 
 // src/networks/bitcoin/index.ts
 var BITCOIN_SPEC = {
-  family: NetworkFamily.BITCOIN_LIKE,
   zAssetFields: zBitcoinLikeAssetFields,
   zLiveData: zBitcoinLikeLiveData,
   zTransactionType: zBitcoinLikeTransactionType,
   zTransactionData: zBitcoinLikeTransactionData,
   zSendTransactionData: zBitcoinLikeSendData,
-  zEstimatedFees: z14.never(),
+  zEstimatedFees: zBitcoinLikeEstimatedFees,
   zTransactionResponse: zBitcoinLikeTransactionResponse,
   zStakingFields: z14.never()};
 var zCantonTransferProposal = z14.object({
@@ -204,7 +222,6 @@ var zCantonLikeTransactionResponse = z14.discriminatedUnion("type", [
 
 // src/networks/canton/index.ts
 var CANTON_SPEC = {
-  family: NetworkFamily.CANTON_LIKE,
   zAssetFields: zCantonLikeAssetFields,
   zLiveData: zCantonLikeLiveData,
   zTransactionType: zCantonLikeTransactionType,
@@ -301,7 +318,6 @@ var zCardanoLikeTransactionResponse = z14.discriminatedUnion("type", [
 
 // src/networks/cardano/index.ts
 var CARDANO_SPEC = {
-  family: NetworkFamily.CARDANO_LIKE,
   zAssetFields: zCardanoLikeAssetFields,
   zLiveData: zCardanoLikeLiveData,
   zTransactionType: zCardanoLikeTransactionType,
@@ -403,7 +419,6 @@ var zEthereumLikeTransactionResponse = z14.discriminatedUnion("type", [
 
 // src/networks/ethereum/index.ts
 var ETHEREUM_SPEC = {
-  family: NetworkFamily.ETHEREUM_LIKE,
   zAssetFields: zEthereumLikeAssetFields,
   zLiveData: zEthereumLikeLiveData,
   zTransactionType: zEthereumLikeTransactionType,
@@ -433,7 +448,6 @@ var zGenericTransactionResponse = z14.discriminatedUnion("type", [
 
 // src/networks/generic/index.ts
 var GENERIC_SPEC = {
-  family: NetworkFamily.GENERIC_LIKE,
   zAssetFields: zGenericAssetFields,
   zLiveData: zGenericLiveData,
   zTransactionType: zGenericTransactionType,
@@ -444,7 +458,8 @@ var GENERIC_SPEC = {
   zStakingFields: z14.never()};
 var zHederaLikeAssetFields = z14.object({
   type: z14.literal(NetworkFamily.HEDERA_LIKE).meta({ description: "Account type" }),
-  address: z14.string().nullable().meta({ description: "Account address" })
+  address: z14.string().nullable().meta({ description: "Account address" }),
+  isActivated: z14.boolean().meta({ description: "Indicates if the account is activated" })
 }).meta({ description: "Hedera-like" });
 var zHederaLikeEstimatedFees = z14.object({
   type: z14.literal(NetworkFamily.HEDERA_LIKE),
@@ -485,7 +500,6 @@ var zHederaLikeTransactionResponse = z14.discriminatedUnion("type", [
 
 // src/networks/hedera/index.ts
 var HEDERA_SPEC = {
-  family: NetworkFamily.HEDERA_LIKE,
   zAssetFields: zHederaLikeAssetFields,
   zLiveData: zHederaLikeLiveData,
   zTransactionType: zHederaLikeTransactionType,
@@ -681,7 +695,6 @@ var zPolkadotLikeTransactionResponse = z14.discriminatedUnion("type", [
 
 // src/networks/polkadot/index.ts
 var POLKADOT_SPEC = {
-  family: NetworkFamily.POLKADOT_LIKE,
   zAssetFields: zPolkadotLikeAssetFields,
   zLiveData: zPolkadotLikeLiveData,
   zTransactionType: zPolkadotLikeTransactionType,
@@ -721,7 +734,6 @@ var zRippleLikeTransactionResponse = z14.discriminatedUnion("type", [
 
 // src/networks/ripple/index.ts
 var RIPPLE_SPEC = {
-  family: NetworkFamily.RIPPLE_LIKE,
   zAssetFields: zRippleLikeAssetFields,
   zLiveData: zRippleLikeLiveData,
   zTransactionType: zRippleLikeTransactionType,
@@ -917,7 +929,6 @@ var zSolanaLikeTransactionResponse = z14.discriminatedUnion("type", [
 
 // src/networks/solana/index.ts
 var SOLANA_SPEC = {
-  family: NetworkFamily.SOLANA_LIKE,
   zAssetFields: zSolanaLikeAssetFields,
   zLiveData: zSolanaLikeLiveData,
   zTransactionType: zSolanaLikeTransactionType,
@@ -938,16 +949,22 @@ var zStellarLikeEstimatedFees = z14.object({
   fee: zIntString
 }).meta({ description: "Stellar-like fees" });
 var zStellarLikeTransactionType = z14.enum(["STELLAR_LIKE_SEND", "STELLAR_LIKE_RECEIVE"]).meta({ description: "Stellar-like transaction type" });
-var zStellarMemo = z14.union([
+var zStellarMemo = z14.discriminatedUnion("type", [
   z14.object({
-    MEMO_TEXT: z14.string().max(28).meta({ description: "Text memo (at most a 28 bytes string)" })
+    type: z14.literal("MEMO_TEXT"),
+    value: z14.string().max(28).meta({ description: "Text memo (at most a 28 bytes string)" })
   }).meta({ description: "Text memo" }),
-  z14.object({ MEMO_ID: zIntString.meta({ description: "Id memo (unsigned 64 bits integer)" }) }).meta({ description: "Id memo" }),
   z14.object({
-    MEMO_HASH: z14.string().max(128).regex(/^[a-fA-F0-9]+$/).meta({ description: "Transaction hash memo (64 bytes hexadecimal string)" })
+    type: z14.literal("MEMO_ID"),
+    value: zIntString.meta({ description: "Id memo (unsigned 64 bits integer)" })
+  }).meta({ description: "Id memo" }),
+  z14.object({
+    type: z14.literal("MEMO_HASH"),
+    value: z14.string().max(128).regex(/^[a-fA-F0-9]+$/).meta({ description: "Transaction hash memo (64 bytes hexadecimal string)" })
   }).meta({ description: "Hash memo" }),
   z14.object({
-    MEMO_RETURN: z14.string().max(128).regex(/^[a-fA-F0-9]+$/).meta({
+    type: z14.literal("MEMO_RETURN"),
+    value: z14.string().max(128).regex(/^[a-fA-F0-9]+$/).meta({
       description: "A 64 bytes hexadecimal string intended to be interpreted as the hash of the transaction the sender is refunding."
     })
   }).meta({ description: "Return memo" })
@@ -967,7 +984,6 @@ var zStellarLikeTransactionResponse = z14.discriminatedUnion("type", [
 
 // src/networks/stellar/index.ts
 var STELLAR_SPEC = {
-  family: NetworkFamily.STELLAR_LIKE,
   zAssetFields: zStellarLikeAssetFields,
   zLiveData: zStellarLikeLiveData,
   zTransactionType: zStellarLikeTransactionType,
@@ -1057,7 +1073,6 @@ var zSuiLikeTransactionResponse = z14.discriminatedUnion("type", [
 
 // src/networks/sui/index.ts
 var SUI_SPEC = {
-  family: NetworkFamily.SUI_LIKE,
   zAssetFields: zSuiLikeAssetFields,
   zLiveData: zSuiLikeLiveData,
   zTransactionType: zSuiLikeTransactionType,
@@ -1134,7 +1149,6 @@ var zTezosLikeTransactionResponse = z14.discriminatedUnion("type", [
 
 // src/networks/tezos/index.ts
 var TEZOS_SPEC = {
-  family: NetworkFamily.TEZOS_LIKE,
   zAssetFields: zTezosLikeAssetFields,
   zLiveData: zTezosLikeLiveData,
   zTransactionType: zTezosLikeTransactionType,
@@ -1182,7 +1196,6 @@ var zTronLikeTransactionResponse = z14.discriminatedUnion("type", [
 
 // src/networks/tron/index.ts
 var TRON_SPEC = {
-  family: NetworkFamily.TRON_LIKE,
   zAssetFields: zTronLikeAssetFields,
   zLiveData: zTronLikeLiveData,
   zTransactionType: zTronLikeTransactionType,
@@ -1232,6 +1245,7 @@ z14.discriminatedUnion("type", [
   TEZOS_SPEC.zStakingFields
 ]);
 z14.discriminatedUnion("type", [
+  BITCOIN_SPEC.zEstimatedFees,
   ETHEREUM_SPEC.zEstimatedFees,
   HEDERA_SPEC.zEstimatedFees,
   RIPPLE_SPEC.zEstimatedFees,
@@ -1270,11 +1284,6 @@ z14.union([
   ...TEZOS_SPEC.zTransactionType.enum,
   ...TRON_SPEC.zTransactionType.enum
 });
-({
-  ...NetworkFamily,
-  // TODO: Sometimes `NetworkFamily` is not a `TransactionType` prefix - but why?
-  [NetworkFamily.GENERIC_LIKE]: "GENERIC"
-});
 var zTransactionData = z14.discriminatedUnion("type", [
   ...BITCOIN_SPEC.zTransactionData.options,
   ...CANTON_SPEC.zTransactionData.options,
@@ -1334,6 +1343,14 @@ var buildGateSyncId = (workspaceName, gateType, gateId) => {
 
 // src/utils.ts
 var isRecord = (value) => isPlainObject(value);
+var randomHex = (length) => {
+  const hexBytes = times(length, () => {
+    const randomByte = Math.floor(Math.random() * 256);
+    return randomByte.toString(16).padStart(2, "0");
+  });
+  return hexBytes.join("").toUpperCase();
+};
+var genAuthUserId = () => randomHex(20);
 var ensureNonEmptyArray = (values, message) => {
   invariant8(
     values.length > 0,
@@ -1346,9 +1363,11 @@ function unreachable(value) {
 }
 
 // src/__fakes__/faker-utils.ts
+var { ec: EC } = elliptic;
 var fakeUniqueName = (length = 20) => faker.string.alphanumeric({ length, casing: "lower" });
 var fakeHexString = (length, casing = "upper") => faker.string.hexadecimal({ prefix: "", casing, length });
-var fakePubKey = () => fakeHexString(130);
+var fakePubKey = () => new EC("p256").genKeyPair().getPublic(false, "hex");
+var fakeDeviceUserId = () => faker.string.hexadecimal({ prefix: "", casing: "upper", length: 16 });
 var fakeIntegerId = () => faker.number.int({ min: 1, max: 2e9 });
 var fakeGateId = fakeIntegerId;
 var fakeBase64String = (length) => btoa(faker.string.sample(length));
@@ -1373,6 +1392,8 @@ var fakeWorkspaceName = () => faker.string.alphanumeric({ length: 16, casing: "l
 // src/__fakes__/canton.ts
 var fakeCantonAddress = (role) => `${role}-${faker.lorem.word()}::${fakeHexString(68, "lower")}`;
 var fakeCantonPartyId = () => fakeCantonAddress("party");
+var fakeCantonContractId = () => fakeHexString(138, "lower");
+var fakeCantonInstrumentId = () => fakeHexString(10, "lower");
 var injectSyncId = (obj) => {
   let { syncId } = obj;
   if (syncId === void 0) {
@@ -1652,6 +1673,488 @@ var genAccount = (opts) => {
     ...rest
   });
 };
+var genSignMessageData = (opts) => ({
+  message: {
+    type: "EIP191",
+    data: fakeHexString(10, "upper")
+  },
+  accountId: faker.string.uuid(),
+  address: faker.finance.ethereumAddress(),
+  derivationPath: "44'/60'/0'/0/0",
+  ...opts
+});
+var genBitcoinLikeSendData = (opts) => {
+  return {
+    type: "BITCOIN_LIKE_SEND",
+    currency: "bitcoin",
+    amount: faker.number.bigInt({ min: 0 }).toString(),
+    maxFee: faker.number.bigInt({ min: 1 }).toString(),
+    recipient: faker.finance.bitcoinAddress(),
+    feeStrategy: {
+      type: faker.helpers.arrayElement(["SLOW", "NORMAL", "FAST", "CUSTOM"]),
+      feePerByte: faker.number.bigInt({ min: 1 }).toString()
+    },
+    ...opts
+  };
+};
+var genCardanoLikeTxData = (txType) => {
+  switch (txType) {
+    case "CARDANO_LIKE_SEND":
+      return {
+        type: txType,
+        currency: "cardano",
+        amount: faker.number.bigInt({ min: 0 }).toString(),
+        maxFee: faker.number.bigInt({ min: 1 }).toString(),
+        recipient: faker.string.alphanumeric({ length: 30 }),
+        feeStrategy: {
+          type: faker.helpers.arrayElement(["SLOW", "NORMAL", "FAST"])
+        }
+      };
+    case "CARDANO_LIKE_STAKING_DELEGATE":
+      return {
+        type: txType,
+        currency: "cardano",
+        maxFee: faker.number.bigInt({ min: 1 }).toString(),
+        stakePoolId: `pool${faker.string.alphanumeric({ length: 52 })}`,
+        feeStrategy: {
+          type: faker.helpers.arrayElement(["SLOW", "NORMAL", "FAST"])
+        }
+      };
+    case "CARDANO_LIKE_STAKING_REGISTER":
+    case "CARDANO_LIKE_STAKING_DEREGISTER":
+    case "CARDANO_LIKE_STAKING_WITHDRAW":
+      return {
+        type: txType,
+        currency: "cardano",
+        maxFee: faker.number.bigInt({ min: 1 }).toString(),
+        amount: faker.number.bigInt({ min: 0 }).toString(),
+        feeStrategy: {
+          type: faker.helpers.arrayElement(["SLOW", "NORMAL", "FAST"])
+        }
+      };
+  }
+};
+var genEthereumLikeSendData = (opts) => {
+  const gasLimit = faker.number.bigInt({ min: 1 });
+  const gasPrice = faker.number.bigInt({ min: 1 });
+  const maxFee = gasLimit * gasPrice;
+  return {
+    type: "ETHEREUM_LIKE_SEND",
+    currency: "ethereum",
+    amount: faker.number.bigInt({ min: 0 }).toString(),
+    maxFee: maxFee.toString(),
+    recipient: faker.finance.bitcoinAddress(),
+    feeStrategy: {
+      type: faker.helpers.arrayElement(["SLOW", "NORMAL", "FAST", "CUSTOM"]),
+      gasLimit: gasLimit.toString(),
+      gasPrice: gasPrice.toString()
+    },
+    ...opts
+  };
+};
+var genEthereumLikeExecuteContractData = (opts) => {
+  const sendData = genEthereumLikeSendData();
+  return {
+    ...omit(sendData, ["type"]),
+    type: "ETHEREUM_LIKE_EXECUTE_CONTRACT",
+    contractData: faker.string.hexadecimal({ prefix: "", casing: "lower", length: 128 }),
+    ...opts
+  };
+};
+var genEthereumLikeDeployContractData = (opts) => {
+  const sendData = genEthereumLikeSendData();
+  return {
+    ...omit(sendData, ["type"]),
+    type: "ETHEREUM_LIKE_DEPLOY_CONTRACT",
+    recipient: "0x0000000000000000000000000000000000000000",
+    contractData: faker.string.hexadecimal({ prefix: "", casing: "lower", length: 128 }),
+    ...opts
+  };
+};
+var genGenericTransactionData = () => {
+  return {
+    type: "GENERIC_TRANSACTION",
+    currency: "tron",
+    rawTx: faker.string.alphanumeric({ length: 100 })
+  };
+};
+var genHederaLikeSendData = (txType) => {
+  return {
+    type: txType,
+    currency: "hedera",
+    amount: faker.number.bigInt({ min: 0 }).toString(),
+    maxFee: faker.number.bigInt({ min: 1 }).toString(),
+    recipient: `0.0.${faker.number.int({ min: 1e7, max: 99999999 }).toString()}`,
+    feeStrategy: {
+      type: faker.helpers.arrayElement(["SLOW", "NORMAL", "FAST"])
+    }
+  };
+};
+var genPolkadotLikeTxData = (txType) => {
+  switch (txType) {
+    case "POLKADOT_LIKE_SEND":
+      return {
+        type: txType,
+        currency: "polkadot",
+        amount: faker.number.bigInt({ min: 0 }).toString(),
+        maxFee: faker.number.bigInt({ min: 1 }).toString(),
+        recipient: faker.string.alphanumeric({ length: 30 })
+      };
+    case "POLKADOT_LIKE_ADDPROXY":
+    case "POLKADOT_LIKE_REMOVEPROXY":
+      return {
+        type: txType,
+        currency: "polkadot",
+        kind: "Staking",
+        proxy: faker.string.alphanumeric({ length: 30 })
+      };
+    case "POLKADOT_LIKE_BOND":
+      return {
+        type: txType,
+        currency: "polkadot",
+        payee: faker.helpers.arrayElement(["Staked", "Stash"]),
+        amount: faker.number.bigInt({ min: 0 }).toString()
+      };
+    case "POLKADOT_LIKE_REBOND":
+    case "POLKADOT_LIKE_UNBOND":
+      return {
+        type: txType,
+        currency: "polkadot",
+        amount: faker.number.bigInt({ min: 0 }).toString()
+      };
+    case "POLKADOT_LIKE_BONDEXTRA":
+      return {
+        type: txType,
+        currency: "polkadot",
+        amount: faker.number.bigInt({ min: 0 }).toString()
+      };
+    case "POLKADOT_LIKE_WITHDRAWUNBONDED":
+    case "POLKADOT_LIKE_CHILL":
+      return {
+        type: txType,
+        currency: "polkadot"
+      };
+    case "POLKADOT_LIKE_SETPAYEE":
+      return {
+        type: txType,
+        currency: "polkadot",
+        payee: faker.helpers.arrayElement(["Staked", "Stash"])
+      };
+    case "POLKADOT_LIKE_ANONYMOUSPROXY":
+    case "POLKADOT_LIKE_KILLANONYMOUS":
+      return {
+        type: txType,
+        currency: "polkadot"
+      };
+  }
+};
+var genRippleLikeSendData = (txType) => {
+  return {
+    type: txType,
+    currency: "ripple",
+    amount: faker.number.bigInt({ min: 0 }).toString(),
+    maxFee: faker.number.bigInt({ min: 1 }).toString(),
+    recipient: faker.string.alphanumeric({ length: 30 }),
+    destinationTag: faker.helpers.arrayElement([faker.number.int().toString(), null]),
+    feeStrategy: {
+      type: faker.helpers.arrayElement(["SLOW", "NORMAL", "FAST"])
+    }
+  };
+};
+var genSolanaLikeTxData = (txType) => {
+  switch (txType) {
+    case "SOLANA_LIKE_SEND":
+    case "SOLANA_LIKE_CREATE_DELEGATE_STAKE":
+    case "SOLANA_LIKE_SEND_TOKEN":
+    case "SOLANA_LIKE_FUND_AND_SEND_TOKEN":
+      return {
+        type: txType,
+        currency: "solana",
+        amount: faker.number.bigInt({ min: 0 }).toString(),
+        maxFee: faker.number.bigInt({ min: 1 }).toString(),
+        recipient: faker.string.alphanumeric({ length: 30 }),
+        feeStrategy: {
+          type: faker.helpers.arrayElement(["SLOW", "NORMAL", "FAST"])
+        }
+      };
+    case "SOLANA_LIKE_DELEGATE_STAKE":
+      return {
+        type: txType,
+        currency: "solana",
+        maxFee: faker.number.bigInt({ min: 1 }).toString(),
+        recipient: faker.string.alphanumeric({ length: 30 }),
+        stakeAccount: faker.string.alphanumeric({ length: 30 }),
+        feeStrategy: {
+          type: faker.helpers.arrayElement(["SLOW", "NORMAL", "FAST"])
+        }
+      };
+    case "SOLANA_LIKE_DEACTIVATE_STAKE":
+      return {
+        type: txType,
+        currency: "solana",
+        maxFee: faker.number.bigInt({ min: 1 }).toString(),
+        stakeAccount: faker.string.alphanumeric({ length: 30 }),
+        feeStrategy: {
+          type: faker.helpers.arrayElement(["SLOW", "NORMAL", "FAST"])
+        }
+      };
+    case "SOLANA_LIKE_SPLIT_DEACTIVATE_STAKE":
+    case "SOLANA_LIKE_SPLIT_STAKE":
+    case "SOLANA_LIKE_WITHDRAW_STAKE":
+      return {
+        type: txType,
+        currency: "solana",
+        amount: faker.number.bigInt({ min: 0 }).toString(),
+        maxFee: faker.number.bigInt({ min: 1 }).toString(),
+        stakeAccount: faker.string.alphanumeric({ length: 30 }),
+        feeStrategy: {
+          type: faker.helpers.arrayElement(["SLOW", "NORMAL", "FAST"])
+        }
+      };
+    case "SOLANA_LIKE_MERGE_STAKE":
+      return {
+        type: txType,
+        currency: "solana",
+        maxFee: faker.number.bigInt({ min: 1 }).toString(),
+        mergeSrcAccount: faker.string.alphanumeric({ length: 30 }),
+        mergeDstAccount: faker.string.alphanumeric({ length: 30 }),
+        feeStrategy: {
+          type: faker.helpers.arrayElement(["SLOW", "NORMAL", "FAST"])
+        }
+      };
+    case "SOLANA_LIKE_CREATE_SPL_TOKEN_ACCOUNT":
+      return {
+        type: txType,
+        currency: "solana",
+        maxFee: faker.number.bigInt({ min: 1 }).toString(),
+        feeStrategy: {
+          type: faker.helpers.arrayElement(["SLOW", "NORMAL", "FAST"])
+        }
+      };
+  }
+};
+var genStellarLikeSendData = (txType) => {
+  return {
+    type: txType,
+    currency: "stellar",
+    amount: faker.number.bigInt({ min: 0 }).toString(),
+    maxFee: faker.number.bigInt({ min: 1 }).toString(),
+    recipient: faker.string.alphanumeric({ length: 30 }),
+    memo: faker.helpers.arrayElement([
+      { type: "MEMO_ID", value: faker.number.bigInt({ min: 0 }).toString() },
+      { type: "MEMO_TEXT", value: faker.word.conjunction(28) },
+      {
+        type: "MEMO_HASH",
+        value: faker.string.hexadecimal({ prefix: "", casing: "lower", length: 64 })
+      },
+      {
+        type: "MEMO_RETURN",
+        value: faker.string.hexadecimal({ prefix: "", casing: "lower", length: 64 })
+      },
+      null
+    ]),
+    feeStrategy: {
+      type: faker.helpers.arrayElement(["SLOW", "NORMAL", "FAST"])
+    }
+  };
+};
+var genSuiLikeTxData = (txType) => {
+  return {
+    currency: "sui",
+    amount: faker.number.bigInt({ min: 0 }).toString(),
+    maxFee: faker.number.bigInt({ min: 1 }).toString(),
+    feeStrategy: {
+      type: faker.helpers.arrayElement(["SLOW", "NORMAL", "FAST"])
+    },
+    ...match(txType).with("SUI_LIKE_STAKE", (type) => ({
+      type,
+      validator: faker.string.alphanumeric({ length: 30 })
+    })).with("SUI_LIKE_UNSTAKE", (type) => ({
+      type,
+      stakedSuiId: faker.string.alphanumeric({ length: 30 }),
+      useAllAmount: faker.datatype.boolean()
+    })).with(P.union("SUI_LIKE_SEND", "SUI_LIKE_SEND_TOKEN"), (type) => ({
+      type,
+      recipient: faker.string.alphanumeric({ length: 30 })
+    })).exhaustive()
+  };
+};
+var genTezosLikeTxData = (txType) => {
+  return {
+    type: txType,
+    currency: "tezos",
+    amount: faker.number.bigInt({ min: 0 }).toString(),
+    maxFee: faker.number.bigInt({ min: 1 }).toString(),
+    recipient: faker.string.alphanumeric({ length: 30 }),
+    feeStrategy: {
+      type: faker.helpers.arrayElement(["SLOW", "NORMAL", "FAST", "CUSTOM"])
+    }
+  };
+};
+var genTronLikeTxData = (txType) => {
+  return {
+    type: txType,
+    currency: "tron",
+    amount: faker.number.bigInt({ min: 0 }).toString(),
+    maxFee: faker.number.bigInt({ min: 1 }).toString(),
+    recipient: faker.string.alphanumeric({ length: 30 }),
+    feeStrategy: {
+      type: faker.helpers.arrayElement(["SLOW", "NORMAL", "FAST"])
+    }
+  };
+};
+var genCantonTransferProposal = () => ({
+  amount: faker.number.bigInt({ min: 0 }).toString(),
+  contractId: fakeCantonContractId(),
+  instrumentId: fakeCantonInstrumentId(),
+  expiresAtMicros: faker.date.future().getTime() * 1e3,
+  memo: faker.lorem.sentence(),
+  sender: fakeCantonPartyId(),
+  recipient: fakeCantonPartyId()
+});
+var genCantonLikeTxData = (txType) => {
+  switch (txType) {
+    case "CANTON_LIKE_SEND":
+    case "CANTON_LIKE_SEND_TOKEN":
+      return {
+        type: txType,
+        currency: "canton_network",
+        amount: faker.number.bigInt({ min: 0 }).toString(),
+        recipient: fakeCantonPartyId()
+      };
+    case "CANTON_LIKE_WITHDRAW":
+      return {
+        type: txType,
+        currency: "canton_network",
+        transferProposal: genCantonTransferProposal(),
+        reason: faker.lorem.sentence()
+      };
+    case "CANTON_LIKE_RECEIVE":
+      return {
+        type: txType,
+        currency: "canton_network",
+        transferProposal: genCantonTransferProposal(),
+        verdict: "ACCEPT",
+        reason: faker.lorem.sentence()
+      };
+    case "CANTON_LIKE_PRE_APPROVAL":
+      return {
+        type: txType,
+        currency: "canton_network",
+        recipient: fakeCantonPartyId()
+      };
+    case "CANTON_LIKE_TAP":
+      return {
+        type: txType,
+        currency: "canton_network",
+        amount: faker.number.bigInt({ min: 0 }).toString(),
+        maxFee: null,
+        recipient: fakeCantonPartyId()
+      };
+  }
+};
+var mergeTransactionData = (defaults, custom) => {
+  const merged = {
+    ...defaults,
+    ...custom,
+    type: defaults.type
+    // make sure `type` comes from `defaults`
+  };
+  return zTransactionData.parse(merged);
+};
+var genCreateTransactionData = (opts) => {
+  const { accountId, transaction } = opts ?? {};
+  const transactionType = transaction?.type ?? "ETHEREUM_LIKE_SEND";
+  let transactionDefaults;
+  switch (transactionType) {
+    case "BITCOIN_LIKE_SEND":
+      transactionDefaults = genBitcoinLikeSendData();
+      break;
+    case "CANTON_LIKE_SEND":
+    case "CANTON_LIKE_SEND_TOKEN":
+    case "CANTON_LIKE_WITHDRAW":
+    case "CANTON_LIKE_RECEIVE":
+    case "CANTON_LIKE_PRE_APPROVAL":
+    case "CANTON_LIKE_TAP":
+      transactionDefaults = genCantonLikeTxData(transactionType);
+      break;
+    case "CARDANO_LIKE_SEND":
+    case "CARDANO_LIKE_STAKING_REGISTER":
+    case "CARDANO_LIKE_STAKING_DEREGISTER":
+    case "CARDANO_LIKE_STAKING_DELEGATE":
+    case "CARDANO_LIKE_STAKING_WITHDRAW":
+      transactionDefaults = genCardanoLikeTxData(transactionType);
+      break;
+    case "ETHEREUM_LIKE_SEND":
+      transactionDefaults = genEthereumLikeSendData();
+      break;
+    case "ETHEREUM_LIKE_EXECUTE_CONTRACT":
+      transactionDefaults = genEthereumLikeExecuteContractData();
+      break;
+    case "ETHEREUM_LIKE_DEPLOY_CONTRACT":
+      transactionDefaults = genEthereumLikeDeployContractData();
+      break;
+    case "GENERIC_TRANSACTION":
+      transactionDefaults = genGenericTransactionData();
+      break;
+    case "HEDERA_LIKE_SEND":
+    case "HEDERA_LIKE_SEND_TOKEN":
+      transactionDefaults = genHederaLikeSendData(transactionType);
+      break;
+    case "POLKADOT_LIKE_SEND":
+    case "POLKADOT_LIKE_ADDPROXY":
+    case "POLKADOT_LIKE_REMOVEPROXY":
+    case "POLKADOT_LIKE_BOND":
+    case "POLKADOT_LIKE_REBOND":
+    case "POLKADOT_LIKE_BONDEXTRA":
+    case "POLKADOT_LIKE_UNBOND":
+    case "POLKADOT_LIKE_WITHDRAWUNBONDED":
+    case "POLKADOT_LIKE_SETPAYEE":
+    case "POLKADOT_LIKE_ANONYMOUSPROXY":
+    case "POLKADOT_LIKE_KILLANONYMOUS":
+    case "POLKADOT_LIKE_CHILL":
+      transactionDefaults = genPolkadotLikeTxData(transactionType);
+      break;
+    case "RIPPLE_LIKE_SEND":
+      transactionDefaults = genRippleLikeSendData(transactionType);
+      break;
+    case "SOLANA_LIKE_SEND":
+    case "SOLANA_LIKE_CREATE_DELEGATE_STAKE":
+    case "SOLANA_LIKE_DELEGATE_STAKE":
+    case "SOLANA_LIKE_WITHDRAW_STAKE":
+    case "SOLANA_LIKE_DEACTIVATE_STAKE":
+    case "SOLANA_LIKE_SPLIT_STAKE":
+    case "SOLANA_LIKE_SPLIT_DEACTIVATE_STAKE":
+    case "SOLANA_LIKE_MERGE_STAKE":
+    case "SOLANA_LIKE_SEND_TOKEN":
+    case "SOLANA_LIKE_FUND_AND_SEND_TOKEN":
+    case "SOLANA_LIKE_CREATE_SPL_TOKEN_ACCOUNT":
+      transactionDefaults = genSolanaLikeTxData(transactionType);
+      break;
+    case "STELLAR_LIKE_SEND":
+      transactionDefaults = genStellarLikeSendData(transactionType);
+      break;
+    case "TEZOS_LIKE_SEND":
+    case "TEZOS_LIKE_DELEGATE":
+    case "TEZOS_LIKE_UNDELEGATE":
+      transactionDefaults = genTezosLikeTxData(transactionType);
+      break;
+    case "SUI_LIKE_SEND":
+    case "SUI_LIKE_SEND_TOKEN":
+    case "SUI_LIKE_STAKE":
+    case "SUI_LIKE_UNSTAKE":
+      transactionDefaults = genSuiLikeTxData(transactionType);
+      break;
+    case "TRON_LIKE_SEND":
+    case "TRON_LIKE_SEND_TOKEN":
+      transactionDefaults = genTronLikeTxData(transactionType);
+      break;
+  }
+  return {
+    accountId: accountId ?? faker.string.uuid(),
+    transaction: mergeTransactionData(transactionDefaults, transaction)
+  };
+};
 var shouldHaveTargetHsmId = (request) => {
   switch (request.type) {
     case RequestType.CREATE_ENTITY:
@@ -1694,43 +2197,43 @@ var shouldHaveTargetHsmId = (request) => {
       return true;
   }
 };
-var shouldHaveTargetId = (request) => {
-  switch (request.type) {
+var shouldHaveTargetId = (type) => {
+  switch (type) {
     case RequestType.CREATE_API_KEY:
     case RequestType.EDIT_API_KEY:
     case RequestType.REVOKE_API_KEY:
       return false;
     case RequestType.CREATE_TRANSACTION:
+    // TODO: move to True when we resolved the MetaTransaction id being an int
     case RequestType.SIGN_DIGESTS:
       return false;
     case RequestType.UPDATE_QUORUM:
     case RequestType.CREATE_PSD_USER:
     case RequestType.CREATE_API_USER:
+    case RequestType.CREATE_SCICONFIG:
     case RequestType.CREATE_ACCOUNT:
-    case RequestType.CREATE_GROUP:
-    case RequestType.CREATE_WHITELIST:
+    case RequestType.CREATE_API_USER_ACCESS:
     case RequestType.CREATE_ENTITY:
-    case RequestType.CREATE_SCICONFIG:
+    case RequestType.CREATE_GROUP:
     case RequestType.CREATE_POLICY:
-    case RequestType.SIGN_MESSAGE:
-    case RequestType.TRADELINK_CREATE_CUSTODIAN:
-    case RequestType.TRADELINK_CREATE_EXCHANGE:
-    case RequestType.TRADELINK_CREATE_ASSET_MANAGER:
-      return request.state === RequestState.EXECUTED;
+    case RequestType.CREATE_WHITELIST:
     case RequestType.EDIT_WORKSPACE_RULE:
     case RequestType.EDIT_ACCOUNT:
-    case RequestType.TRADELINK_ACTIVATE_ACCOUNT:
     case RequestType.EDIT_TOKEN_RULE:
     // EDIT_TOKEN_RULE targetId is the parent account which must always exist, even when creating new token rule.
     case RequestType.EDIT_GROUP:
-    case RequestType.REVOKE_GROUP:
-    case RequestType.EDIT_WHITELIST:
     case RequestType.EDIT_ENTITY:
-    case RequestType.REVOKE_ENTITY:
-    case RequestType.CREATE_API_USER_ACCESS:
-    case RequestType.REVOKE_USER:
     case RequestType.EDIT_SCICONFIG:
     case RequestType.EDIT_POLICY:
+    case RequestType.EDIT_WHITELIST:
+    case RequestType.REVOKE_ENTITY:
+    case RequestType.REVOKE_GROUP:
+    case RequestType.REVOKE_USER:
+    case RequestType.SIGN_MESSAGE:
+    case RequestType.TRADELINK_ACTIVATE_ACCOUNT:
+    case RequestType.TRADELINK_CREATE_ASSET_MANAGER:
+    case RequestType.TRADELINK_CREATE_CUSTODIAN:
+    case RequestType.TRADELINK_CREATE_EXCHANGE:
     case RequestType.TRADELINK_EDIT_CUSTODIAN:
     case RequestType.TRADELINK_EDIT_EXCHANGE:
     case RequestType.TRADELINK_EDIT_ASSET_MANAGER:
@@ -1743,13 +2246,373 @@ var shouldHaveTargetId = (request) => {
       return true;
   }
 };
+var genCreateAccountData = (opts) => {
+  return {
+    name: fakeUniqueName(),
+    type: "BITCOIN_LIKE",
+    currency: "bitcoin",
+    contractAddress: null,
+    tokenIdentifier: null,
+    governance: {
+      type: "CLASSIC",
+      policy: { rules: [] }
+      // TODO: account gov rules should not be empty
+    },
+    index: 0,
+    derivationPath: "m/84'/0'/0'",
+    ...opts
+  };
+};
+var genEditAccountData = (opts) => {
+  return {
+    name: fakeUniqueName(),
+    governance: {
+      type: "CLASSIC",
+      policy: { rules: [] }
+      // TODO: account gov rules should not be empty
+    },
+    ...opts
+  };
+};
+var genEditTokenRuleData = (opts) => {
+  return {
+    parentAccountId: faker.string.uuid(),
+    contractAddress: faker.string.alphanumeric({ length: 44 }),
+    rules: [
+      {
+        operationType: "SEND",
+        reviewSteps: [
+          {
+            quorum: 1,
+            userIds: []
+          }
+        ]
+      }
+    ],
+    ...opts
+  };
+};
+var genCreateApiKeyData = (opts) => {
+  return {
+    name: faker.company.name().slice(0, 19),
+    entities: [],
+    scopes: {},
+    // FIXME what should we put there?
+    ...opts
+  };
+};
+var genEditApiKeyData = (opts) => {
+  return {
+    name: faker.company.name().slice(0, 19),
+    entities: [],
+    scopes: {},
+    // FIXME what should we put there?
+    ...opts
+  };
+};
+var genSignDigestsData = (opts) => {
+  const { accountId, digests } = opts ?? {};
+  return {
+    accountId: accountId ?? faker.string.uuid(),
+    digests: digests ?? [
+      {
+        digest: faker.string.hexadecimal({ prefix: "", length: 64 }),
+        derivationPath: "m/44'/60'/0'"
+      }
+    ]
+  };
+};
+var genCreateEntityData = (opts) => {
+  return {
+    name: faker.word.noun({ length: { min: 5, max: 19 } }),
+    accountIds: [],
+    memberIds: [],
+    ...opts
+  };
+};
+var genEditEntityData = (opts) => {
+  return {
+    name: faker.word.noun({ length: { min: 5, max: 19 } }),
+    accountIds: [],
+    memberIds: [],
+    ...opts
+  };
+};
+var genCreateGroupData = (opts) => {
+  return {
+    name: faker.word.noun({ length: { min: 5, max: 19 } }),
+    description: faker.lorem.sentence(),
+    members: [],
+    ...opts
+  };
+};
+var genEditGroupData = (opts) => {
+  return {
+    name: faker.word.noun({ length: { min: 5, max: 19 } }),
+    description: faker.lorem.sentence(),
+    members: [],
+    ...opts
+  };
+};
+var genCreatePolicyData = (opts) => {
+  return {
+    name: faker.word.noun({ length: { min: 5, max: 19 } }),
+    description: faker.lorem.sentence(),
+    currency: "bitcoin",
+    govRules: [],
+    ...opts
+  };
+};
+var genEditPolicyData = (opts) => {
+  return {
+    name: faker.word.noun({ length: { min: 5, max: 19 } }),
+    description: faker.lorem.sentence(),
+    govRules: [],
+    ...opts
+  };
+};
+var genCreateSciConfigData = (opts) => {
+  return {
+    account: faker.string.uuid(),
+    config: {
+      dapps: times(faker.number.int({ min: 0, max: 5 }), () => faker.word.noun()),
+      customContractCallEnabled: faker.datatype.boolean()
+    },
+    ...opts
+  };
+};
+var genEditSciConfigData = (opts) => {
+  return {
+    config: {
+      dapps: times(faker.number.int({ min: 0, max: 5 }), () => faker.word.noun()),
+      customContractCallEnabled: faker.datatype.boolean()
+    },
+    ...opts
+  };
+};
+var genCreatePledgeIncrementData = (opts) => ({
+  accountId: faker.string.uuid(),
+  exchangeId: faker.string.uuid(),
+  amount: "42",
+  ...opts
+});
+var genRepledgeRequestData = (opts) => ({
+  accountId: faker.string.uuid(),
+  exchangeId: faker.string.uuid(),
+  amount: "42",
+  ...opts
+});
+var genCreateSettlementData = (opts) => ({
+  accountId: faker.string.uuid(),
+  exchangeId: faker.string.uuid(),
+  transaction: {
+    type: "BITCOIN_LIKE_SEND",
+    amount: "42",
+    currency: "bitcoin",
+    maxFee: "999",
+    recipient: faker.finance.bitcoinAddress(),
+    feeStrategy: { type: "NORMAL" }
+  },
+  ...opts
+});
+var genForceUnpledgeData = (opts) => ({
+  accountId: faker.string.uuid(),
+  exchangeId: faker.string.uuid(),
+  ...opts
+});
+var genTradelinkWithdrawData = (opts) => ({
+  accountId: faker.string.uuid(),
+  transaction: {
+    type: "ETHEREUM_LIKE_SEND",
+    recipient: "0x63e4195AF1509490b430F3f5bCb85A82a24F5C82",
+    amount: faker.number.bigInt({ min: 0, max: 99 }).toString(),
+    maxFee: faker.number.bigInt({ min: 1 }).toString(),
+    currency: "ethereum",
+    feeStrategy: {
+      type: "NORMAL",
+      gasPrice: "2",
+      gasLimit: "10"
+    }
+  },
+  ...opts
+});
+var genTradelinkArbitrationData = (opts) => ({
+  accountId: faker.string.uuid(),
+  transaction: {
+    type: "ETHEREUM_LIKE_SEND",
+    recipient: "0xcefd70CFCd7a2FAa0fe956E3d496F9313297CB44",
+    amount: faker.number.bigInt({ min: 0, max: 99 }).toString(),
+    maxFee: faker.number.bigInt({ min: 1 }).toString(),
+    currency: "ethereum",
+    feeStrategy: {
+      type: "NORMAL",
+      gasPrice: "2",
+      gasLimit: "10"
+    }
+  },
+  ...opts
+});
+var genCreatePsdUserData = (opts) => ({
+  registrationId: faker.string.uuid(),
+  ...opts
+});
+var genCreateApiUserData = (opts) => {
+  return {
+    name: faker.person.firstName(),
+    pubKey: fakePubKey(),
+    role: UserRole.OPERATOR,
+    viewAll: false,
+    ...opts
+  };
+};
+var genCreateApiUserAccessData = (opts) => {
+  return {
+    name: faker.person.firstName(),
+    ...opts
+  };
+};
+var genCreateWhitelistData = (opts) => {
+  return {
+    name: faker.word.noun({ length: { min: 5, max: 19 } }),
+    description: faker.lorem.sentence(),
+    type: faker.helpers.arrayElement(Object.values(WhitelistType)),
+    addresses: [
+      {
+        name: faker.lorem.words(3),
+        currency: "bitcoin",
+        address: faker.finance.bitcoinAddress(),
+        destinationTags: []
+      },
+      {
+        name: faker.lorem.words(3),
+        currency: "ethereum",
+        address: faker.finance.ethereumAddress(),
+        destinationTags: []
+      }
+    ],
+    ...opts
+  };
+};
+var genEditWhitelistData = (opts) => {
+  return {
+    name: faker.word.noun({ length: { min: 5, max: 19 } }),
+    addresses: [
+      {
+        name: faker.lorem.words(3),
+        currency: "bitcoin",
+        address: faker.finance.bitcoinAddress(),
+        destinationTags: []
+      },
+      {
+        name: faker.lorem.words(3),
+        currency: "ethereum",
+        address: faker.finance.ethereumAddress(),
+        destinationTags: []
+      }
+    ],
+    ...opts
+  };
+};
+var genWorkspaceRuleData = (opts) => {
+  return {
+    permission: AdminPermission.CREATE_ACCOUNT_WITH_POLICY,
+    reviewConfig: [{ userIds: [], quorum: 2 }],
+    ...opts
+  };
+};
 
 // src/__fakes__/models/requests/requests-and-reviews.ts
+var genRequestData = (type, opts) => {
+  switch (type) {
+    // Workspace...
+    case RequestType.UPDATE_QUORUM:
+      return { quorum: 3, ...opts };
+    // User...
+    case RequestType.CREATE_PSD_USER:
+      return genCreatePsdUserData(opts);
+    case RequestType.CREATE_API_USER:
+      return genCreateApiUserData(opts);
+    case RequestType.CREATE_API_USER_ACCESS:
+      return genCreateApiUserAccessData(opts);
+    case RequestType.REVOKE_USER:
+      return {};
+    // Admin gov rule...
+    case RequestType.EDIT_WORKSPACE_RULE:
+      return genWorkspaceRuleData(opts);
+    // Group...
+    case RequestType.CREATE_GROUP:
+      return genCreateGroupData(opts);
+    case RequestType.EDIT_GROUP:
+      return genEditGroupData(opts);
+    case RequestType.REVOKE_GROUP:
+      return {};
+    // ApiKey...
+    case RequestType.CREATE_API_KEY:
+      return genCreateApiKeyData(opts);
+    case RequestType.EDIT_API_KEY:
+      return genEditApiKeyData(opts);
+    case RequestType.REVOKE_API_KEY:
+      return {};
+    // Whitelist...
+    case RequestType.CREATE_WHITELIST:
+      return genCreateWhitelistData(opts);
+    case RequestType.EDIT_WHITELIST:
+      return genEditWhitelistData(opts);
+    // Entity...
+    case RequestType.CREATE_ENTITY:
+      return genCreateEntityData(opts);
+    case RequestType.EDIT_ENTITY:
+      return genEditEntityData(opts);
+    case RequestType.REVOKE_ENTITY:
+      return {};
+    // Account...
+    case RequestType.CREATE_ACCOUNT:
+      return genCreateAccountData(opts);
+    case RequestType.EDIT_ACCOUNT:
+      return genEditAccountData(opts);
+    case RequestType.EDIT_TOKEN_RULE:
+      return genEditTokenRuleData(opts);
+    // Operator requests...
+    case RequestType.CREATE_TRANSACTION:
+      return genCreateTransactionData(opts);
+    case RequestType.SIGN_MESSAGE:
+      return genSignMessageData(opts);
+    case RequestType.SIGN_DIGESTS:
+      return genSignDigestsData(opts);
+    // SCI config...
+    case RequestType.CREATE_SCICONFIG:
+      return genCreateSciConfigData(opts);
+    case RequestType.EDIT_SCICONFIG:
+      return genEditSciConfigData(opts);
+    // Policy
+    case RequestType.CREATE_POLICY:
+      return genCreatePolicyData(opts);
+    case RequestType.EDIT_POLICY:
+      return genEditPolicyData(opts);
+    // Tradelink...
+    case RequestType.TRADELINK_ADJUST_PLEDGE:
+      return genCreatePledgeIncrementData(opts);
+    case RequestType.TRADELINK_CREATE_SETTLEMENT:
+      return genCreateSettlementData(opts);
+    case RequestType.TRADELINK_FORCE_UNPLEDGE:
+      return genForceUnpledgeData(opts);
+    case RequestType.TRADELINK_WITHDRAW:
+      return genTradelinkWithdrawData(opts);
+    case RequestType.TRADELINK_REPLEDGE:
+      return genRepledgeRequestData(opts);
+    case RequestType.TRADELINK_ARBITRATE:
+      return genTradelinkArbitrationData(opts);
+    default: {
+      const unknownType = type;
+      throw new Error(`Unknown request type: ${unknownType}`);
+    }
+  }
+};
 var genRequestReviewSteps = (numSteps) => times(1, () => ({ stageName: "default", quorum: 2 }));
 var genVaultRequest = (opts) => {
   const { type, state = RequestState.PENDING_APPROVAL, data, ...custom } = opts;
   const targetHsmId = shouldHaveTargetHsmId({ type, state }) ? type === RequestType.CREATE_PSD_USER ? fakePubKey() : fakeHsmObjectId() : null;
-  const targetId = shouldHaveTargetId({ type, state }) ? faker.string.uuid() : null;
+  const targetId = shouldHaveTargetId(type) ? faker.string.uuid() : null;
   return injectSyncId({
     id: faker.string.uuid(),
     workspaceName: fakeWorkspaceName(),
@@ -1813,6 +2676,98 @@ var genVaultRequestReview = (opts) => {
     ...opts
   };
 };
+var genUserFieldsForDeviceType = (deviceType) => {
+  switch (deviceType) {
+    case UserDeviceType.PSD:
+    case UserDeviceType.SOFT_PSD:
+      return {
+        deviceType,
+        deviceUserId: fakeDeviceUserId(),
+        hsmId: null
+      };
+    case UserDeviceType.API:
+      return {
+        deviceType,
+        deviceUserId: null,
+        hsmId: faker.string.uuid()
+      };
+  }
+};
+var genUser = (opts) => {
+  const role = opts?.role ?? faker.helpers.arrayElement([UserRole.ADMIN, UserRole.OPERATOR]);
+  const deviceType = opts?.deviceType ?? UserDeviceType.PSD;
+  const userFieldsForDeviceType = genUserFieldsForDeviceType(deviceType);
+  const gateType = role === UserRole.READ_ONLY_API_KEY ? GateUserType.VaultApiKey : GateUserType.Person;
+  return injectSyncId({
+    id: faker.string.uuid(),
+    name: faker.person.fullName(),
+    ...userFieldsForDeviceType,
+    authUserId: genAuthUserId(),
+    pubKey: fakePubKey(),
+    workspaceName: fakeWorkspaceName(),
+    u2fKeyHandle: fakePubKey(),
+    u2fPubKey: fakePubKey(),
+    legacyViewAll: false,
+    role,
+    status: ActivationStatus.ACTIVE,
+    isSuspended: false,
+    gateType,
+    gateId: fakeGateId(),
+    createdAt: faker.date.past(),
+    updatedAt: faker.date.past(),
+    ...opts
+  });
+};
+var genGroup = (opts) => injectSyncId({
+  id: faker.string.uuid(),
+  workspaceName: fakeWorkspaceName(),
+  name: faker.person.fullName(),
+  description: faker.lorem.sentence(10),
+  hsmId: fakeHsmObjectId(),
+  status: ActivationStatus.ACTIVE,
+  gateId: fakeGateId(),
+  gateType: "Group",
+  createdAt: faker.date.past(),
+  updatedAt: faker.date.past(),
+  ...opts
+});
+var genGroupWithMembers = (opts) => {
+  const group = genGroup(opts);
+  return {
+    ...group,
+    members: opts?.members ?? []
+  };
+};
+var genWhitelist = (opts) => {
+  return injectSyncId({
+    id: faker.string.uuid(),
+    workspaceName: fakeWorkspaceName(),
+    name: faker.lorem.words(3),
+    description: faker.lorem.sentence(10),
+    addresses: [
+      {
+        name: faker.lorem.words(3),
+        currency: "bitcoin",
+        address: faker.finance.bitcoinAddress(),
+        destinationTags: []
+      },
+      {
+        name: faker.lorem.words(3),
+        currency: "ethereum",
+        address: faker.finance.ethereumAddress(),
+        destinationTags: []
+      }
+    ],
+    hsmId: fakeHsmObjectId(),
+    type: faker.helpers.arrayElement(Object.values(WhitelistType)),
+    status: faker.helpers.arrayElement(Object.values(ActivationStatus)),
+    gateId: fakeGateId(),
+    gateType: "Whitelist",
+    createdAt: faker.date.past(),
+    updatedAt: faker.date.past(),
+    ...opts
+  });
+};
 var zPubKey = zHexString.meta({ description: "Public key" });
 var zHsmCertificate = z.object({
   codeHash: z.base64().meta({ description: "Hash of the executable that generated this certificate" }),
@@ -1929,8 +2884,7 @@ var zUserRegistrationCreateInput = z.object({
 zUserRegistrationCreateInput.extend({
   id: z.string().meta({ description: "User registration ID" }),
   workspaceName: z.string().meta({ description: "Workspace name" }),
-  state: z.enum(UserRegistrationState).meta({ description: "User registration state" }),
-  isLocked: z.boolean().meta({ description: "Whether the registration is locked by a request" })
+  state: z.enum(UserRegistrationState).meta({ description: "User registration state" })
 });
 
 // src/users/request-data.ts
@@ -1939,7 +2893,7 @@ var zCreatePsdUserRequestData = z14.object({
 });
 var zCreateApiUserRequestData = z14.object({
   name: zUserName,
-  pubKey: z14.string().meta({ description: "Public key" }),
+  pubKey: z14.string().regex(/^04[0-9a-fA-F]{128}$/).meta({ description: "Public key, uncompressed secp256r1 format" }),
   role: z14.enum(["ADMIN", "OPERATOR"]).meta({ description: "User role" }),
   viewAll: z14.boolean().meta({ description: "View all data" }).optional()
 }).meta({ description: "Create API user request data" });
@@ -2353,10 +3307,7 @@ z14.enum([
 var zRawSigningLiveData = zCommonLiveData.extend({
   type: z14.literal(AccountType.RAW_SIGNING).meta({ description: "Account type" })
 }).meta({ description: "Raw signing account" });
-z14.discriminatedUnion("type", [
-  zRawSigningLiveData,
-  ...zAccountLiveData.options
-]);
+z14.discriminatedUnion("type", [zRawSigningLiveData, ...zAccountLiveData.options]).meta({ description: "Account live data", id: "AccountLiveDataResponse" });
 z14.object({
   address: z14.string().meta({ description: "Address" }),
   derivationPath: z14.string().nullable().meta({ description: "Derivation path" })
@@ -2655,7 +3606,8 @@ var getAccountAssetFields = (account) => {
     case AccountType.HEDERA_LIKE:
       return {
         type: account.type,
-        address: account.address
+        address: account.address,
+        isActivated: account.lesWalletId !== null
       };
     /* v8 ignore next -- @preserve */
     default:
@@ -2695,6 +3647,63 @@ var serializeAccount = (account) => {
   };
   return zAccountResponse.parse(response);
 };
+var zUserResponse = z14.object({
+  id: z14.string().meta({ description: "Internal unique identifier" }),
+  legacyId: z14.number().meta({ description: "Legacy internal unique identifier (for retro-compatibility)" }),
+  legacyViewAll: z14.boolean().meta({ description: "If true, user can read all resources on the workspace" }),
+  workspaceName: z14.string().meta({ description: "User's workspace name" }),
+  name: z14.string().meta({ description: "User name" }),
+  deviceUserId: z14.string().nullable().meta({ description: "User's device ID (for non-API users)" }),
+  deviceType: z14.enum(UserDeviceType).meta({ description: "User's device type" }),
+  role: z14.enum(UserRole).meta({ description: "User role" }),
+  pubKey: z14.string().meta({ description: "User public key" }),
+  status: z14.enum(ActivationStatus).meta({ description: "User status" }),
+  isSuspended: z14.boolean().meta({ description: "Whether the user is suspended" }),
+  createdAt: z14.coerce.date().meta({ description: "Creation timestamp" }),
+  updatedAt: z14.coerce.date().meta({ description: "Last modification timestamp" })
+});
+zUserResponse.extend({
+  role: z14.literal(UserRole.ADMIN).meta({ description: "Should always be ADMIN" })
+});
+z14.enum([
+  "name",
+  "role",
+  "status",
+  "createdAt",
+  "updatedAt"
+]).default("createdAt");
+
+// src/users/app-utils.ts
+function serializeUser(user) {
+  const serialized = {
+    ...user,
+    legacyId: user.gateId
+  };
+  return zUserResponse.parse(serialized);
+}
+
+// src/groups/app-types.ts
+var zGroupResponse = z14.object({
+  id: z14.string().meta({ description: "Internal unique identifier" }),
+  legacyId: z14.number().meta({ description: "Legacy internal unique identifier (for retro-compatibility)" }),
+  name: z14.string().meta({ description: "Group name" }),
+  description: z14.string().nullable().meta({ description: "Group description" }),
+  status: z14.enum(ActivationStatus).meta({ description: "Group status" }),
+  members: z14.array(zUserResponse).meta({ description: "Group members" }),
+  createdAt: z14.coerce.date().meta({ description: "Creation timestamp" }),
+  updatedAt: z14.coerce.date().meta({ description: "Last modification timestamp" })
+});
+z14.enum(["name", "status", "createdAt", "updatedAt"]).default("createdAt");
+
+// src/groups/app-utils.ts
+function serializeGroup(group) {
+  const serialized = {
+    ...group,
+    legacyId: group.gateId,
+    members: group.members.map(serializeUser)
+  };
+  return zGroupResponse.parse(serialized);
+}
 
 // src/compat/patch-request-expired-at.ts
 var patchRequestExpiredAt = (data) => ({
@@ -3062,6 +4071,31 @@ function serializeVaultRequest(request) {
   patched = patchTezosRequestData(patched);
   return patched;
 }
+var zWhitelistAddressResponse = z14.object({
+  name: z14.string().min(1).max(50).meta({ description: "Address name" }),
+  currency: zCurrencyString.meta({ description: "Address currency" }),
+  address: z14.string().min(1).max(200).meta({ description: "Address value" }),
+  destinationTags: z14.array(z14.string().min(1).regex(/^\w+$/)).optional().meta({ description: "List of destination tags (applicable for Ripple currency)" })
+});
+var zWhitelistResponse = z14.object({
+  id: z14.string().meta({ description: "Internal unique identifier" }),
+  legacyId: z14.number().meta({ description: "Legacy internal unique identifier (for retro-compatibility)" }),
+  name: z14.string().meta({ description: "Whitelist name" }),
+  status: z14.enum(ActivationStatus).meta({ description: "Whitelist status" }),
+  addresses: z14.array(zWhitelistAddressResponse),
+  createdAt: z14.coerce.date().meta({ description: "Creation timestamp" }),
+  updatedAt: z14.coerce.date().meta({ description: "Last modification timestamp" }),
+  description: z14.string().nullable().meta({ description: "Whitelist description" })
+}).meta({ description: "Whitelist", id: "WhitelistResponse" });
+z14.enum(["name", "status", "createdAt", "updatedAt"]).default("createdAt");
+var serializeWhitelist = (whitelist) => {
+  const serialized = {
+    ...whitelist,
+    legacyId: whitelist.gateId,
+    addresses: z.array(zWhitelistAddressResponse).parse(whitelist.addresses)
+  };
+  return zWhitelistResponse.parse(serialized);
+};
 
 // src/__fakes__/responses.ts
 function genVaultRequestResponse(opts, reviews = []) {
@@ -3074,8 +4108,23 @@ function genAccountResponse(overrides) {
   const account = serializeAccount(dbAccount);
   return zAccountResponse.parse(account);
 }
+function genUserResponse(overrides) {
+  const dbUser = genUser(overrides);
+  const user = serializeUser(dbUser);
+  return zUserResponse.parse(user);
+}
+function genGroupResponse(overrides) {
+  const dbGroup = genGroupWithMembers(overrides);
+  const group = serializeGroup(dbGroup);
+  return zGroupResponse.parse(group);
+}
+function genWhitelistResponse(overrides) {
+  const dbWhitelist = genWhitelist(overrides);
+  const whitelist = serializeWhitelist(dbWhitelist);
+  return zWhitelistResponse.parse(whitelist);
+}
 /* v8 ignore next -- @preserve */
 
-export { genAccountResponse, genVaultRequestResponse, genVaultRequestReview };
+export { genAccountResponse, genCreateTransactionData, genGroupResponse, genRequestData, genUserResponse, genVaultRequestResponse, genVaultRequestReview, genWhitelistResponse };
 //# sourceMappingURL=fakes.mjs.map
 //# sourceMappingURL=fakes.mjs.map