@ledgerhq/revault-api 1.20.0

package/lib/fakes.mjs

@@ -0,0 +1,2097 @@
+import { faker } from '@faker-js/faker';
+import z5, { z } from 'zod';
+import { ChallengeType, PsdModel, AccountType, AccountGovernanceType, ActivationStatus, WhitelistType, PolicyType, UserDeviceType, AdminPermission, RequestType, RequestReviewStatus, RequestState, GateAccountType } from '@prisma/client';
+import 'axios';
+import invariant from 'invariant';
+import { omit, times } from 'lodash';
+
+// src/__fakes__/responses.ts
+
+// src/errors.ts
+var ValidationError = class extends Error {
+};
+
+// src/sync-utils.ts
+var GATE_SYNC_ID_PREFIX = "gate://";
+var buildGateSyncId = (workspaceName, gateType, gateId) => {
+  if (gateId <= 0) {
+    throw new ValidationError(`Invalid gate ID: ${gateId}`);
+  }
+  return `${GATE_SYNC_ID_PREFIX}${workspaceName}/${gateType}/${gateId}`;
+};
+
+// src/utils.ts
+var ensureNonEmptyArray = (values, message) => {
+  invariant(
+    values.length > 0,
+    `Expected non-empty array but got one with length ${values.length}`
+  );
+  return values;
+};
+function unreachable(value) {
+  throw new Error(`Un-covered: ${value}`);
+}
+var zHsmObjectId = z.string().regex(/^[\w-]+$/).min(1);
+var zHexString = z.string().regex(/^[0-9a-fA-F]+$/);
+var zPubKey = zHexString.describe("Public key");
+var zHsmCertificate = z.object({
+  codeHash: z.string().base64().describe("Hash of the executable that generated this certificate"),
+  attestationPub: z.string().base64().describe("Attestation public key"),
+  certificate: z.string().base64().describe("Certificate bytes"),
+  signature: z.string().base64().describe("Certificate signature")
+});
+var zBlob = z.string();
+var zPsdChallenge = z.object({
+  challengeType: z.literal(ChallengeType.PSD),
+  wActions: z.array(z.string()).describe("Wrapped blobs that describe the screens to display"),
+  handshake: z.string().describe("Handshake for the HSM <-> PSD communication"),
+  handshakeAttestation: zHsmCertificate.describe(
+    "Handshake attestation to verify secure channel between HSM & PSD"
+  ),
+  partitionId: z.string().describe("HSM partition id (maybe not useful)")
+});
+var zApiChallenge = z.object({
+  challengeType: z.literal(ChallengeType.API),
+  payload: z.object({
+    approve: z.string().describe("JSON payload to sign (as JWS) to approve"),
+    reject: z.string().describe("JSON payload to sign (as JWS) to reject")
+  }).describe("JSON payload to approve and to reject")
+});
+var zUserChallenge = z.discriminatedUnion("challengeType", [
+  zPsdChallenge.describe("Necessary data to approve on a PSD"),
+  zApiChallenge.describe("Necessary data for approval by an API user")
+]);
+var zHsmChallengeGroup = z.record(zPubKey, zUserChallenge);
+var zHsmChallengeSteps = z.array(zHsmChallengeGroup);
+var zPsdSignature = z.string().min(1).describe("Signature from PSD");
+var zApiSignature = z.string().min(1).describe("Signature from API (JWS)");
+var zUserApproval = z.discriminatedUnion("challengeType", [
+  z.object({
+    challengeType: z.literal(ChallengeType.PSD),
+    signature: zPsdSignature
+  }),
+  z.object({
+    challengeType: z.literal(ChallengeType.API),
+    signature: zApiSignature
+  })
+]);
+var zHsmApprovalGroup = z.record(zPubKey, zUserApproval);
+z.array(zHsmApprovalGroup);
+z.object({
+  stageName: z.string(),
+  steps: zHsmChallengeSteps
+});
+var zUserRegistrationDeviceData = z.object({
+  name: z.string().describe("Name of the user to register"),
+  psdModel: z.nativeEnum(PsdModel).describe("Device model"),
+  pubKey: zPubKey.describe("Device public key"),
+  confidentialityKey: zPubKey.describe("TODO describe"),
+  psdEphemeralKey: zPubKey.describe("TODO describe"),
+  psdEphemeralKeyAttestation: zHsmCertificate.describe("TODO describe")
+}).describe("TODO describe");
+var zUserRegistrationChallenge = z.object({
+  challenge: z.string().describe("TODO describe"),
+  ephemeralPublicKey: zPubKey.describe("TODO describe"),
+  ephemeralPublicKeyAttestation: zHsmCertificate.describe("TODO describe"),
+  handshake: zHexString.describe("TODO describe"),
+  handshakeAttestation: zHsmCertificate.describe("TODO describe"),
+  u2fRegisterData: z.string().describe("TODO describe"),
+  ciphertext: z.string().describe("TODO describe"),
+  requestId: z.string().describe("TODO describe")
+}).describe("TODO describe");
+z.object({
+  certificate: zHsmCertificate.describe("TODO describe"),
+  u2fRegister: zHexString.describe("TODO describe"),
+  u2fKeyHandle: zHexString.describe("TODO describe"),
+  registerData: z.string().describe("TODO describe"),
+  validationKey: zPubKey.describe("TODO describe"),
+  pairingPayload: z.string().describe("TODO describe")
+}).describe("TODO describe");
+z.object({
+  confidentialityKeyCurve25519: z.string(),
+  confidentialityKeySignature: z.string()
+});
+z.object({
+  pairing: z.object({
+    workspaceName: z.string(),
+    partitionKey: z.string(),
+    // TODO: Is this `zPubKey`?
+    bootstrapEnabled: z.boolean()
+  }),
+  // TODO: Is this `zHsmCertificate`?
+  partitionKeyAttestation: z.object({
+    codeHash: z.string(),
+    attestationPub: z.string(),
+    certificate: z.string(),
+    signature: z.string()
+  }),
+  blob: zBlob
+});
+var zBigInt = z.string().regex(/^0|[1-9]\d*$/);
+var zIntString = z.string().min(1).regex(/^-?\d+$/);
+var zBitcoinLikeTransactionType = z5.enum(["BITCOIN_LIKE_SEND", "BITCOIN_LIKE_RECEIVE"]).describe("Bitcoin-like transaction type");
+var zCardanoLikeTransactionType = z5.enum([
+  "CARDANO_LIKE_SEND",
+  "CARDANO_LIKE_RECEIVE",
+  "CARDANO_LIKE_STAKING_REGISTER",
+  "CARDANO_LIKE_STAKING_DEREGISTER",
+  "CARDANO_LIKE_STAKING_DELEGATE",
+  "CARDANO_LIKE_STAKING_WITHDRAW"
+]).describe("Cardano-like transaction type");
+var zEthereumLikeTransferTransactionType = z5.enum(["ETHEREUM_LIKE_SEND", "ETHEREUM_LIKE_RECEIVE"]).describe("Ethereum-like transaction type");
+var zEthereumLikeContractTransactionType = z5.enum(["ETHEREUM_LIKE_EXECUTE_CONTRACT", "ETHEREUM_LIKE_DEPLOY_CONTRACT"]).describe("Ethereum-like transaction type");
+var zPolkadotLikeTransactionType = z5.enum([
+  "POLKADOT_LIKE_SEND",
+  "POLKADOT_LIKE_RECEIVE",
+  "POLKADOT_LIKE_ADDPROXY",
+  "POLKADOT_LIKE_REMOVEPROXY",
+  "POLKADOT_LIKE_BOND",
+  "POLKADOT_LIKE_REBOND",
+  "POLKADOT_LIKE_BONDEXTRA",
+  "POLKADOT_LIKE_UNBOND",
+  "POLKADOT_LIKE_WITHDRAWUNBONDED",
+  "POLKADOT_LIKE_SETCONTROLLER",
+  "POLKADOT_LIKE_SETPAYEE",
+  "POLKADOT_LIKE_PROXY",
+  "POLKADOT_LIKE_ANONYMOUSPROXY",
+  "POLKADOT_LIKE_KILLANONYMOUS",
+  "POLKADOT_LIKE_PUREPROXY",
+  "POLKADOT_LIKE_KILLPURE",
+  "POLKADOT_LIKE_NOMINATE",
+  "POLKADOT_LIKE_REWARD",
+  "POLKADOT_LIKE_CHILL",
+  "POLKADOT_LIKE_TRANSFERALL"
+]).describe("Polkadot-like transaction type");
+var zRippleLikeTransactionType = z5.enum(["RIPPLE_LIKE_SEND", "RIPPLE_LIKE_RECEIVE"]).describe("Ripple-like transaction type");
+var zSolanaLikeTransactionType = z5.enum([
+  "SOLANA_LIKE_SEND",
+  "SOLANA_LIKE_RECEIVE",
+  "SOLANA_LIKE_CREATE_DELEGATE_STAKE",
+  "SOLANA_LIKE_DELEGATE_STAKE",
+  "SOLANA_LIKE_WITHDRAW_STAKE",
+  "SOLANA_LIKE_DEACTIVATE_STAKE",
+  "SOLANA_LIKE_SPLIT_STAKE",
+  "SOLANA_LIKE_SPLIT_DEACTIVATE_STAKE",
+  "SOLANA_LIKE_MERGE_STAKE",
+  "SOLANA_LIKE_SEND_TOKEN",
+  "SOLANA_LIKE_FUND_TOKEN"
+]).describe("Solana-like transaction type");
+var zStellarLikeTransactionType = z5.enum(["STELLAR_LIKE_SEND", "STELLAR_LIKE_RECEIVE"]).describe("Stellar-like transaction type");
+var zTezosLikeTransactionType = z5.enum([
+  "TEZOS_LIKE_SEND",
+  "TEZOS_LIKE_RECEIVE",
+  "TEZOS_LIKE_REVEAL",
+  "TEZOS_LIKE_DELEGATE",
+  "TEZOS_LIKE_UNDELEGATE"
+]).describe("Tezos-like transaction type");
+var zGenericTransactionType = z5.enum(["GENERIC_TRANSACTION"]).describe("Generic transaction type");
+z5.union([
+  zBitcoinLikeTransactionType,
+  zCardanoLikeTransactionType,
+  zEthereumLikeTransferTransactionType,
+  zEthereumLikeContractTransactionType,
+  zGenericTransactionType,
+  zPolkadotLikeTransactionType,
+  zRippleLikeTransactionType,
+  zSolanaLikeTransactionType,
+  zStellarLikeTransactionType,
+  zTezosLikeTransactionType
+]);
+
+// src/transactions/request-data.ts
+var zHexDataString = z5.string().regex(/^(?:0x|0X)?[a-fA-F0-9]+$/).transform((hex) => `0x${hex.toLowerCase().replace("0x", "")}`);
+if ("openapi" in zHexDataString) {
+  zHexDataString = zHexDataString.openapi?.({ effectType: "same" });
+}
+var zCommonTransactionData = z5.object({
+  amount: zBigInt.describe("Transaction amount"),
+  currency: z5.string().describe("Transaction currency"),
+  // TODO: strict literal or enum?
+  maxFee: zBigInt.nullable().describe("Transaction max fee"),
+  recipient: z5.string().describe("Transaction recipient")
+});
+var zFeeStrategyCustom = z5.object({
+  type: z5.enum(["SLOW", "NORMAL", "FAST", "CUSTOM"])
+});
+var zFeeStrategy = z5.object({
+  type: z5.enum(["SLOW", "NORMAL", "FAST"])
+});
+var zBitcoinLikeFeeStrategy = zFeeStrategyCustom.extend({
+  // nullish is optional + nullable, it is easier to seed rather than just optional
+  feePerByte: zBigInt.nullish().describe("Fee per byte")
+}).describe("Bitcoin-like fee strategy");
+var zBitcoinLikeSendData = zCommonTransactionData.extend({
+  type: z5.literal(zBitcoinLikeTransactionType.enum.BITCOIN_LIKE_SEND),
+  feeStrategy: zBitcoinLikeFeeStrategy
+}).describe("Bitcoin-like send data");
+var zEthereumLikeLegacyFeeStrategy = zFeeStrategyCustom.extend({ gasPrice: zBigInt.describe("Gas price"), gasLimit: zBigInt.describe("Gas limit") }).describe("Ethereum-like legacy fee strategy");
+var zEthereumLikeEip1559FeeStrategy = zFeeStrategyCustom.extend({
+  maxPriorityFeePerGas: zBigInt.describe("Maximum priority fee per gas"),
+  maxFeePerGas: zBigInt.describe("Maximum fee per gas (base + priority)"),
+  gasLimit: zBigInt.describe("Gas limit")
+}).describe("Ethereum-like EIP-1559 fee strategy");
+var zEthereumLikeFeeStrategy = z5.union([zEthereumLikeLegacyFeeStrategy, zEthereumLikeEip1559FeeStrategy]).describe("Ethereum-like fee strategy");
+var zEthereumLikeDeployContractData = zCommonTransactionData.extend({
+  type: z5.literal(zEthereumLikeContractTransactionType.enum.ETHEREUM_LIKE_DEPLOY_CONTRACT),
+  // force the recipient to be the zero address
+  recipient: z5.literal("0x0000000000000000000000000000000000000000"),
+  contractData: zHexDataString.describe("Contract data in hexadecimal format"),
+  feeStrategy: zEthereumLikeFeeStrategy
+}).describe("Ethereum-like deploy contract data");
+var zEthereumLikeExecuteContractData = zCommonTransactionData.extend({
+  type: z5.literal(zEthereumLikeContractTransactionType.enum.ETHEREUM_LIKE_EXECUTE_CONTRACT),
+  contractData: zHexDataString.describe("Contract call data in hexadecimal format"),
+  feeStrategy: zEthereumLikeFeeStrategy
+}).describe("Ethereum-like execute contract data");
+var zEthereumLikeSendData = zCommonTransactionData.extend({
+  type: z5.literal(zEthereumLikeTransferTransactionType.enum.ETHEREUM_LIKE_SEND),
+  feeStrategy: zEthereumLikeFeeStrategy
+}).describe("Ethereum-like send data");
+var zTezosLikeFeeStrategy = zFeeStrategyCustom.extend({
+  gasLimit: zBigInt.describe("Gas limit"),
+  storageLimit: zBigInt.nullable().describe("Storage limit")
+}).describe("Tezos-like fee strategy");
+var zTezosLikeDelegateData = zCommonTransactionData.extend({
+  type: z5.literal(zTezosLikeTransactionType.enum.TEZOS_LIKE_DELEGATE),
+  feeStrategy: zTezosLikeFeeStrategy
+}).describe("Tezos-like delegate data");
+var zTezosLikeSendData = zCommonTransactionData.extend({
+  type: z5.literal(zTezosLikeTransactionType.enum.TEZOS_LIKE_SEND),
+  feeStrategy: zTezosLikeFeeStrategy
+}).describe("Tezos-like send data");
+var zTezosLikeUndelegateData = zCommonTransactionData.extend({
+  type: z5.literal(zTezosLikeTransactionType.enum.TEZOS_LIKE_UNDELEGATE),
+  feeStrategy: zTezosLikeFeeStrategy
+}).describe("Tezos-like undelegate data");
+var zPolkadotRewardDestination = z5.enum(["Staked", "Stash"]);
+var zPolkadotLikeAddProxyData = z5.object({
+  type: z5.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_ADDPROXY),
+  currency: z5.string().describe("Transaction currency"),
+  kind: z5.literal("Staking").describe("Proxy kind"),
+  proxy: z5.string().describe("Proxy address")
+}).describe("Polkadot-like add proxy data");
+var zPolkadotLikeAnonymousProxyData = z5.object({
+  type: z5.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_ANONYMOUSPROXY),
+  currency: z5.string().describe("Transaction currency")
+}).describe("Polkadot-like anonymous proxy data");
+var zPolkadotLikeBondData = z5.object({
+  type: z5.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_BOND),
+  currency: z5.string().describe("Transaction currency"),
+  payee: zPolkadotRewardDestination,
+  amount: zBigInt.describe("Amount")
+}).describe("Polkadot-like bond data");
+var zPolkadotLikeBondExtraData = z5.object({
+  type: z5.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_BONDEXTRA),
+  currency: z5.string().describe("Transaction currency"),
+  amount: zBigInt.describe("Amount")
+}).describe("Polkadot-like bond extra data");
+var zPolkadotLikeChillData = z5.object({
+  type: z5.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_CHILL),
+  currency: z5.string().describe("Transaction currency")
+}).describe("Polkadot-like chill data");
+var zPolkadotLikeKillAnonymousData = z5.object({
+  type: z5.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_KILLANONYMOUS),
+  currency: z5.string().describe("Transaction currency")
+}).describe("Polkadot-like kill anonymous data");
+var zPolkadotLikeRebondData = z5.object({
+  type: z5.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_REBOND),
+  currency: z5.string().describe("Transaction currency"),
+  amount: zBigInt.describe("Amount")
+}).describe("Polkadot-like rebond data");
+var zPolkadotLikeRemoveProxyData = z5.object({
+  type: z5.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_REMOVEPROXY),
+  currency: z5.string().describe("Transaction currency"),
+  kind: z5.literal("Staking"),
+  proxy: z5.string().describe("Proxy address")
+}).describe("Polkadot-like remove proxy data");
+var zPolkadotLikeSendData = zCommonTransactionData.extend({
+  type: z5.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_SEND)
+}).describe("Polkadot-like send data");
+var zPolkadotLikeSetPayeeData = z5.object({
+  type: z5.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_SETPAYEE),
+  currency: z5.string().describe("Transaction currency"),
+  payee: zPolkadotRewardDestination
+}).describe("Polkadot-like set payee data");
+var zPolkadotLikeUnbondData = z5.object({
+  type: z5.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_UNBOND),
+  currency: z5.string().describe("Transaction currency"),
+  amount: zBigInt.describe("Amount")
+}).describe("Polkadot-like unbond data");
+var zPolkadotLikeWithdrawUnbondedData = z5.object({
+  type: z5.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_WITHDRAWUNBONDED),
+  currency: z5.string().describe("Transaction currency")
+}).describe("Polkadot-like withdraw unbonded data");
+var zRippleLikeSendData = zCommonTransactionData.extend({
+  type: z5.literal(zRippleLikeTransactionType.enum.RIPPLE_LIKE_SEND),
+  destinationTag: zIntString.nullable().describe("Destination tag"),
+  feeStrategy: zFeeStrategyCustom.describe("Ripple-like fee strategy")
+}).describe("Ripple-like send data");
+var zStellarMemo = z5.union([
+  z5.object({ MEMO_TEXT: z5.string().max(28).describe("Text memo (at most a 28 bytes string)") }).describe("Text memo"),
+  z5.object({ MEMO_ID: zIntString.describe("Id memo (unsigned 64 bits integer)") }).describe("Id memo"),
+  z5.object({
+    MEMO_HASH: z5.string().max(128).regex(/^[a-fA-F0-9]+$/).describe("Transaction hash memo (64 bytes hexadecimal string)")
+  }).describe("Hash memo"),
+  z5.object({
+    MEMO_RETURN: z5.string().max(128).regex(/^[a-fA-F0-9]+$/).describe(
+      "A 64 bytes hexadecimal string intended to be interpreted as the hash of the transaction the sender is refunding."
+    )
+  }).describe("Return memo")
+]);
+var zStellarLikeSendData = zCommonTransactionData.extend({
+  type: z5.literal(zStellarLikeTransactionType.enum.STELLAR_LIKE_SEND),
+  memo: zStellarMemo.nullable().describe("Stellar memo"),
+  feeStrategy: zFeeStrategy.describe("Stellar-like fee strategy")
+}).describe("Stellar-like send data");
+var zSolanaLikeCreateDelegateStakeData = zCommonTransactionData.extend({
+  type: z5.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_CREATE_DELEGATE_STAKE),
+  recipient: z5.string().describe("Delegated vote address"),
+  // Re-described
+  feeStrategy: zFeeStrategy.describe("Solana-like fee strategy")
+}).describe("Solana-like create delegate stake data");
+var zSolanaLikeDeactivateStakeData = z5.object({
+  type: z5.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_DEACTIVATE_STAKE),
+  currency: z5.string().describe("Transaction currency"),
+  maxFee: zBigInt.nullable().describe("Transaction max fee"),
+  stakeAccount: z5.string().describe("Stake account address"),
+  feeStrategy: zFeeStrategy.describe("Solana-like fee strategy")
+  // No recipient, no amount
+}).describe("Solana-like deactivate stake data");
+var zSolanaLikeDelegateStakeData = z5.object({
+  type: z5.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_DELEGATE_STAKE),
+  currency: z5.string().describe("Transaction currency"),
+  maxFee: zBigInt.nullable().describe("Transaction max fee"),
+  recipient: z5.string().describe("Delegated vote address"),
+  stakeAccount: z5.string().describe("Stake account address"),
+  feeStrategy: zFeeStrategy.describe("Solana-like fee strategy")
+  // No amount
+}).describe("Solana-like delegate stake data");
+var zSolanaLikeMergeStakeData = z5.object({
+  type: z5.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_MERGE_STAKE),
+  currency: z5.string().describe("Transaction currency"),
+  maxFee: zBigInt.nullable().describe("Transaction max fee"),
+  mergeSrcAccount: z5.string().describe("Source stake address"),
+  mergeDstAccount: z5.string().describe("Destination stake address"),
+  feeStrategy: zFeeStrategy.describe("Solana-like fee strategy")
+  // No recipient, no amount
+}).describe("Solana-like merge stake data");
+var zSolanaLikeSendData = zCommonTransactionData.extend({
+  type: z5.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_SEND),
+  feeStrategy: zFeeStrategy.describe("Solana-like fee strategy")
+}).describe("Solana-like send data");
+var zSolanaLikeSplitDeactivateStakeData = z5.object({
+  type: z5.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_SPLIT_DEACTIVATE_STAKE),
+  amount: zBigInt.describe("Transaction amount"),
+  currency: z5.string().describe("Transaction currency"),
+  maxFee: zBigInt.nullable().describe("Transaction max fee"),
+  stakeAccount: z5.string().describe("Stake account address"),
+  feeStrategy: zFeeStrategy.describe("Solana-like fee strategy")
+  // No recipient
+}).describe("Solana-like split deactivate stake data");
+var zSolanaLikeSplitStakeData = z5.object({
+  type: z5.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_SPLIT_STAKE),
+  amount: zBigInt.describe("Transaction amount"),
+  currency: z5.string().describe("Transaction currency"),
+  maxFee: zBigInt.nullable().describe("Transaction max fee"),
+  stakeAccount: z5.string().describe("Stake account address"),
+  feeStrategy: zFeeStrategy.describe("Solana-like fee strategy")
+  // No recipient
+}).describe("Solana-like split stake data");
+var zSolanaLikeWithdrawStakeData = z5.object({
+  type: z5.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_WITHDRAW_STAKE),
+  amount: zBigInt.describe("Transaction amount"),
+  currency: z5.string().describe("Transaction currency"),
+  maxFee: zBigInt.nullable().describe("Transaction max fee"),
+  stakeAccount: z5.string().describe("Stake account address"),
+  feeStrategy: zFeeStrategy.describe("Solana-like fee strategy")
+  // No recipient
+}).describe("Solana-like delegate stake data");
+var zSolanaLikeSendTokenData = zCommonTransactionData.extend({
+  type: z5.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_SEND_TOKEN),
+  feeStrategy: zFeeStrategy.describe("Solana-like fee strategy")
+}).describe("Solana-like send token data");
+var zSolanaLikeFundTokenData = zCommonTransactionData.extend({
+  type: z5.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_FUND_TOKEN),
+  feeStrategy: zFeeStrategy.describe("Solana-like fee strategy")
+}).describe("Solana-like fund token data");
+var zCardanoSendData = zCommonTransactionData.extend({
+  type: z5.literal(zCardanoLikeTransactionType.enum.CARDANO_LIKE_SEND),
+  feeStrategy: zFeeStrategy.describe("Cardano-like fee strategy")
+}).describe("Cardano-like send data");
+var zCardanoStakingDelegateData = z5.object({
+  type: z5.literal(zCardanoLikeTransactionType.enum.CARDANO_LIKE_STAKING_DELEGATE),
+  currency: z5.string().describe("Transaction currency"),
+  // TODO: strict literal or enum?
+  maxFee: zBigInt.nullable().describe("Transaction max fee"),
+  feeStrategy: zFeeStrategy.describe("Cardano-like fee strategy"),
+  // DELEGATE doesn't have neither amount nor recipient
+  stakePoolId: z5.string().min(1).max(100).describe("")
+}).describe("Cardano-like staking delegate");
+var zCardanoStakingDeregisterData = z5.object({
+  type: z5.literal(zCardanoLikeTransactionType.enum.CARDANO_LIKE_STAKING_DEREGISTER),
+  currency: z5.string().describe("Transaction currency"),
+  // TODO: strict literal or enum?
+  maxFee: zBigInt.nullable().describe("Transaction max fee"),
+  feeStrategy: zFeeStrategy.describe("Cardano-like fee strategy"),
+  // DEREGISTER doesn't have a recipient
+  amount: zBigInt.describe("Amount to deregister")
+}).describe("Cardano-like staking deregister data");
+var zCardanoStakingRegisterData = z5.object({
+  type: z5.literal(zCardanoLikeTransactionType.enum.CARDANO_LIKE_STAKING_REGISTER),
+  currency: z5.string().describe("Transaction currency"),
+  // TODO: strict literal or enum?
+  maxFee: zBigInt.nullable().describe("Transaction max fee"),
+  feeStrategy: zFeeStrategy.describe("Cardano-like fee strategy"),
+  // REGISTER doesn't have a recipient
+  amount: zBigInt.describe("Amount to register")
+}).describe("Cardano-like staking register data");
+var zCardanoStakingWithdrawData = z5.object({
+  type: z5.literal(zCardanoLikeTransactionType.enum.CARDANO_LIKE_STAKING_WITHDRAW),
+  currency: z5.string().describe("Transaction currency"),
+  // TODO: strict literal or enum?
+  maxFee: zBigInt.nullable().describe("Transaction max fee"),
+  feeStrategy: zFeeStrategy.describe("Cardano-like fee strategy"),
+  // WITHDRAW doesn't have a recipient
+  amount: zBigInt.describe("Amount to withdraw")
+}).describe("Cardano-like staking withdraw data");
+var zGenericTransactionData = z5.object({
+  type: z5.literal(zGenericTransactionType.enum.GENERIC_TRANSACTION),
+  currency: z5.string().describe("Transaction currency"),
+  rawTx: z5.string().describe("Raw tx")
+}).describe("Generic transaction data");
+var zTransactionData = z5.discriminatedUnion("type", [
+  // Bitcoin
+  zBitcoinLikeSendData,
+  // Cardano
+  zCardanoSendData,
+  zCardanoStakingDelegateData,
+  zCardanoStakingDeregisterData,
+  zCardanoStakingRegisterData,
+  zCardanoStakingWithdrawData,
+  // Ethereum
+  zEthereumLikeDeployContractData,
+  zEthereumLikeExecuteContractData,
+  zEthereumLikeSendData,
+  // Generic
+  zGenericTransactionData,
+  // Polkadot
+  zPolkadotLikeAddProxyData,
+  zPolkadotLikeAnonymousProxyData,
+  zPolkadotLikeBondData,
+  zPolkadotLikeBondExtraData,
+  zPolkadotLikeChillData,
+  zPolkadotLikeKillAnonymousData,
+  zPolkadotLikeRebondData,
+  zPolkadotLikeRemoveProxyData,
+  zPolkadotLikeSendData,
+  zPolkadotLikeSetPayeeData,
+  zPolkadotLikeUnbondData,
+  zPolkadotLikeWithdrawUnbondedData,
+  // Ripple
+  zRippleLikeSendData,
+  // Solana
+  zSolanaLikeCreateDelegateStakeData,
+  zSolanaLikeDeactivateStakeData,
+  zSolanaLikeDelegateStakeData,
+  zSolanaLikeMergeStakeData,
+  zSolanaLikeSendData,
+  zSolanaLikeSplitDeactivateStakeData,
+  zSolanaLikeSplitStakeData,
+  zSolanaLikeWithdrawStakeData,
+  zSolanaLikeSendTokenData,
+  zSolanaLikeFundTokenData,
+  // Stellar
+  zStellarLikeSendData,
+  // Tezos
+  zTezosLikeDelegateData,
+  zTezosLikeSendData,
+  zTezosLikeUndelegateData
+]);
+var zSendOnlyTransactionData = z5.discriminatedUnion("type", [
+  zBitcoinLikeSendData,
+  zCardanoSendData,
+  zEthereumLikeSendData,
+  zPolkadotLikeSendData,
+  zRippleLikeSendData,
+  zSolanaLikeSendData,
+  zStellarLikeSendData,
+  zTezosLikeSendData
+]);
+var zCreateTransactionRequestData = z5.object({
+  accountId: z5.string().min(1).describe("Target account id"),
+  transaction: zTransactionData
+});
+var zAccountOperationType = z.enum([
+  "SEND",
+  "STAKE",
+  "DEPLOY_CONTRACT",
+  "EXECUTE_CONTRACT",
+  "SIGN_DIGESTS",
+  "SIGN_MESSAGE",
+  "ACTIVATE_TOKEN"
+]);
+var zOperationType = z.enum([...zAccountOperationType.options]);
+var zNote = z5.object({
+  title: z5.string().describe("Request note title"),
+  content: z5.string().describe("Request note content")
+});
+
+// src/accounts/clients/types.ts
+var zTransactionStatus = z5.enum(["SUCCESSFUL", "FAILED"]);
+var zBitcoinLikeCoinFields = z5.object({
+  type: zBitcoinLikeTransactionType
+});
+var zCardanoLikeCoinFields = z5.object({
+  type: zCardanoLikeTransactionType
+});
+var zEthereumLikeTransferCoinFields = z5.object({
+  type: zEthereumLikeTransferTransactionType,
+  gasPrice: z5.string(),
+  gasLimit: z5.string(),
+  nonce: z5.string()
+});
+var zEthereumLikeContractCoinFields = zEthereumLikeTransferCoinFields.extend({
+  type: zEthereumLikeContractTransactionType,
+  contractData: z5.string().describe("Contract deployment or contract execution data")
+});
+var zGenericCoinFields = z5.object({
+  type: zGenericTransactionType
+});
+var zPolkadotLikeCoinFields = z5.object({
+  type: zPolkadotLikeTransactionType
+});
+var zRippleLikeCoinFields = z5.object({
+  type: zRippleLikeTransactionType,
+  memos: z5.array(z5.string()),
+  destinationTag: z5.string()
+});
+var zSolanaLikeCoinFields = z5.object({
+  type: zSolanaLikeTransactionType
+});
+var zStellarLikeCoinFields = z5.object({
+  type: zStellarLikeTransactionType
+});
+var zTezosLikeCoinFields = z5.object({
+  type: zTezosLikeTransactionType
+});
+var zCommonTransactionResponse = z5.object({
+  id: z5.string().describe("Internal unique identifier"),
+  hash: z5.string().describe("Transaction hash"),
+  block: z5.object({
+    height: z5.string().nullable().describe("Transaction block height"),
+    time: z5.string().nullable().describe("Transaction block time")
+  }),
+  status: zTransactionStatus.describe("Transaction status"),
+  confirmations: z5.string().describe("Block confirmations"),
+  amount: z5.string().describe("Transaction amount"),
+  fee: z5.string().describe("Transaction fee"),
+  senders: z5.array(z5.string()).describe("Senders (can be multiple for UTXOs-based accounts)"),
+  recipients: z5.array(z5.string()).describe("Recipients (can be multiple for multi-output transactions)")
+});
+var zBitcoinLikeTransactionResponse = zCommonTransactionResponse.merge(zBitcoinLikeCoinFields).describe("Bitcoin-like transaction");
+var zCardanoLikeTransactionResponse = zCommonTransactionResponse.merge(zCardanoLikeCoinFields).describe("Cardano-like transaction");
+var zEthereumLikeTransferTransactionResponse = zCommonTransactionResponse.merge(zEthereumLikeTransferCoinFields).describe("Ethereum-like transfer transaction");
+var zEthereumLikeContractTransactionResponse = zCommonTransactionResponse.merge(zEthereumLikeContractCoinFields).describe("Ethereum-like contract transaction");
+var zGenericTransactionResponse = zCommonTransactionResponse.merge(zGenericCoinFields).describe("Generic transaction");
+var zPolkadotLikeTransactionResponse = zCommonTransactionResponse.merge(zPolkadotLikeCoinFields).describe("Polkadot-like transaction");
+var zRippleLikeTransactionResponse = zCommonTransactionResponse.merge(zRippleLikeCoinFields).describe("Ripple-like transaction");
+var zSolanaLikeTransactionResponse = zCommonTransactionResponse.merge(zSolanaLikeCoinFields).describe("Solana-like transaction");
+var zStellarLikeTransactionResponse = zCommonTransactionResponse.merge(zStellarLikeCoinFields).describe("Stellar-like transaction");
+var zTezosLikeTransactionResponse = zCommonTransactionResponse.merge(zTezosLikeCoinFields).describe("Tezos-like transaction");
+var zTransactionResponse = z5.discriminatedUnion("type", [
+  zBitcoinLikeTransactionResponse,
+  zCardanoLikeTransactionResponse,
+  zEthereumLikeTransferTransactionResponse,
+  zEthereumLikeContractTransactionResponse,
+  zGenericTransactionResponse,
+  zPolkadotLikeTransactionResponse,
+  zRippleLikeTransactionResponse,
+  zSolanaLikeTransactionResponse,
+  zStellarLikeTransactionResponse,
+  zTezosLikeTransactionResponse
+]);
+z5.discriminatedUnion(
+  zTransactionResponse.discriminator,
+  ensureNonEmptyArray(
+    zTransactionResponse.options.map((_) => _.extend({ note: zNote.nullable() }))
+  )
+);
+var zCardanoLikeStakingData = z5.object({
+  staked: z5.string().describe("Staked balance")
+}).nullable().describe("Cardano-like staking data");
+var zCardanoLikeStakingFields = z5.object({
+  type: z5.literal(AccountType.CARDANO_LIKE).describe("Account type"),
+  staking: zCardanoLikeStakingData.optional()
+});
+var zEthereumLikeStakingData = z5.object({
+  totalStaking: z5.string().describe("Total staked amount"),
+  totalRewards: z5.string().describe("Total of rewards"),
+  availableRewards: z5.string().describe("Available rewards"),
+  networkApy: z5.number().describe("Network APY")
+}).nullable().describe("Ethereum-like staking data");
+var zEthereumLikeStakingFields = z5.object({
+  type: z5.literal(AccountType.ETHEREUM_LIKE).describe("Account type"),
+  staking: zEthereumLikeStakingData.optional()
+});
+var zPolkadotUnbondingAmount = z5.object({
+  amount: z5.string().describe("Amount"),
+  waiting_time: z5.string().describe("Waiting time")
+});
+var zPolkadotLikeStakingData = z5.object({
+  info: z5.object({
+    controllerAddress: z5.string().nullable().describe("Controller address"),
+    rewardsDestination: z5.string().nullable().describe("Rewards destination"),
+    proxies: z5.array(z5.string()).describe("Proxies"),
+    legacyStaking: z5.boolean().describe("True if account uses legacy staking"),
+    isNominator: z5.boolean().describe("True if is nominator")
+  }),
+  balances: z5.object({
+    free: z5.string().describe("Free balance"),
+    reserved: z5.string().describe("Reserved balance"),
+    frozen: z5.string().describe("Frozen balance"),
+    bonded: z5.string().describe("Bonded balance"),
+    available: z5.string().describe("Available balance"),
+    unbonding: z5.array(zPolkadotUnbondingAmount).describe("Unbonding balances"),
+    unbonded: z5.array(zPolkadotUnbondingAmount).describe("Unbonded balances"),
+    totalUnbonding: z5.string().describe("Total unbonding"),
+    totalUnbonded: z5.string().describe("Total unbonded")
+  }),
+  anonymousProxy: z5.object({
+    address: z5.string().describe("Address"),
+    createdAt: z5.string().describe("Creation date"),
+    isController: z5.boolean().describe("True if is controller"),
+    isMain: z5.boolean().describe("True if is main"),
+    balances: z5.object({
+      free: z5.string().describe("Anonymous proxy free balance"),
+      reserved: z5.string().describe("Anonymous proxy reserved balance"),
+      frozen: z5.string().describe("Anonymous proxy frozen balance"),
+      bonded: z5.string().describe("Anonymous proxy bonded balance"),
+      available: z5.string().describe("Anonymous proxy available balance"),
+      total: z5.string().describe("Anonymous proxy total balance")
+    }).nullable(),
+    blockHeight: z5.string().describe("Anonymous proxy block height"),
+    extIndex: z5.string().describe("Ext index"),
+    index: z5.string().describe("Index"),
+    kind: z5.string().describe("Kind")
+  }).nullable().describe("Anonymous proxy")
+}).nullable().describe("Polkadot-like staking data");
+var zPolkadotLikeStakingFields = z5.object({
+  type: z5.literal(AccountType.POLKADOT_LIKE).describe("Account type"),
+  staking: zPolkadotLikeStakingData.optional()
+});
+var zSolanaStakingAccountStatus = z5.enum(["not_sync", "activating", "activated", "deactivating", "deactivated", "deleted"]).describe("Staking account status");
+var zSolanaLikeStakingData = z5.object({
+  staked: z5.string().describe("Staked balance"),
+  rewards: z5.object({
+    total: z5.string().describe("Total rewards"),
+    last7: z5.string().describe("Rewards on last 7 days"),
+    last30: z5.string().describe("Rewards on last 30 days")
+  }),
+  stakes: z5.array(
+    z5.object({
+      uid: z5.string(),
+      baseAccountUid: z5.string(),
+      pubKey: z5.string().describe("Public key"),
+      validatorPubKey: z5.string().nullable().describe("Validator public key"),
+      initialAmount: z5.string().describe("Initial amount"),
+      activeAmount: z5.string().describe("Active amount"),
+      inactiveAmount: z5.string().describe("Inactive amount"),
+      totalBalance: z5.string().describe("Total balance"),
+      creationDate: z5.string().describe("Creation date"),
+      activationEpoch: z5.string().nullable().describe("Activation epoch"),
+      activationDate: z5.string().nullable().describe("Activation date"),
+      deactivationEpoch: z5.string().nullable().describe("Deactivation epoch"),
+      deactivationDate: z5.string().nullable().describe("Deactivation date"),
+      status: zSolanaStakingAccountStatus,
+      rentExemptReserve: z5.string().describe("Rent exempt reserve"),
+      withdrawableAmount: z5.string().describe("Withdrawable amount"),
+      totalRewards: z5.string().describe("Total rewards"),
+      creationTxHash: z5.string().nullable().describe("Creation transaction hash"),
+      actionsTxHashes: z5.array(z5.string()).describe("Actions transactions hashes")
+    })
+  )
+}).nullable().describe("Solana-like staking data");
+var zSolanaLikeStakingFields = z5.object({
+  type: z5.literal(AccountType.SOLANA_LIKE).describe("Account type"),
+  staking: zSolanaLikeStakingData.optional()
+});
+var zTezosLikeStakingData = z5.object({
+  delegations: z5.array(
+    z5.object({
+      address: z5.string()
+    })
+  )
+}).nullable().describe("Tezos-like staking data");
+var zTezosLikeStakingFields = z5.object({
+  type: z5.literal(AccountType.TEZOS_LIKE).describe("Account type"),
+  staking: zTezosLikeStakingData.optional()
+});
+z5.discriminatedUnion("type", [
+  zCardanoLikeStakingFields,
+  zEthereumLikeStakingFields,
+  zPolkadotLikeStakingFields,
+  zSolanaLikeStakingFields,
+  zTezosLikeStakingFields
+]);
+
+// src/accounts/account-asset-fields.ts
+var zBitcoinLikeAssetFields = z.object({
+  type: z.literal(AccountType.BITCOIN_LIKE).describe("Account type"),
+  xpub: z.string().describe("xpub (extended public key)")
+}).describe("Bitcoin-like");
+var zCardanoLikeAssetFields = z.object({
+  type: z.literal(AccountType.CARDANO_LIKE).describe("Account type"),
+  address: z.string().describe("Account address").nullable()
+}).describe("Cardano-like");
+var zEthereumLikeAssetFields = z.object({
+  type: z.literal(AccountType.ETHEREUM_LIKE).describe("Account type"),
+  address: z.string().describe("Account address").nullable()
+}).describe("Ethereum-like");
+var zEthereumTokenLikeAssetFields = z.object({
+  type: z.enum([AccountType.ERC20_LIKE, AccountType.BEP20_LIKE, AccountType.TRC20_LIKE]).describe("Account type"),
+  address: z.string().describe("Account address").nullable(),
+  contractAddress: z.string().describe("Token contract address")
+}).describe("Ethereum-like token");
+var zGenericLikeAssetFields = z.object({ type: z.literal(AccountType.GENERIC_LIKE).describe("Account type") }).describe("Generic-like");
+var zPolkadotLikeAssetFields = z.object({
+  type: z.literal(AccountType.POLKADOT_LIKE).describe("Account type"),
+  address: z.string().describe("Account address").nullable()
+}).describe("Polkadot-like");
+var zRippleLikeAssetFields = z.object({
+  type: z.literal(AccountType.RIPPLE_LIKE).describe("Account type"),
+  xpub: z.string().describe("xpub (extended public key)")
+}).describe("Ripple-like");
+var zSolanaLikeAssetFields = z.object({
+  type: z.literal(AccountType.SOLANA_LIKE).describe("Account type"),
+  address: z.string().describe("Account address").nullable(),
+  contractAddress: z.string().describe("Token contract address").nullable()
+}).describe("Solana-like");
+var zStellarLikeAssetFields = z.object({
+  type: z.literal(AccountType.STELLAR_LIKE).describe("Account type"),
+  address: z.string().describe("Account address").nullable()
+}).describe("Stellar-like");
+var zTezosLikeAssetFields = z.object({
+  type: z.literal(AccountType.TEZOS_LIKE).describe("Account type"),
+  address: z.string().describe("Account address").nullable()
+}).describe("Tezos-like");
+z.discriminatedUnion("type", [
+  zBitcoinLikeAssetFields,
+  zCardanoLikeAssetFields,
+  zEthereumLikeAssetFields,
+  zEthereumTokenLikeAssetFields,
+  zGenericLikeAssetFields,
+  zPolkadotLikeAssetFields,
+  zRippleLikeAssetFields,
+  zSolanaLikeAssetFields,
+  zStellarLikeAssetFields,
+  zTezosLikeAssetFields
+]).describe("Account asset fields");
+var zAccountAssetFields = z.discriminatedUnion("type", [
+  zBitcoinLikeAssetFields,
+  zCardanoLikeAssetFields.merge(zCardanoLikeStakingFields).describe("Cardano-like"),
+  zEthereumLikeAssetFields.merge(zEthereumLikeStakingFields).describe("Ethereum-like"),
+  zEthereumTokenLikeAssetFields,
+  zGenericLikeAssetFields,
+  zPolkadotLikeAssetFields.merge(zPolkadotLikeStakingFields).describe("Polkadot-like"),
+  zRippleLikeAssetFields,
+  zSolanaLikeAssetFields.merge(zSolanaLikeStakingFields).describe("Solana-like"),
+  zStellarLikeAssetFields,
+  zTezosLikeAssetFields.merge(zTezosLikeStakingFields).describe("Tezos-like")
+]).describe("Asset fields");
+var zReviewStepWithUsers = z.object({
+  quorum: z.number().min(0).describe("Number of required approvals for the step"),
+  userIds: z.array(z.string().min(1)).describe("User ids in the step")
+  // PKs to `User` model
+}).describe("Review step with users");
+var zReviewStepWithUsersArray = z.array(zReviewStepWithUsers);
+var zReviewStepData = z.union([
+  zReviewStepWithUsers,
+  z.object({
+    quorum: z.number().min(0).describe("Number of required approvals for the step"),
+    groupId: z.string().min(1).describe("Group id in the step")
+    // PKs to `Group` model
+  }).describe("Review step with group")
+]);
+var zReviewStepsArray = z.array(zReviewStepData).min(1).describe("Review steps");
+var zWorkspaceName = z5.string().min(1).max(20).regex(/^[a-z0-9]+$/);
+
+// src/tradelink/types.ts
+var zTradelinkWhitelistAddress = z5.object({
+  name: z5.string().min(1),
+  currency: z5.string().min(1),
+  address: z5.string().min(1)
+});
+z5.array(zTradelinkWhitelistAddress);
+var zTradelinkId = z5.string().describe("Unique identifier in Tradelink service");
+var zTradelinkOrgEntityResponse = z5.object({
+  tradelinkId: zTradelinkId,
+  name: z5.string().describe("Name"),
+  code: z5.string().describe("Code"),
+  logoUrl: z5.string().describe("Logo URL")
+});
+zTradelinkOrgEntityResponse.omit({
+  tradelinkId: true
+});
+z5.object({
+  tradelinkId: zTradelinkId
+});
+var zTradelinkExchangeConfig = z5.object({
+  exchangeId: z5.string().describe("Tradelink exchange id"),
+  repledgeAuthorized: z5.boolean().describe("Determines whether this exchange is authorized to repledge on this account"),
+  needsAssetManagerApprovalForSettlements: z5.boolean().describe(
+    'Determines whether asset manager will "pre-approve" the settlement requests on this account'
+  )
+});
+var zTradelinkExchangeConfigs = z5.array(zTradelinkExchangeConfig);
+z5.object({
+  workspaceName: zWorkspaceName,
+  custodian: z5.object({ name: z5.string() }),
+  assetManagers: z5.array(z5.object({ name: z5.string() })),
+  exchanges: z5.array(z5.object({ name: z5.string() }))
+});
+z5.object({
+  tradelinkId: z5.string(),
+  workspaceName: zWorkspaceName,
+  custodian: zTradelinkOrgEntityResponse,
+  assetManagers: z5.array(zTradelinkOrgEntityResponse),
+  exchanges: z5.array(zTradelinkOrgEntityResponse)
+});
+var zTradelinkAsset = z5.object({
+  name: z5.string(),
+  magnitude: z5.number().int().nonnegative()
+});
+z5.object({
+  tradelinkId: zTradelinkId,
+  asset: zTradelinkAsset,
+  state: z5.enum([
+    "PLEDGE_READY",
+    "PLEDGE_INCREMENT_PENDING_APPROVAL",
+    "PLEDGE_APPROVED",
+    "PLEDGE_REJECTED",
+    "UNPLEDGE_PENDING_APPROVAL",
+    "UNPLEDGE_APPROVED",
+    "UNPLEDGE_REJECTED",
+    "REPLEDGE_PENDING_APPROVAL",
+    "REPLEDGE_APPROVED",
+    "REPLEDGE_REJECTED",
+    "ASSIGNED_TO_SETTLEMENT",
+    "OUTBOUND_TRANSACTION_CONFIRMED",
+    "OUTBOUND_TRANSACTION_FAILED",
+    "RECOVERING_FROM_FAILURE",
+    "PLEDGE_CONSUMED"
+  ]),
+  isLocked: z5.boolean(),
+  amount: z5.string().describe("Currently pledged amount"),
+  pending: z5.string().describe("Requested pledge increment, not yet approved"),
+  repledge: z5.string().describe("TODO: describe this field"),
+  exchangeTradelinkId: z5.string(),
+  accountId: z5.string()
+});
+z5.object({
+  workspaceName: z5.string(),
+  clientAccountId: z5.string().describe("Account ID from the client side"),
+  exchangeTradelinkId: zTradelinkId,
+  asset: zTradelinkAsset
+});
+z5.object({
+  pledgeTradelinkId: zTradelinkId,
+  amount: zBigInt,
+  asset: zTradelinkAsset
+});
+z5.object({
+  tradelinkId: z5.string(),
+  pledgeTradelinkId: z5.string(),
+  state: z5.enum([
+    "REGISTERED",
+    "PENDING_REPLEDGE_CREATION_APPROVAL",
+    "PENDING_REPLEDGE_APPROVAL",
+    "PENDING_CREATION_APPROVAL",
+    "PENDING_PRE_APPROVAL",
+    "PRE_APPROVED",
+    "APPROVED",
+    "REJECTED",
+    "CONFIRMED",
+    "FAILED"
+  ]),
+  // For now we only consider the outbound settlement
+  outboundTransactionHash: z5.string().nullable()
+});
+
+// src/tradelink/request-data.ts
+var zCustodianRequestData = z5.object({
+  settlement: zReviewStepWithUsersArray.describe("List of settlement review steps"),
+  withdraw: zReviewStepWithUsersArray.describe("List of withdraw review steps"),
+  arbitration: zReviewStepWithUsersArray.describe("List of arbitration review steps")
+});
+var zTradelinkEntityRequestData = z5.object({
+  tradelinkId: z5.string().min(1),
+  groups: zReviewStepWithUsersArray.describe("List of asset manager review groups"),
+  whitelist: z5.array(zTradelinkWhitelistAddress).describe("List of asset manager whitelisted addresses")
+});
+var zAdjustPledgeRequestData = z5.object({
+  accountId: z5.string().describe("Account id"),
+  exchangeId: z5.string().describe("Exchange id"),
+  amount: zIntString.describe("Amount to add to pledge")
+});
+var zCreateSettlementRequestData = z5.object({
+  accountId: z5.string().describe("Account id"),
+  exchangeId: z5.string().describe("Exchange id"),
+  transaction: zSendOnlyTransactionData
+});
+var zForceUnpledgeRequestData = z5.object({
+  accountId: z5.string().describe("Account id"),
+  exchangeId: z5.string().describe("Exchange id")
+});
+var zTradelinkWithdrawRequestData = z5.object({
+  accountId: z5.string().describe("Account id"),
+  transaction: zSendOnlyTransactionData
+});
+
+// src/accounts/account-governance-fields.ts
+var zClassicAccountGovernanceFields = z.object({
+  type: z.literal(AccountGovernanceType.CLASSIC).describe("Classic account governance"),
+  policyId: z.string().describe("Identifier of corresponding governance policy")
+}).describe("Classic");
+var zTradelinkAccountGovernanceFields = z.object({
+  type: z.literal(AccountGovernanceType.TRADELINK).describe("Tradelink account governance"),
+  assetManagerId: z.string().describe("Identifier of corresponding asset manager"),
+  exchangeConfigs: zTradelinkExchangeConfigs.describe("Tradelink exchange configurations")
+}).describe("Tradelink");
+var zAccountGovernanceFields = z.discriminatedUnion("type", [zClassicAccountGovernanceFields, zTradelinkAccountGovernanceFields]).describe("Governance fields");
+
+// src/accounts/types.ts
+var zAccountCommonFields = z5.object({
+  id: z5.string().describe("Internal unique identifier"),
+  legacyId: z5.number().describe("Legacy internal unique identifier (for retro-compatibility)"),
+  status: z5.nativeEnum(ActivationStatus).describe("Status"),
+  name: z5.string().describe("Name"),
+  currency: z5.string().describe("Currency identifier"),
+  index: z5.number().gte(0).describe("BIP44 account index"),
+  derivationPath: z5.string().describe("Derivation path"),
+  createdAt: z5.coerce.date().describe("Creation timestamp"),
+  updatedAt: z5.coerce.date().describe("Last modification timestamp")
+});
+var zAccountBalanceFields = z5.object({
+  total: z5.string().describe("Total balance"),
+  pending: z5.string().describe("Pending balance")
+}).describe("Balance fields");
+var zAccountResponse = zAccountCommonFields.extend({
+  balance: zAccountBalanceFields.optional(),
+  asset: zAccountAssetFields,
+  governance: zAccountGovernanceFields
+});
+z5.enum([
+  "name",
+  "currency",
+  "index",
+  "createdAt",
+  "updatedAt"
+]).default("createdAt");
+
+// src/accounts/app-types.ts
+var zNote2 = z5.object({
+  title: z5.string().describe("Transaction note title"),
+  content: z5.string().describe("Transaction note content")
+}).describe("Optional transaction note");
+z5.discriminatedUnion(
+  zTransactionResponse.discriminator,
+  ensureNonEmptyArray(
+    zTransactionResponse.options.map((_) => _.extend({ note: zNote2.nullable() }))
+  )
+);
+var zWhitelistAddress = z5.object({
+  name: z5.string().min(1).max(50),
+  currency: z5.string().min(1).max(50),
+  address: z5.string().min(1).max(200),
+  // Destination tags are numeric-only or alpha-numeric.
+  // Empty array (or undefined) means no check on destination tag.
+  destinationTags: z5.array(z5.string().min(1).regex(/^\w+$/)).optional()
+});
+var zWhitelistAddresses = z5.array(zWhitelistAddress);
+var zWhitelistName = z5.string().min(1).max(45).describe("Whitelist name");
+var zCreateWhitelistRequestData = z5.object({
+  name: zWhitelistName,
+  description: z5.string().nullable(),
+  addresses: zWhitelistAddresses,
+  type: z5.nativeEnum(WhitelistType)
+});
+var zEditWhitelistRequestData = z5.object({
+  name: zWhitelistName,
+  addresses: zWhitelistAddresses
+});
+
+// src/policies/db-utils.ts
+var zThreshold = z5.object({
+  min: z5.string().regex(/^\d+$/).nullable().describe("Minimum transaction amount"),
+  // bigint
+  max: z5.string().regex(/^\d+$/).nullable().describe("Maximum transaction amount")
+  // bigint
+}).describe("Threshold for the transaction value");
+var zWhitelistIds = z5.array(z5.string().min(1)).describe("IDs of whitelists for the recipient address");
+var zGovRuleJsonObject = z5.object({
+  // Required.
+  operationType: zOperationType.describe("Allowed operation type"),
+  // Optional threshold on transaction value: null `min` = 0, null `max` = +inf
+  threshold: zThreshold,
+  // Optional whitelist on transaction recipient: Empty list means no whitelist.
+  whitelistIds: zWhitelistIds,
+  reviewConfigId: z5.string().min(1).describe("Id of ReviewConfig"),
+  // HSM id for the rule
+  hsmId: zHsmObjectId
+}).describe("INTERNAL: Governance rule JSON representation in DB");
+z5.array(zGovRuleJsonObject);
+var zAccountGovRuleData = z5.object({
+  operationType: zAccountOperationType.describe("Allowed operation type"),
+  // Optional threshold on transaction value: null `min` = 0, null `max` = +inf
+  threshold: zThreshold.optional(),
+  // Optional whitelist on transaction recipient: Empty list means no whitelist.
+  whitelistIds: zWhitelistIds.optional(),
+  reviewSteps: zReviewStepsArray
+}).describe("Account governance rule");
+var zGovRuleData = z5.discriminatedUnion("operationType", [zAccountGovRuleData]).describe("Governance rule");
+var zPolicyName = z5.string().min(1).max(19).describe("Policy name");
+var zCurrency = z5.string().min(1).max(40).regex(/^\w+$/).describe("Currency");
+var zCreatePolicyRequestData = z5.object({
+  name: zPolicyName,
+  description: z5.string().nullable().describe("Description"),
+  currency: zCurrency,
+  govRules: z5.array(zGovRuleData).describe("Governance rules")
+});
+var zEditPolicyRequestData = z5.object({
+  name: zPolicyName,
+  description: z5.string().nullable().describe("Description"),
+  govRules: z5.array(zGovRuleData).describe("Governance rules")
+});
+
+// src/accounts/request-data.ts
+var zAccountName = z5.string().min(1).max(40).describe("Account name");
+var zCurrency2 = z5.string().min(1).max(40).regex(/^\w+$/).describe("Currency");
+var zAccountPolicyRequestData = z5.discriminatedUnion("type", [
+  z5.object({ type: z5.literal(PolicyType.ACCOUNT_POLICY), policyId: z5.string() }).describe("Account policy"),
+  z5.object({ type: z5.literal(PolicyType.ACCOUNT_PRIVATE_POLICY), rules: z5.array(zGovRuleData) }).describe("Account governance rules")
+]).describe("Account policy or governance rules");
+var zCreateAccountGovernanceData = z5.discriminatedUnion("type", [
+  z5.object({
+    type: z5.literal(AccountGovernanceType.CLASSIC),
+    policy: zAccountPolicyRequestData
+  }),
+  z5.object({
+    type: z5.literal(AccountGovernanceType.TRADELINK),
+    assetManagerId: z5.string(),
+    exchangeConfigs: zTradelinkExchangeConfigs
+  })
+]);
+var zCreateAccountUserInputData = z5.object({
+  name: zAccountName,
+  type: z5.nativeEnum(AccountType),
+  // "BITCOIN_LIKE"
+  currency: zCurrency2,
+  // "bitcoin"
+  index: z5.number().nonnegative().optional().describe("Account index"),
+  contractAddress: z5.string().min(1).optional().describe("Account contract address"),
+  governance: zCreateAccountGovernanceData
+});
+var zCreateAccountRequestData = zCreateAccountUserInputData.omit({ index: true }).extend({
+  index: z5.number().nonnegative().describe("Account index"),
+  derivationPath: z5.string().describe("Account bip44 derivation path")
+});
+var zEditAccountGovernanceData = z5.discriminatedUnion("type", [
+  z5.object({
+    type: z5.literal(AccountGovernanceType.CLASSIC),
+    policy: zAccountPolicyRequestData
+  }),
+  z5.object({
+    type: z5.literal(AccountGovernanceType.TRADELINK),
+    exchangeConfigs: zTradelinkExchangeConfigs
+  })
+]);
+var zEditAccountRequestData = z5.object({
+  name: zAccountName,
+  governance: zEditAccountGovernanceData
+});
+var zActivateAccountRequestData = z5.object({});
+var zEditTokenRuleRequestData = z5.object({
+  parentAccountId: z5.string().min(1).describe("Parent account unique ID"),
+  contractAddress: z5.string().min(1).describe("Token contract address"),
+  rules: z5.array(zGovRuleData).describe("Account governance rules")
+});
+
+// src/accounts/app-utils.ts
+var getAccountAssetStaticFields = (account) => {
+  switch (account.type) {
+    case AccountType.BITCOIN_LIKE:
+      return {
+        type: account.type,
+        xpub: account.xpub
+      };
+    case AccountType.ETHEREUM_LIKE:
+      return {
+        type: account.type,
+        address: account.address
+      };
+    case AccountType.ERC20_LIKE:
+    case AccountType.BEP20_LIKE:
+    case AccountType.TRC20_LIKE:
+      return {
+        type: account.type,
+        address: account.address,
+        contractAddress: account.contractAddress
+      };
+    case AccountType.CARDANO_LIKE:
+      return {
+        type: account.type,
+        address: account.address
+      };
+    case AccountType.SOLANA_LIKE:
+      return {
+        type: account.type,
+        address: account.address,
+        contractAddress: account.contractAddress
+      };
+    case AccountType.TEZOS_LIKE:
+      return {
+        type: account.type,
+        address: account.address
+      };
+    case AccountType.STELLAR_LIKE:
+      return {
+        type: account.type,
+        address: account.address
+      };
+    case AccountType.RIPPLE_LIKE:
+      return {
+        type: account.type,
+        xpub: account.xpub
+      };
+    case AccountType.POLKADOT_LIKE:
+      return {
+        type: account.type,
+        address: account.address
+      };
+    case AccountType.GENERIC_LIKE:
+      return {
+        type: account.type
+      };
+    /* v8 ignore start */
+    default:
+      unreachable(account.type);
+  }
+};
+var getAccountGovernanceFields = (account) => {
+  switch (account.governanceType) {
+    case AccountGovernanceType.CLASSIC:
+      return {
+        type: AccountGovernanceType.CLASSIC,
+        policyId: account.classicGovernanceMixin.policyId
+      };
+    case AccountGovernanceType.TRADELINK:
+      return {
+        type: AccountGovernanceType.TRADELINK,
+        assetManagerId: account.tradelinkGovernanceMixin.assetManagerId,
+        exchangeConfigs: zTradelinkExchangeConfigs.parse(
+          account.tradelinkGovernanceMixin.exchangeConfigs
+        )
+      };
+    /* v8 ignore start */
+    default:
+      unreachable(account.governanceType);
+  }
+};
+var serializeAccount = (account) => {
+  const asset = getAccountAssetStaticFields(account);
+  const governance = getAccountGovernanceFields(account);
+  const response = {
+    ...account,
+    legacyId: account.gateId,
+    governance,
+    asset
+  };
+  return zAccountResponse.parse(response);
+};
+var zSciConfigData = z5.object({
+  dapps: z5.array(z5.string()).nullable().describe("Allowed DApps, null allows all"),
+  customContractCallEnabled: z5.boolean().describe("Allow non-DApp SCI")
+});
+var zCreateSciConfigRequestData = z5.object({
+  account: z5.string().describe("Account UUID"),
+  config: zSciConfigData
+});
+var zEditSciConfigRequestData = z5.object({
+  config: zSciConfigData
+});
+var zRequestReviewStep = z.object({
+  stageName: z.string().regex(/^\w+$/).describe("The review stage name"),
+  quorum: z.number().int().min(1).describe("Quorum for the review step")
+});
+var zRequestReviewSteps = z.array(zRequestReviewStep);
+var zGroupName = z5.string().min(1).max(19).describe("Group name");
+var zCreateGroupRequestData = z5.object({
+  name: zGroupName,
+  description: z5.string().nullable().describe("Group description"),
+  members: z5.array(z5.string()).describe("List of group members ids")
+});
+var zEditGroupRequestData = z5.object({
+  name: zGroupName,
+  members: z5.array(z5.string()).describe("List of group members ids")
+});
+var zRegistration = z5.discriminatedUnion("subState", [
+  z5.object({
+    subState: z5.literal("PENDING"),
+    deviceData: zUserRegistrationDeviceData.describe("Device data"),
+    challenge: zUserRegistrationChallenge.describe("Registration challenge")
+  }).describe("Pending registration"),
+  z5.object({
+    subState: z5.literal("COMPLETED"),
+    pubKey: zPubKey.describe("User device public key"),
+    u2fKeyHandle: z5.string().describe("U2F key handle for authenticate via PSD"),
+    u2fPubKey: zPubKey.describe("U2F public key for authenticate via PSD")
+  }).describe("Completed registration")
+]);
+var zUserName = z5.string().min(1).max(19).describe("User name");
+var zCreateUserWithDeviceData = z5.object({
+  name: zUserName,
+  deviceType: z5.enum([UserDeviceType.PSD, UserDeviceType.SOFT_PSD]).describe("Device type"),
+  deviceUserId: z5.string().regex(/^[A-F0-9]{16}$/).describe("Device user ID"),
+  registration: zRegistration.optional().describe("Data collected from the new user during registration")
+}).describe("Create PSD or Soft PSD user request data");
+var zCreateAdminRequestData = zCreateUserWithDeviceData.extend({
+  deviceType: z5.literal(UserDeviceType.PSD).describe("Device type")
+  // Admin must use PSD
+});
+var zCreateOperatorRequestData = zCreateUserWithDeviceData;
+var zCreateApiUserRequestData = z5.object({
+  name: zUserName,
+  publicKey: z5.string().describe("Public key")
+}).describe("Create API user request data");
+var zCreateApiUserAccessRequestData = z5.object({
+  name: zUserName
+}).describe("Create API user request data");
+var zApiKeyName = z5.string().min(1).max(19).describe("API key name");
+var zCreateApiKeyRequestData = z5.object({
+  name: zApiKeyName,
+  entities: z5.array(z5.string()).describe("List of related entities ids"),
+  scopes: z5.object({}).describe("FIXME to be precised")
+}).describe("Create read-only API key request data");
+var zEditApiKeyRequestData = zCreateApiKeyRequestData.describe(
+  "Edit read-only API key request data"
+);
+var zEntityName = z5.string().min(1).max(19).describe("Entity name");
+var zCreateEntityRequestData = z5.object({
+  name: zEntityName,
+  accounts: z5.array(z5.string())
+});
+var zEditEntityRequestData = z5.object({
+  name: zEntityName,
+  accounts: z5.array(z5.string())
+});
+var NonRootAdminPermission = omit(AdminPermission, "ROOT");
+var zWorkspaceRuleRequestData = z5.object({
+  permission: z5.nativeEnum(NonRootAdminPermission).describe("Granted permissions"),
+  reviewConfig: zReviewStepWithUsersArray.describe("List of admin review steps")
+});
+var zUpdateQuorumRequestData = z5.object({
+  quorum: z5.number().int().min(1).describe("Workspace quorum")
+});
+
+// src/requests/request-data.ts
+var zUserCreationVaultRequestMixinsByType = {
+  CREATE_ADMIN: z5.object({
+    type: z5.literal(RequestType.CREATE_ADMIN),
+    data: zCreateAdminRequestData
+  }),
+  CREATE_OPERATOR: z5.object({
+    type: z5.literal(RequestType.CREATE_OPERATOR),
+    data: zCreateOperatorRequestData
+  })
+};
+var zVaultRequestMixinsByType = {
+  // Workspaces
+  [RequestType.UPDATE_QUORUM]: z5.object({
+    type: z5.literal(RequestType.UPDATE_QUORUM),
+    data: zUpdateQuorumRequestData
+  }),
+  // Transactions
+  [RequestType.CREATE_TRANSACTION]: z5.object({
+    type: z5.literal(RequestType.CREATE_TRANSACTION),
+    data: zCreateTransactionRequestData,
+    meta: z5.object({
+      hash: z5.string().nullable()
+    }).optional().nullable()
+  }),
+  // Accounts
+  [RequestType.CREATE_ACCOUNT]: z5.object({
+    type: z5.literal(RequestType.CREATE_ACCOUNT),
+    data: zCreateAccountRequestData
+  }),
+  [RequestType.EDIT_ACCOUNT]: z5.object({
+    type: z5.literal(RequestType.EDIT_ACCOUNT),
+    data: zEditAccountRequestData
+  }),
+  [RequestType.ACTIVATE_TRADELINK_ACCOUNT]: z5.object({
+    type: z5.literal(RequestType.ACTIVATE_TRADELINK_ACCOUNT),
+    targetId: z5.string(),
+    data: zActivateAccountRequestData
+  }),
+  [RequestType.EDIT_TOKEN_RULE]: z5.object({
+    type: z5.literal(RequestType.EDIT_TOKEN_RULE),
+    targetId: z5.string(),
+    data: zEditTokenRuleRequestData
+  }),
+  // Groups
+  [RequestType.CREATE_GROUP]: z5.object({
+    type: z5.literal(RequestType.CREATE_GROUP),
+    data: zCreateGroupRequestData
+  }),
+  [RequestType.EDIT_GROUP]: z5.object({
+    type: z5.literal(RequestType.EDIT_GROUP),
+    data: zEditGroupRequestData
+  }),
+  [RequestType.REVOKE_GROUP]: z5.object({
+    type: z5.literal(RequestType.REVOKE_GROUP),
+    data: z5.object({})
+  }),
+  // Whitelists
+  [RequestType.CREATE_WHITELIST]: z5.object({
+    type: z5.literal(RequestType.CREATE_WHITELIST),
+    data: zCreateWhitelistRequestData
+  }),
+  [RequestType.EDIT_WHITELIST]: z5.object({
+    type: z5.literal(RequestType.EDIT_WHITELIST),
+    data: zEditWhitelistRequestData
+  }),
+  // Entities
+  [RequestType.CREATE_ENTITY]: z5.object({
+    type: z5.literal(RequestType.CREATE_ENTITY),
+    data: zCreateEntityRequestData
+  }),
+  [RequestType.EDIT_ENTITY]: z5.object({
+    type: z5.literal(RequestType.EDIT_ENTITY),
+    data: zEditEntityRequestData
+  }),
+  [RequestType.REVOKE_ENTITY]: z5.object({
+    type: z5.literal(RequestType.REVOKE_ENTITY),
+    data: z5.object({})
+  }),
+  // Users
+  ...zUserCreationVaultRequestMixinsByType,
+  [RequestType.CREATE_API_USER]: z5.object({
+    type: z5.literal(RequestType.CREATE_API_USER),
+    data: zCreateApiUserRequestData
+  }),
+  [RequestType.CREATE_API_USER_ACCESS]: z5.object({
+    type: z5.literal(RequestType.CREATE_API_USER_ACCESS),
+    data: zCreateApiUserAccessRequestData
+  }),
+  [RequestType.REVOKE_USER]: z5.object({
+    type: z5.literal(RequestType.REVOKE_USER),
+    data: z5.object({})
+  }),
+  // Admin gov rules
+  [RequestType.CREATE_WORKSPACE_RULE]: z5.object({
+    type: z5.literal(RequestType.CREATE_WORKSPACE_RULE),
+    data: zWorkspaceRuleRequestData
+  }),
+  [RequestType.EDIT_WORKSPACE_RULE]: z5.object({
+    type: z5.literal(RequestType.EDIT_WORKSPACE_RULE),
+    data: zWorkspaceRuleRequestData
+  }),
+  // SCI configs
+  [RequestType.CREATE_SCICONFIG]: z5.object({
+    type: z5.literal(RequestType.CREATE_SCICONFIG),
+    data: zCreateSciConfigRequestData
+  }),
+  [RequestType.EDIT_SCICONFIG]: z5.object({
+    type: z5.literal(RequestType.EDIT_SCICONFIG),
+    data: zEditSciConfigRequestData
+  }),
+  // API keys
+  [RequestType.CREATE_API_KEY]: z5.object({
+    type: z5.literal(RequestType.CREATE_API_KEY),
+    data: zCreateApiKeyRequestData
+  }),
+  [RequestType.EDIT_API_KEY]: z5.object({
+    type: z5.literal(RequestType.EDIT_API_KEY),
+    data: zEditApiKeyRequestData
+  }),
+  [RequestType.REVOKE_API_KEY]: z5.object({
+    type: z5.literal(RequestType.REVOKE_API_KEY),
+    data: z5.object({})
+  }),
+  // Policies
+  [RequestType.CREATE_POLICY]: z5.object({
+    type: z5.literal(RequestType.CREATE_POLICY),
+    data: zCreatePolicyRequestData
+  }),
+  [RequestType.EDIT_POLICY]: z5.object({
+    type: z5.literal(RequestType.EDIT_POLICY),
+    data: zEditPolicyRequestData
+  }),
+  // Tradelink
+  [RequestType.CREATE_TRADELINK_CUSTODIAN]: z5.object({
+    type: z5.literal(RequestType.CREATE_TRADELINK_CUSTODIAN),
+    data: zCustodianRequestData
+  }),
+  [RequestType.EDIT_TRADELINK_CUSTODIAN]: z5.object({
+    type: z5.literal(RequestType.EDIT_TRADELINK_CUSTODIAN),
+    targetId: z5.string(),
+    data: zCustodianRequestData
+  }),
+  [RequestType.CREATE_TRADELINK_EXCHANGE]: z5.object({
+    type: z5.literal(RequestType.CREATE_TRADELINK_EXCHANGE),
+    data: zTradelinkEntityRequestData
+  }),
+  [RequestType.EDIT_TRADELINK_EXCHANGE]: z5.object({
+    type: z5.literal(RequestType.EDIT_TRADELINK_EXCHANGE),
+    targetId: z5.string(),
+    data: zTradelinkEntityRequestData
+  }),
+  [RequestType.CREATE_TRADELINK_ASSET_MANAGER]: z5.object({
+    type: z5.literal(RequestType.CREATE_TRADELINK_ASSET_MANAGER),
+    data: zTradelinkEntityRequestData
+  }),
+  [RequestType.EDIT_TRADELINK_ASSET_MANAGER]: z5.object({
+    type: z5.literal(RequestType.EDIT_TRADELINK_ASSET_MANAGER),
+    targetId: z5.string(),
+    data: zTradelinkEntityRequestData
+  }),
+  [RequestType.ADJUST_PLEDGE]: z5.object({
+    type: z5.literal(RequestType.ADJUST_PLEDGE),
+    data: zAdjustPledgeRequestData
+  }),
+  [RequestType.CREATE_SETTLEMENT]: z5.object({
+    type: z5.literal(RequestType.CREATE_SETTLEMENT),
+    data: zCreateSettlementRequestData
+  }),
+  [RequestType.FORCE_UNPLEDGE]: z5.object({
+    type: z5.literal(RequestType.FORCE_UNPLEDGE),
+    data: zForceUnpledgeRequestData
+  }),
+  [RequestType.TRADELINK_WITHDRAW]: z5.object({
+    type: z5.literal(RequestType.TRADELINK_WITHDRAW),
+    data: zTradelinkWithdrawRequestData
+  }),
+  // Deprecate ADMIN_GOV_RULE
+  [RequestType.CREATE_ADMIN_GOV_RULE]: z5.object({
+    type: z5.literal(RequestType.CREATE_ADMIN_GOV_RULE),
+    data: z5.object({}).describe("Deprecated")
+  }),
+  [RequestType.EDIT_ADMIN_GOV_RULE]: z5.object({
+    type: z5.literal(RequestType.EDIT_ADMIN_GOV_RULE),
+    data: z5.object({}).describe("Deprecated")
+  })
+};
+
+// src/requests/app-types.ts
+var zRequestReviewResponse = z5.object({
+  // Note: Do NOT include `quorum` as it is already available in the request's `reviewSteps` field.
+  stepIndex: z5.number().int().describe("Index of the governance step in the request workflow"),
+  userId: z5.string().describe("Reviewer id"),
+  status: z5.nativeEnum(RequestReviewStatus).describe("Review status"),
+  createdAt: z5.coerce.date().describe("Created date"),
+  updatedAt: z5.coerce.date().describe("Updated date")
+});
+var zVaultRequestCommonMixin = z5.object({
+  id: z5.string().describe("Request unique identifier"),
+  legacyId: z5.number().describe("Legacy internal unique identifier (for retro-compatibility)"),
+  state: z5.nativeEnum(RequestState).describe("Request state"),
+  reviewSteps: zRequestReviewSteps.describe("Request review steps"),
+  currentStepIndex: z5.number().int().min(0).describe("Index of the current approval step"),
+  expiredAt: z5.coerce.date().nullable().describe("Optional expiration date"),
+  targetId: z5.string().nullable().describe("Optional ID of the target object"),
+  note: zNote.nullable().describe("Optional request note"),
+  reviews: z5.array(zRequestReviewResponse).describe("Requests reviews"),
+  // `type` and `data` are correlated -- See `zVaultRequestMixinsByType`
+  createdAt: z5.coerce.date().describe("Creation timestamp"),
+  updatedAt: z5.coerce.date().describe("Last modification timestamp")
+});
+var allowedRequestCreationInput = {
+  [RequestType.CREATE_ADMIN]: zVaultRequestMixinsByType[RequestType.CREATE_ADMIN],
+  [RequestType.CREATE_GROUP]: zVaultRequestMixinsByType[RequestType.CREATE_GROUP],
+  [RequestType.CREATE_WHITELIST]: zVaultRequestMixinsByType[RequestType.CREATE_WHITELIST],
+  [RequestType.EDIT_WHITELIST]: zVaultRequestMixinsByType[RequestType.EDIT_WHITELIST],
+  [RequestType.CREATE_OPERATOR]: zVaultRequestMixinsByType[RequestType.CREATE_OPERATOR],
+  [RequestType.CREATE_TRANSACTION]: zVaultRequestMixinsByType[RequestType.CREATE_TRANSACTION],
+  [RequestType.CREATE_POLICY]: zVaultRequestMixinsByType[RequestType.CREATE_POLICY],
+  [RequestType.EDIT_POLICY]: zVaultRequestMixinsByType[RequestType.EDIT_POLICY],
+  [RequestType.CREATE_ACCOUNT]: z5.object({
+    type: z5.literal(RequestType.CREATE_ACCOUNT),
+    data: zCreateAccountUserInputData
+  }),
+  [RequestType.ACTIVATE_TRADELINK_ACCOUNT]: zVaultRequestMixinsByType[RequestType.ACTIVATE_TRADELINK_ACCOUNT],
+  [RequestType.CREATE_TRADELINK_CUSTODIAN]: zVaultRequestMixinsByType[RequestType.CREATE_TRADELINK_CUSTODIAN],
+  [RequestType.EDIT_TRADELINK_CUSTODIAN]: zVaultRequestMixinsByType[RequestType.EDIT_TRADELINK_CUSTODIAN],
+  [RequestType.CREATE_TRADELINK_EXCHANGE]: zVaultRequestMixinsByType[RequestType.CREATE_TRADELINK_EXCHANGE],
+  [RequestType.EDIT_TRADELINK_EXCHANGE]: zVaultRequestMixinsByType[RequestType.EDIT_TRADELINK_EXCHANGE],
+  [RequestType.CREATE_TRADELINK_ASSET_MANAGER]: zVaultRequestMixinsByType[RequestType.CREATE_TRADELINK_ASSET_MANAGER],
+  [RequestType.EDIT_TRADELINK_ASSET_MANAGER]: zVaultRequestMixinsByType[RequestType.EDIT_TRADELINK_ASSET_MANAGER],
+  [RequestType.ADJUST_PLEDGE]: zVaultRequestMixinsByType[RequestType.ADJUST_PLEDGE],
+  [RequestType.FORCE_UNPLEDGE]: zVaultRequestMixinsByType[RequestType.FORCE_UNPLEDGE],
+  [RequestType.CREATE_SETTLEMENT]: zVaultRequestMixinsByType[RequestType.CREATE_SETTLEMENT],
+  [RequestType.TRADELINK_WITHDRAW]: zVaultRequestMixinsByType[RequestType.TRADELINK_WITHDRAW]
+};
+z5.object({
+  request: z5.discriminatedUnion(
+    "type",
+    ensureNonEmptyArray(
+      Object.values(allowedRequestCreationInput).map((_) => {
+        const requestType = _.shape.type._def.value;
+        return _.describe(`${requestType} request data`);
+      })
+    )
+  )
+});
+var zVaultRequestResponse = z5.discriminatedUnion(
+  "type",
+  ensureNonEmptyArray(
+    Object.values(zVaultRequestMixinsByType).map((_) => {
+      const requestType = _.shape.type._def.value;
+      return _.merge(zVaultRequestCommonMixin).describe(`${requestType} request`);
+    })
+  )
+);
+z5.discriminatedUnion(
+  "type",
+  ensureNonEmptyArray(
+    Object.values(zUserCreationVaultRequestMixinsByType).map((_) => {
+      const requestType = _.shape.type._def.value;
+      return _.merge(zVaultRequestCommonMixin).describe(`${requestType} request`);
+    })
+  )
+);
+z5.enum([
+  "state",
+  "expiredAt",
+  "createdAt",
+  "updatedAt"
+]).default("createdAt");
+z5.object({
+  pubKey: z5.string().describe("Public key of the current user"),
+  challenge: zUserChallenge.describe("Challenge data to sign with the user's private key")
+});
+var shouldHaveTargetHsmId = (request) => {
+  switch (request.type) {
+    case RequestType.CREATE_ENTITY:
+    case RequestType.EDIT_ENTITY:
+    case RequestType.REVOKE_ENTITY:
+    case RequestType.CREATE_SCICONFIG:
+    case RequestType.EDIT_SCICONFIG:
+    case RequestType.CREATE_API_KEY:
+    case RequestType.EDIT_API_KEY:
+    case RequestType.REVOKE_API_KEY:
+    case RequestType.CREATE_WORKSPACE_RULE:
+    case RequestType.EDIT_WORKSPACE_RULE:
+      return false;
+    case RequestType.CREATE_ADMIN:
+    case RequestType.CREATE_OPERATOR:
+      if (request.state === RequestState.INITIAL || request.state === RequestState.PENDING_REGISTRATION) {
+        return false;
+      }
+      if (request.state === RequestState.ABORTED || request.state === RequestState.BLOCKED || request.state === RequestState.EXPIRED) {
+        return void 0;
+      }
+      return true;
+    case RequestType.UPDATE_QUORUM:
+    case RequestType.CREATE_TRANSACTION:
+    case RequestType.CREATE_ACCOUNT:
+    case RequestType.EDIT_ACCOUNT:
+    case RequestType.ACTIVATE_TRADELINK_ACCOUNT:
+    case RequestType.CREATE_GROUP:
+    case RequestType.EDIT_GROUP:
+    case RequestType.REVOKE_GROUP:
+    case RequestType.CREATE_WHITELIST:
+    case RequestType.EDIT_WHITELIST:
+    case RequestType.CREATE_API_USER:
+    case RequestType.CREATE_API_USER_ACCESS:
+    // targeting / editing an existing `User`
+    case RequestType.REVOKE_USER:
+    case RequestType.CREATE_POLICY:
+    case RequestType.EDIT_POLICY:
+    case RequestType.CREATE_TRADELINK_CUSTODIAN:
+    case RequestType.EDIT_TRADELINK_CUSTODIAN:
+    case RequestType.CREATE_TRADELINK_EXCHANGE:
+    case RequestType.EDIT_TRADELINK_EXCHANGE:
+    case RequestType.CREATE_TRADELINK_ASSET_MANAGER:
+    case RequestType.EDIT_TRADELINK_ASSET_MANAGER:
+      return request.state !== RequestState.INITIAL;
+    case RequestType.EDIT_TOKEN_RULE:
+      return true;
+    /* v8 ignore start */
+    case RequestType.CREATE_ADMIN_GOV_RULE:
+    case RequestType.EDIT_ADMIN_GOV_RULE:
+      throw new Error(`Admin gov rules requests are deprecated`);
+  }
+};
+var shouldHaveTargetId = (request) => {
+  switch (request.type) {
+    case RequestType.CREATE_API_KEY:
+    case RequestType.EDIT_API_KEY:
+    case RequestType.REVOKE_API_KEY:
+      return false;
+    case RequestType.CREATE_TRANSACTION:
+      return false;
+    case RequestType.CREATE_WORKSPACE_RULE:
+    case RequestType.CREATE_ACCOUNT:
+    case RequestType.CREATE_GROUP:
+    case RequestType.CREATE_WHITELIST:
+    case RequestType.CREATE_ENTITY:
+    case RequestType.CREATE_ADMIN:
+    case RequestType.CREATE_OPERATOR:
+    case RequestType.CREATE_API_USER:
+    case RequestType.CREATE_SCICONFIG:
+    case RequestType.CREATE_POLICY:
+    case RequestType.CREATE_TRADELINK_CUSTODIAN:
+    case RequestType.CREATE_TRADELINK_EXCHANGE:
+    case RequestType.CREATE_TRADELINK_ASSET_MANAGER:
+      return request.state === RequestState.EXECUTED;
+    case RequestType.UPDATE_QUORUM:
+    case RequestType.EDIT_WORKSPACE_RULE:
+    case RequestType.EDIT_ACCOUNT:
+    case RequestType.ACTIVATE_TRADELINK_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_TRADELINK_CUSTODIAN:
+    case RequestType.EDIT_TRADELINK_EXCHANGE:
+    case RequestType.EDIT_TRADELINK_ASSET_MANAGER:
+    case RequestType.ADJUST_PLEDGE:
+    case RequestType.CREATE_SETTLEMENT:
+    case RequestType.FORCE_UNPLEDGE:
+    case RequestType.TRADELINK_WITHDRAW:
+      return true;
+    /* v8 ignore start */
+    case RequestType.CREATE_ADMIN_GOV_RULE:
+    case RequestType.EDIT_ADMIN_GOV_RULE:
+      throw new Error(`Admin gov rules requests are deprecated`);
+  }
+};
+
+// src/requests/app-utils/index.ts
+function serializeVaultRequest(request) {
+  const serialized = {
+    ...request,
+    legacyId: request.gateId
+  };
+  if (request.type === "CREATE_TRANSACTION") {
+    Object.assign(serialized, {
+      meta: {
+        hash: request.transactionMeta?.hash ?? null
+      }
+    });
+  }
+  return zVaultRequestResponse.parse(serialized);
+}
+var fakeHexString = (length, casing = "upper") => faker.string.hexadecimal({ prefix: "", casing, length });
+var fakePubKey = () => fakeHexString(130);
+var fakeIntegerId = () => faker.number.int({ min: 1, max: 2e9 });
+var fakeGateId = fakeIntegerId;
+var fakeBase64String = (length) => btoa(faker.string.sample(length));
+var fakePsdSignature = () => fakeBase64String(100);
+var fakeJws = () => times(3, () => faker.string.hexadecimal({ prefix: "", length: 100 })).join(".");
+var fakeHsmObjectId = () => faker.string.uuid();
+var fakeHsmCertificate = () => ({
+  codeHash: fakeBase64String(10),
+  attestationPub: fakeBase64String(20),
+  certificate: fakeBase64String(20),
+  signature: fakeBase64String(20)
+});
+var fakePsdChallenge = () => ({
+  challengeType: "PSD",
+  wActions: [fakeBase64String(50), fakeBase64String(50), fakeBase64String(50)],
+  handshake: fakeBase64String(100),
+  handshakeAttestation: fakeHsmCertificate(),
+  partitionId: fakeBase64String(20)
+});
+var fakeWorkspaceName = () => faker.string.alpha({ length: 8, casing: "lower" });
+var injectSyncId = (obj) => {
+  let { syncId } = obj;
+  if (syncId === void 0) {
+    if (obj.gateType !== null && obj.gateId !== 0) {
+      syncId = buildGateSyncId(obj.workspaceName, obj.gateType, obj.gateId);
+    } else if (obj.gateType === null && obj.gateId === 0) {
+      syncId = faker.string.uuid();
+    } else {
+      throw new Error(`Invalid gateType and gateId: ${obj.gateType}, ${obj.gateId}`);
+    }
+  }
+  return { ...obj, syncId };
+};
+var genAssetFieldsForType = (type) => {
+  const hsmXpub = faker.string.hexadecimal({ prefix: "", casing: "upper", length: 66 });
+  const hsmChainCode = faker.string.hexadecimal({ prefix: "", casing: "upper", length: 64 });
+  switch (type) {
+    case "BITCOIN_LIKE":
+      return {
+        type,
+        currency: faker.helpers.arrayElement(["bitcoin", "bitcoin_testnet"]),
+        derivationPath: "84'/0'/0'",
+        address: null,
+        contractAddress: null,
+        xpub: faker.string.hexadecimal({ prefix: "", length: 120 }),
+        hsmXpub,
+        hsmChainCode
+      };
+    case "ETHEREUM_LIKE":
+    // fall-through...
+    case "ERC20_LIKE":
+    case "BEP20_LIKE":
+      return {
+        type,
+        currency: type === "BEP20_LIKE" ? "bsc" : faker.helpers.arrayElement(["ethereum", "ethereum_goerli"]),
+        derivationPath: "44'/60'/0'",
+        address: faker.finance.ethereumAddress(),
+        contractAddress: type === "ETHEREUM_LIKE" ? null : faker.finance.ethereumAddress(),
+        xpub: null,
+        hsmXpub,
+        hsmChainCode
+      };
+    case "CARDANO_LIKE":
+      return {
+        type,
+        currency: faker.helpers.arrayElement(["cardano"]),
+        derivationPath: "1852'/1815'/0'",
+        address: `addr${faker.string.alphanumeric({ length: 100, casing: "lower" })}`,
+        contractAddress: null,
+        xpub: null,
+        hsmXpub,
+        hsmChainCode
+      };
+    case "SOLANA_LIKE":
+      return {
+        type,
+        currency: faker.helpers.arrayElement(["solana"]),
+        derivationPath: "44'/501'/0'",
+        address: faker.string.alphanumeric({ length: 44, casing: "lower" }),
+        contractAddress: null,
+        xpub: null,
+        hsmXpub,
+        hsmChainCode: null
+      };
+    case "TEZOS_LIKE":
+      return {
+        type,
+        currency: faker.helpers.arrayElement(["tezos"]),
+        derivationPath: "44'/1729'/0'",
+        address: `tz${faker.string.alphanumeric({ length: 34, casing: "mixed" })}`,
+        contractAddress: null,
+        xpub: null,
+        hsmXpub,
+        hsmChainCode
+      };
+    case "STELLAR_LIKE":
+      return {
+        type,
+        currency: faker.helpers.arrayElement(["stellar"]),
+        derivationPath: "44'/148'/0'",
+        address: faker.string.alphanumeric({ length: 56, casing: "upper" }),
+        contractAddress: null,
+        xpub: null,
+        hsmXpub,
+        hsmChainCode
+      };
+    case "RIPPLE_LIKE":
+      return {
+        type,
+        currency: faker.helpers.arrayElement(["ripple"]),
+        derivationPath: "44'/144'/0'",
+        address: faker.string.alphanumeric({ length: 34, casing: "mixed" }),
+        contractAddress: null,
+        xpub: `xpub${faker.string.alphanumeric({ length: 107, casing: "mixed" })}`,
+        hsmXpub,
+        hsmChainCode
+      };
+    case "POLKADOT_LIKE":
+      return {
+        type,
+        currency: faker.helpers.arrayElement(["polkadot"]),
+        derivationPath: "44'/354'/0'",
+        address: faker.string.alphanumeric({ length: 48, casing: "mixed" }),
+        contractAddress: null,
+        xpub: null,
+        hsmXpub,
+        hsmChainCode: null
+      };
+    case "TRC20_LIKE":
+      return {
+        type,
+        currency: faker.helpers.arrayElement(["tron"]),
+        derivationPath: "44'/195'/0'",
+        address: faker.string.alphanumeric({ length: 34, casing: "mixed" }),
+        contractAddress: faker.string.alphanumeric({ length: 34, casing: "mixed" }),
+        xpub: null,
+        hsmXpub,
+        hsmChainCode
+      };
+    case "GENERIC_LIKE":
+      return {
+        type,
+        currency: faker.helpers.arrayElement(["cosmos"]),
+        derivationPath: "44'/118'/0'",
+        address: faker.string.alphanumeric({ length: 34, casing: "mixed" }),
+        contractAddress: null,
+        xpub: null,
+        hsmXpub,
+        hsmChainCode
+      };
+  }
+};
+var genGovernanceFieldsForType = (governanceType, {
+  accountId,
+  policyId,
+  assetManagerId
+}) => {
+  switch (governanceType) {
+    case AccountGovernanceType.CLASSIC:
+      return {
+        governanceType,
+        classicGovernanceMixin: {
+          id: faker.number.int(),
+          policyId: policyId ?? faker.string.uuid(),
+          accountId
+        },
+        tradelinkGovernanceMixin: null
+      };
+    case AccountGovernanceType.TRADELINK:
+      return {
+        governanceType,
+        classicGovernanceMixin: null,
+        tradelinkGovernanceMixin: {
+          id: faker.number.int(),
+          assetManagerId: assetManagerId ?? faker.string.uuid(),
+          accountId,
+          exchangeConfigs: [],
+          status: ActivationStatus.ACTIVE
+        }
+      };
+  }
+};
+var genAccount = (opts) => {
+  const { policyId, assetManagerId, ...rest } = opts ?? {};
+  const commonFields = {
+    id: faker.string.uuid(),
+    workspaceName: fakeWorkspaceName(),
+    name: faker.finance.accountName(),
+    hsmId: fakeHsmObjectId(),
+    status: ActivationStatus.ACTIVE,
+    index: faker.number.int({ min: 0, max: 10 }),
+    gateId: fakeGateId(),
+    gateType: GateAccountType.Account,
+    createdAt: faker.date.past(),
+    updatedAt: faker.date.past()
+  };
+  const assetFields = genAssetFieldsForType(
+    opts?.type ?? faker.helpers.arrayElement(Object.values(AccountType))
+  );
+  const governanceFields = genGovernanceFieldsForType(
+    opts?.governanceType ?? faker.helpers.arrayElement(Object.values(AccountGovernanceType)),
+    { accountId: commonFields.id, policyId, assetManagerId }
+  );
+  return injectSyncId({
+    ...commonFields,
+    ...governanceFields,
+    ...assetFields,
+    ...rest
+  });
+};
+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 }) ? fakeHsmObjectId() : null;
+  const targetId = shouldHaveTargetId({ type, state }) ? faker.string.uuid() : null;
+  return injectSyncId({
+    id: faker.string.uuid(),
+    workspaceName: fakeWorkspaceName(),
+    type,
+    state,
+    reviewSteps: genRequestReviewSteps(),
+    currentStepIndex: 0,
+    expiredAt: null,
+    targetHsmId,
+    createdById: faker.string.uuid(),
+    createdAt: faker.date.past(),
+    updatedAt: faker.date.past(),
+    note: null,
+    managedData: null,
+    data,
+    targetId,
+    gateTargetType: "Whatsoever",
+    gateTargetId: 0,
+    gateType: "Request",
+    gateId: fakeGateId(),
+    // Note: Custom properties will overwrite the default ones. It is still possible for caller
+    // to overwrite `targetId`. Thus it is not guaranteed that these values will always be
+    // consistent with `type` and `state`.
+    ...custom
+  });
+};
+var genVaultRequestReview = (opts) => {
+  const status = opts?.status ?? RequestReviewStatus.PENDING;
+  const challenge = opts?.challenge ?? fakePsdChallenge();
+  const { challengeType } = challenge;
+  let signature;
+  if (status !== RequestReviewStatus.APPROVED) {
+    signature = null;
+  } else {
+    switch (challengeType) {
+      case ChallengeType.PSD:
+        signature = fakePsdSignature();
+        break;
+      case ChallengeType.API:
+        signature = fakeJws();
+        break;
+    }
+  }
+  return {
+    id: faker.number.int(),
+    requestId: faker.string.uuid(),
+    stageName: "default",
+    // assume the simple case where there is one single stage
+    stepIndex: 0,
+    userId: faker.string.uuid(),
+    pubKey: fakePubKey(),
+    challengeType,
+    challenge,
+    signature,
+    status,
+    createdAt: faker.date.past(),
+    updatedAt: faker.date.past(),
+    ...opts
+  };
+};
+
+// src/__fakes__/responses.ts
+var genericBalanceFields = () => {
+  const total = faker.number.int();
+  const pending = faker.number.int({ min: 0, max: total / 2 });
+  return {
+    total: total.toString(),
+    pending: pending.toString()
+  };
+};
+var stakingFieldsByAccountType = {
+  BEP20_LIKE: () => null,
+  BITCOIN_LIKE: () => null,
+  CARDANO_LIKE: () => ({
+    type: "CARDANO_LIKE",
+    staking: {
+      staked: faker.number.int().toString()
+    }
+  }),
+  ERC20_LIKE: () => null,
+  ETHEREUM_LIKE: () => ({
+    type: "ETHEREUM_LIKE",
+    staking: {
+      totalStaking: faker.number.int().toString(),
+      totalRewards: faker.number.int().toString(),
+      availableRewards: faker.number.int().toString(),
+      networkApy: faker.number.float({ min: 0, max: 1 })
+    }
+  }),
+  GENERIC_LIKE: () => null,
+  POLKADOT_LIKE: () => ({
+    type: "POLKADOT_LIKE",
+    staking: {
+      info: {
+        controllerAddress: "<fake-controller-address>",
+        rewardsDestination: "<fake-rewards-destination>",
+        proxies: ["<fake-proxy>"],
+        legacyStaking: false,
+        isNominator: false
+      },
+      balances: {
+        free: faker.number.int().toString(),
+        reserved: faker.number.int().toString(),
+        frozen: faker.number.int().toString(),
+        bonded: faker.number.int().toString(),
+        available: faker.number.int().toString(),
+        unbonding: [{ amount: faker.number.int().toString(), waiting_time: "<fake-waiting-time>" }],
+        unbonded: [{ amount: faker.number.int().toString(), waiting_time: "<fake-waiting-time>" }],
+        totalUnbonding: faker.number.int().toString(),
+        totalUnbonded: faker.number.int().toString()
+      },
+      anonymousProxy: {
+        address: "<fake-anonymous-proxy-address>",
+        createdAt: faker.date.past().toISOString(),
+        isController: false,
+        isMain: false,
+        balances: {
+          free: faker.number.int().toString(),
+          reserved: faker.number.int().toString(),
+          frozen: faker.number.int().toString(),
+          bonded: faker.number.int().toString(),
+          available: faker.number.int().toString(),
+          total: faker.number.int().toString()
+        },
+        blockHeight: faker.number.int().toString(),
+        extIndex: faker.number.int().toString(),
+        index: faker.number.int().toString(),
+        kind: "<fake-kind>"
+      }
+    }
+  }),
+  RIPPLE_LIKE: () => null,
+  SOLANA_LIKE: () => ({
+    type: "SOLANA_LIKE",
+    staking: {
+      staked: faker.number.int().toString(),
+      rewards: {
+        total: faker.number.int().toString(),
+        last7: faker.number.int().toString(),
+        last30: faker.number.int().toString()
+      },
+      stakes: [
+        {
+          uid: "<fake-stake-uid>",
+          baseAccountUid: "<fake-base-account-uid>",
+          pubKey: "<fake-pub-key>",
+          validatorPubKey: "<fake-validator-pub-key>",
+          initialAmount: faker.number.int().toString(),
+          activeAmount: faker.number.int().toString(),
+          inactiveAmount: faker.number.int().toString(),
+          totalBalance: faker.number.int().toString(),
+          creationDate: faker.date.past().toISOString(),
+          activationEpoch: faker.date.past().toISOString(),
+          activationDate: faker.date.past().toISOString(),
+          deactivationEpoch: "<fake-deactivation-epoch>",
+          deactivationDate: faker.date.past().toISOString(),
+          status: "activated",
+          rentExemptReserve: faker.number.int().toString(),
+          withdrawableAmount: faker.number.int().toString(),
+          totalRewards: faker.number.int().toString(),
+          creationTxHash: "<fake-creation-tx-hash>",
+          actionsTxHashes: ["<fake-action-tx-hash>"]
+        }
+      ]
+    }
+  }),
+  STELLAR_LIKE: () => null,
+  TEZOS_LIKE: () => null,
+  TRC20_LIKE: () => null
+};
+function genVaultRequestResponse(opts, reviews = []) {
+  const request = genVaultRequest(opts);
+  const requestWithReviews = { ...request, reviews };
+  return serializeVaultRequest(requestWithReviews);
+}
+function genAccountResponse(overrides) {
+  const dbAccount = genAccount(overrides);
+  const account = serializeAccount(dbAccount);
+  const staking = stakingFieldsByAccountType[account.asset.type]();
+  Object.assign(account.asset, staking);
+  const response = {
+    ...account,
+    balance: genericBalanceFields()
+  };
+  return zAccountResponse.parse(response);
+}
+
+export { genAccountResponse, genVaultRequestResponse, genVaultRequestReview };
+//# sourceMappingURL=fakes.mjs.map
+//# sourceMappingURL=fakes.mjs.map