@ledgerhq/revault-api 1.40.0 → 1.40.1

package/lib/fakes.mjs

@@ -1,71 +1,10 @@
 import { __export } from './chunk-J5LGTIGS.mjs';
 import { faker } from '@faker-js/faker';
-import { AllowedAction, AccountType, ChallengeType, PsdModel, UserRole, UserRegistrationState, AdminPermission, RequestType, MessageType, AccountGovernanceType, ActivationStatus, WhitelistType, RequestReviewStatus, RequestState, GateAccountType } from '@prisma/client';
-import z11, { z } from 'zod';
+import { AccountType, ChallengeType, PsdModel, UserRole, UserRegistrationState, AllowedAction, AdminPermission, MessageType, RequestType, AccountGovernanceType, ActivationStatus, WhitelistType, RequestReviewStatus, RequestState, GateAccountType } from '@prisma/client';
+import { omit, times, get, isPlainObject } from 'lodash';
 import 'axios';
 import invariant from 'invariant';
-import { omit, times, get, isPlainObject } from 'lodash';
-
-var zHexString = z.string().regex(/^[0-9a-fA-F]+$/);
-var zIntString = z.string().nonempty().regex(/^(-?[1-9]\d*|0)$/);
-var zUnsignedIntString = z.string().nonempty().regex(/^([1-9]\d*|0)$/);
-var zCurrencyString = z.string().nonempty().max(40).regex(/^\w+$/).meta({ description: "Will be deprecated soon, use network instead. Currency" });
-var zNetwork = z.string().nonempty().max(40).regex(/^\w+$/).meta({ description: "Network (Same as currency for now)" });
-var zCurrency = z.object({
-  network: zNetwork,
-  contractAddress: z.string().nonempty().nullable().meta({ description: "Token contract address" })
-});
-z.string().regex(/^[\w-]+$/).nonempty();
-var zHsmObjectId = z.string().regex(/^[\w-]+$/).nonempty();
-z.codec(z.iso.datetime(), z.date(), {
-  decode: (isoString) => new Date(isoString),
-  // ISO string → Date
-  encode: (date) => date.toISOString()
-  // Date → ISO string
-});
-
-// src/types/operation.ts
-var zValueTransactionOperationType = z.enum([
-  AllowedAction.SEND,
-  AllowedAction.STAKE,
-  AllowedAction.DEPLOY_CONTRACT,
-  AllowedAction.EXECUTE_CONTRACT,
-  AllowedAction.ACTIVATE_TOKEN,
-  AllowedAction.RECEIVE
-]);
-var zValueTransactionOperation = z.object({
-  type: zValueTransactionOperationType,
-  currency: zCurrencyString,
-  recipient: z.string().nonempty(),
-  destinationTag: z.string().nonempty().optional(),
-  value: zUnsignedIntString
-});
-var zSigningOperationType = z.enum([AllowedAction.SIGN_MESSAGE, AllowedAction.SIGN_DIGESTS]);
-var zSigningOperation = z.object({
-  type: zSigningOperationType
-});
-var zClassicOperationType = z.enum([
-  AllowedAction.SEND,
-  AllowedAction.STAKE,
-  AllowedAction.DEPLOY_CONTRACT,
-  AllowedAction.EXECUTE_CONTRACT,
-  AllowedAction.SIGN_MESSAGE,
-  AllowedAction.ACTIVATE_TOKEN,
-  AllowedAction.RECEIVE
-]);
-z.enum([AllowedAction.SIGN_DIGESTS]);
-var zOperationType = z.enum([
-  ...zValueTransactionOperationType.options,
-  ...zSigningOperationType.options
-]);
-z.discriminatedUnion("type", [
-  zValueTransactionOperation,
-  zSigningOperation
-]);
-var zNote = z11.object({
-  title: z11.string().meta({ description: "Note title" }),
-  content: z11.string().meta({ description: "Note content" })
-});
+import z9, { z } from 'zod';
 
 // src/errors.ts
 var ValidationError = class extends Error {
@@ -92,319 +31,585 @@ var ensureNonEmptyArray = (values, message) => {
 function unreachable(value) {
   throw new Error(`Un-covered: ${value}`);
 }
-var NetworkFamily = omit(AccountType, ["RAW_SIGNING"]);
-var zHexDataString = z11.codec(z11.string().regex(/^(?:0x|0X)?[a-fA-F0-9]+$/), z11.string(), {
-  decode: (hex) => `0x${hex.toLowerCase().replace("0x", "")}`,
-  encode: (hex) => hex
-});
-var zCommonLiveData = z11.object({
-  id: z11.string().meta({ description: "Account internal unique identifier" }),
-  balance: z11.object({
-    total: z11.string().meta({ description: "Total balance" }),
-    pending: z11.string().meta({ description: "Pending balance" })
-  }).meta({ description: "Balance fields" })
-});
-var zCommonTransactionData = z11.object({
-  amount: zUnsignedIntString.meta({ description: "Transaction amount" }),
-  currency: zCurrencyString.meta({
-    description: "Will be deprecated soon, use Account.network. Transaction currency"
-  }),
-  // TODO: to remove, use account.network instead
-  maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
-  recipient: z11.string().nonempty().meta({ description: "Transaction recipient" })
-});
-var zFeeStrategyCustom = z11.object({
-  type: z11.enum(["SLOW", "NORMAL", "FAST", "CUSTOM"])
-});
-var zFeeStrategy = z11.object({
-  type: z11.enum(["SLOW", "NORMAL", "FAST"])
-});
-var zTransactionStatus = z11.enum(["SUCCESSFUL", "FAILED"]);
-var zCommonTransactionResponse = z11.object({
-  id: z11.string().meta({ description: "Internal unique identifier" }),
-  hash: z11.string().meta({ description: "Transaction hash" }),
-  block: z11.object({
-    height: z11.string().nullable().meta({ description: "Transaction block height" }),
-    time: z11.string().nullable().meta({ description: "Transaction block time" })
-  }),
-  status: zTransactionStatus.meta({ description: "Transaction status" }),
-  confirmations: z11.string().meta({ description: "Block confirmations" }),
-  amount: z11.string().meta({ description: "Transaction amount" }),
-  fee: z11.string().meta({ description: "Transaction fee" }),
-  senders: z11.array(z11.string()).meta({ description: "Senders (can be multiple for UTXOs-based accounts)" }),
-  recipients: z11.array(z11.string()).meta({ description: "Recipients (can be multiple for multi-output transactions)" })
-});
 
-// src/networks/bitcoin.ts
-var zBitcoinLikeAssetFields = z11.object({
-  type: z11.literal(NetworkFamily.BITCOIN_LIKE).meta({ description: "Account type" }),
-  xpub: z11.string().meta({ description: "xpub (extended public key)" })
-}).meta({ description: "Bitcoin-like" });
-var zBitcoinLikeLiveData = zCommonLiveData.extend({
-  type: z11.literal(NetworkFamily.BITCOIN_LIKE).meta({ description: "Account type" })
-}).meta({ description: "Bitcoin-like" });
-var zBitcoinLikeTransactionType = z11.enum(["BITCOIN_LIKE_SEND", "BITCOIN_LIKE_RECEIVE"]).meta({ description: "Bitcoin-like transaction type" });
-var zBitcoinLikeFeeStrategy = zFeeStrategyCustom.extend({
-  // nullish is optional + nullable, it is easier to seed rather than just optional
-  feePerByte: zUnsignedIntString.nullish().meta({ description: "Fee per byte" })
-}).meta({ description: "Bitcoin-like fee strategy" });
-var zBitcoinLikeSendData = zCommonTransactionData.extend({
-  type: z11.literal(zBitcoinLikeTransactionType.enum.BITCOIN_LIKE_SEND),
-  feeStrategy: zBitcoinLikeFeeStrategy
-}).meta({
-  description: "Bitcoin-like send data",
-  id: "BitcoinLikeSendData"
-});
-var zBitcoinLikeTransactionData = z11.discriminatedUnion("type", [zBitcoinLikeSendData]);
-var zBitcoinLikeTransactionResponse = zCommonTransactionResponse.extend({ type: zBitcoinLikeTransactionType }).meta({ description: "Bitcoin-like transaction" });
-var zCantonLikeAssetFields = z11.object({
-  type: z11.literal(NetworkFamily.CANTON_LIKE).meta({ description: "Account type" }),
-  address: z11.string().nullable().meta({ description: "Account address" })
-}).meta({ description: "Canton-like" });
-var zCantonLikeLiveData = zCommonLiveData.extend({
-  type: z11.literal(NetworkFamily.CANTON_LIKE).meta({ description: "Account type" })
-}).meta({ description: "Canton-like" });
-var zCantonLikeTransactionType = z11.enum(["CANTON_LIKE_SEND", "CANTON_LIKE_RECEIVE"]).meta({ description: "Canton-like transaction type" });
-var zCantonLikeSendData = zCommonTransactionData.extend({
-  type: z11.literal(zCantonLikeTransactionType.enum.CANTON_LIKE_SEND)
-}).meta({
-  description: "Canton-like send data",
-  id: "CantonLikeSendData"
-});
-var zCantonLikeTransactionData = z11.discriminatedUnion("type", [zCantonLikeSendData]);
-var zCantonLikeTransactionResponse = zCommonTransactionResponse.extend({ type: zCantonLikeTransactionType }).meta({ description: "Canton-like transaction" });
-var zCardanoLikeAssetFields = z11.object({
-  type: z11.literal(NetworkFamily.CARDANO_LIKE).meta({ description: "Account type" }),
-  address: z11.string().nullable().meta({ description: "Account address" })
-}).meta({ description: "Cardano-like" });
-var zCardanoLikeStakingData = z11.object({
-  staked: z11.string().meta({ description: "Staked balance" })
-}).nullable().meta({ description: "Cardano-like staking data" });
-var zCardanoLikeStakingFields = z11.object({
-  type: z11.literal(NetworkFamily.CARDANO_LIKE).meta({ description: "Account type" }),
-  staking: zCardanoLikeStakingData.optional()
-});
-var zCardanoLikeLiveData = zCommonLiveData.extend(zCardanoLikeStakingFields.shape).meta({ description: "Cardano-like" });
-var zCardanoLikeTransactionType = z11.enum([
-  "CARDANO_LIKE_SEND",
-  "CARDANO_LIKE_RECEIVE",
-  "CARDANO_LIKE_STAKING_REGISTER",
-  "CARDANO_LIKE_STAKING_DEREGISTER",
-  "CARDANO_LIKE_STAKING_DELEGATE",
-  "CARDANO_LIKE_STAKING_WITHDRAW"
-]).meta({ description: "Cardano-like transaction type" });
-var zCardanoLikeSendData = zCommonTransactionData.extend({
-  type: z11.literal(zCardanoLikeTransactionType.enum.CARDANO_LIKE_SEND),
-  feeStrategy: zFeeStrategy.meta({ description: "Cardano-like fee strategy" })
-}).meta({
-  description: "Cardano-like send data",
-  id: "CardanoSendData"
-});
-var zCardanoStakingDelegateData = z11.object({
-  type: z11.literal(zCardanoLikeTransactionType.enum.CARDANO_LIKE_STAKING_DELEGATE),
-  currency: zCurrencyString.meta({ description: "Transaction currency" }),
-  // TODO: strict literal or enum?
-  maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
-  feeStrategy: zFeeStrategy.meta({ description: "Cardano-like fee strategy" }),
-  // DELEGATE doesn't have neither amount nor recipient
-  stakePoolId: z11.string().min(1).max(100).meta({ description: "" })
-}).meta({
-  description: "Cardano-like staking delegate",
-  id: "CardanoStakingDelegateData"
-});
-var zCardanoStakingDeregisterData = z11.object({
-  type: z11.literal(zCardanoLikeTransactionType.enum.CARDANO_LIKE_STAKING_DEREGISTER),
-  currency: zCurrencyString.meta({ description: "Transaction currency" }),
-  // TODO: strict literal or enum?
-  maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
-  feeStrategy: zFeeStrategy.meta({ description: "Cardano-like fee strategy" }),
-  // DEREGISTER doesn't have a recipient
-  amount: zUnsignedIntString.meta({ description: "Amount to deregister" })
-}).meta({
-  description: "Cardano-like staking deregister data",
-  id: "CardanoStakingDeregisterData"
-});
-var zCardanoStakingRegisterData = z11.object({
-  type: z11.literal(zCardanoLikeTransactionType.enum.CARDANO_LIKE_STAKING_REGISTER),
-  currency: zCurrencyString.meta({ description: "Transaction currency" }),
-  // TODO: strict literal or enum?
-  maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
-  feeStrategy: zFeeStrategy.meta({ description: "Cardano-like fee strategy" }),
-  // REGISTER doesn't have a recipient
-  amount: zUnsignedIntString.meta({ description: "Amount to register" })
-}).meta({
-  description: "Cardano-like staking register data",
-  id: "CardanoStakingRegisterData"
-});
-var zCardanoStakingWithdrawData = z11.object({
-  type: z11.literal(zCardanoLikeTransactionType.enum.CARDANO_LIKE_STAKING_WITHDRAW),
-  currency: zCurrencyString.meta({ description: "Transaction currency" }),
-  // TODO: strict literal or enum?
-  maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
-  feeStrategy: zFeeStrategy.meta({ description: "Cardano-like fee strategy" }),
-  // WITHDRAW doesn't have a recipient
-  amount: zUnsignedIntString.meta({ description: "Amount to withdraw" })
-}).meta({
-  description: "Cardano-like staking withdraw data",
-  id: "CardanoStakingWithdrawData"
-});
-var zCardanoLikeTransactionData = z11.discriminatedUnion("type", [
-  zCardanoLikeSendData,
-  zCardanoStakingDelegateData,
-  zCardanoStakingDeregisterData,
-  zCardanoStakingRegisterData,
-  zCardanoStakingWithdrawData
-]);
-var zCardanoLikeTransactionResponse = zCommonTransactionResponse.extend({ type: zCardanoLikeTransactionType }).meta({ description: "Cardano-like transaction" });
-var zEthereumLikeAssetFields = z11.object({
-  type: z11.literal(NetworkFamily.ETHEREUM_LIKE).meta({ description: "Account type" }),
-  address: z11.string().nullable().meta({ description: "Account address" }),
-  contractAddress: z11.string().nullable().meta({
-    description: "Will be deprecated, Use contractAddress at root level instead; Token contract address"
-  }).optional()
-}).meta({ description: "Ethereum-like" });
-var zEthereumLikeStakingData = z11.object({
-  totalStaking: z11.string().meta({ description: "Total staked amount" }),
-  totalRewards: z11.string().meta({ description: "Total of rewards" }),
-  availableRewards: z11.string().meta({ description: "Available rewards" }),
-  networkApy: z11.number().meta({ description: "Network APY" })
-}).nullable().meta({ description: "Ethereum-like staking data" });
-var zEthereumLikeStakingFields = z11.object({
-  type: z11.literal(NetworkFamily.ETHEREUM_LIKE).meta({ description: "Account type" }),
-  staking: zEthereumLikeStakingData.optional()
-});
-var zEthereumLikeLiveData = zCommonLiveData.extend(zEthereumLikeStakingFields.shape).meta({ description: "Ethereum-like" });
-var zEthereumLikeEstimatedFees = z11.object({
-  type: z11.literal(NetworkFamily.ETHEREUM_LIKE),
-  baseFees: zIntString,
-  gasLimit: zIntString,
-  nonce: z11.string(),
-  priorityFees: zIntString
-}).meta({ description: "Ethereum-like fees" });
-var zEthereumLikeTransferTransactionType = z11.enum(["ETHEREUM_LIKE_SEND", "ETHEREUM_LIKE_RECEIVE"]).meta({ description: "Ethereum-like transaction type" });
-var zEthereumLikeContractTransactionType = z11.enum(["ETHEREUM_LIKE_EXECUTE_CONTRACT", "ETHEREUM_LIKE_DEPLOY_CONTRACT"]).meta({ description: "Ethereum-like transaction type" });
-var zEthereumLikeLegacyFeeStrategy = zFeeStrategyCustom.extend({
-  gasPrice: zUnsignedIntString.meta({ description: "Gas price" }),
-  gasLimit: zUnsignedIntString.meta({ description: "Gas limit" })
-}).meta({ description: "Ethereum-like legacy fee strategy" });
-var zEthereumLikeEip1559FeeStrategy = zFeeStrategyCustom.extend({
-  maxPriorityFeePerGas: zUnsignedIntString.meta({ description: "Maximum priority fee per gas" }),
-  maxFeePerGas: zUnsignedIntString.meta({ description: "Maximum fee per gas (base + priority)" }),
-  gasLimit: zUnsignedIntString.meta({ description: "Gas limit" })
-}).meta({ description: "Ethereum-like EIP-1559 fee strategy" });
-var zEthereumLikeFeeStrategy = z11.union([zEthereumLikeLegacyFeeStrategy, zEthereumLikeEip1559FeeStrategy]).meta({
-  description: "Ethereum-like fee strategy",
-  id: "EthereumLikeFeeStrategy"
-});
-var zEthereumLikeDeployContractData = zCommonTransactionData.extend({
-  type: z11.literal(zEthereumLikeContractTransactionType.enum.ETHEREUM_LIKE_DEPLOY_CONTRACT),
-  // force the recipient to be the zero address
-  recipient: z11.literal("0x0000000000000000000000000000000000000000"),
-  contractData: zHexDataString.meta({ description: "Contract data in hexadecimal format" }),
-  feeStrategy: zEthereumLikeFeeStrategy
-}).meta({
-  description: "Ethereum-like deploy contract data",
-  id: "EthereumLikeDeployContractData"
-});
-var zEthereumLikeExecuteContractData = zCommonTransactionData.extend({
-  type: z11.literal(zEthereumLikeContractTransactionType.enum.ETHEREUM_LIKE_EXECUTE_CONTRACT),
-  contractData: zHexDataString.meta({ description: "Contract call data in hexadecimal format" }),
-  feeStrategy: zEthereumLikeFeeStrategy
-}).meta({
-  description: "Ethereum-like execute contract data",
-  id: "EthereumLikeExecuteContractData"
-});
-var zEthereumLikeSendData = zCommonTransactionData.extend({
-  type: z11.literal(zEthereumLikeTransferTransactionType.enum.ETHEREUM_LIKE_SEND),
-  feeStrategy: zEthereumLikeFeeStrategy
-}).meta({
-  description: "Ethereum-like send data",
-  id: "EthereumLikeSendData"
-});
-var zEthereumLikeTransactionData = z11.discriminatedUnion("type", [
-  zEthereumLikeDeployContractData,
-  zEthereumLikeExecuteContractData,
-  zEthereumLikeSendData
-]);
-var zEthereumLikeTransferCoinFields = z11.object({
-  type: zEthereumLikeTransferTransactionType,
-  gasPrice: z11.string(),
-  gasLimit: z11.string(),
-  nonce: z11.string()
-});
-var zEthereumLikeContractCoinFields = zEthereumLikeTransferCoinFields.extend({
-  type: zEthereumLikeContractTransactionType,
-  contractData: z11.string().meta({ description: "Contract deployment or contract execution data" })
-});
-var zEthereumLikeTransferTransactionResponse = zCommonTransactionResponse.extend(zEthereumLikeTransferCoinFields.shape).meta({ description: "Ethereum-like transfer transaction" });
-var zEthereumLikeContractTransactionResponse = zCommonTransactionResponse.extend(zEthereumLikeContractCoinFields.shape).meta({ description: "Ethereum-like contract transaction" });
-var zGenericLikeAssetFields = z11.object({ type: z11.literal(NetworkFamily.GENERIC_LIKE).meta({ description: "Account type" }) }).meta({ description: "Generic-like" });
-var zGenericLikeLiveData = zCommonLiveData.extend({
-  type: z11.literal(NetworkFamily.GENERIC_LIKE).meta({ description: "Account type" })
-}).meta({ description: "Generic-like" });
-var zGenericTransactionType = z11.enum(["GENERIC_TRANSACTION"]).meta({ description: "Generic transaction type" });
-var zGenericTransactionData = z11.object({
-  type: z11.literal(zGenericTransactionType.enum.GENERIC_TRANSACTION),
-  currency: zCurrencyString.meta({ description: "Transaction currency" }),
-  rawTx: z11.string().meta({ description: "Raw tx" })
-}).meta({
-  description: "Generic transaction data",
-  id: "GenericTransactionData"
+// src/__fakes__/faker-utils.ts
+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 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 zGenericTransactionResponse = zCommonTransactionResponse.extend({ type: zGenericTransactionType }).meta({ description: "Generic transaction" });
-var zPolkadotLikeAssetFields = z11.object({
-  type: z11.literal(NetworkFamily.POLKADOT_LIKE).meta({ description: "Account type" }),
-  address: z11.string().nullable().meta({ description: "Account address" })
-}).meta({ description: "Polkadot-like" });
-var zPolkadotUnbondingAmount = z11.object({
-  amount: z11.string().meta({ description: "Amount" }),
-  waiting_time: z11.string().meta({ description: "Waiting time" })
-});
-var zPolkadotLikeStakingData = z11.object({
-  info: z11.object({
-    controllerAddress: z11.string().nullable().meta({ description: "Controller address" }),
-    rewardsDestination: z11.string().nullable().meta({ description: "Rewards destination" }),
-    proxies: z11.array(z11.string()).meta({ description: "Proxies" }),
-    legacyStaking: z11.boolean().meta({ description: "True if account uses legacy staking" }),
-    isNominator: z11.boolean().meta({ description: "True if is nominator" })
-  }),
-  balances: z11.object({
-    free: z11.string().meta({ description: "Free balance" }),
-    reserved: z11.string().meta({ description: "Reserved balance" }),
-    frozen: z11.string().meta({ description: "Frozen balance" }),
-    bonded: z11.string().meta({ description: "Bonded balance" }),
-    available: z11.string().meta({ description: "Available balance" }),
-    unbonding: z11.array(zPolkadotUnbondingAmount).meta({ description: "Unbonding balances" }),
-    unbonded: z11.array(zPolkadotUnbondingAmount).meta({ description: "Unbonded balances" }),
-    totalUnbonding: z11.string().meta({ description: "Total unbonding" }),
-    totalUnbonded: z11.string().meta({ description: "Total unbonded" })
-  }),
-  anonymousProxy: z11.object({
-    address: z11.string().meta({ description: "Address" }),
-    createdAt: z11.string().meta({ description: "Creation date" }),
-    isController: z11.boolean().meta({ description: "True if is controller" }),
-    isMain: z11.boolean().meta({ description: "True if is main" }),
-    balances: z11.object({
-      free: z11.string().meta({ description: "Anonymous proxy free balance" }),
-      reserved: z11.string().meta({ description: "Anonymous proxy reserved balance" }),
-      frozen: z11.string().meta({ description: "Anonymous proxy frozen balance" }),
-      bonded: z11.string().meta({ description: "Anonymous proxy bonded balance" }),
-      available: z11.string().meta({ description: "Anonymous proxy available balance" }),
-      total: z11.string().meta({ description: "Anonymous proxy total balance" })
-    }).nullable(),
-    blockHeight: z11.string().meta({ description: "Anonymous proxy block height" }),
-    extIndex: z11.string().meta({ description: "Ext index" }),
-    index: z11.string().meta({ description: "Index" }),
-    kind: z11.string().meta({ description: "Kind" })
-  }).nullable().meta({ description: "Anonymous proxy" })
-}).nullable().meta({ description: "Polkadot-like staking data" });
-var zPolkadotLikeStakingFields = z11.object({
-  type: z11.literal(NetworkFamily.POLKADOT_LIKE).meta({ description: "Account type" }),
-  staking: zPolkadotLikeStakingData.optional()
+var fakePsdChallenge = () => ({
+  challengeType: "PSD",
+  wActions: [fakeBase64String(50), fakeBase64String(50), fakeBase64String(50)],
+  handshake: fakeBase64String(100),
+  handshakeAttestation: fakeHsmCertificate(),
+  partitionId: fakeBase64String(20)
 });
-var zPolkadotLikeLiveData = zCommonLiveData.extend(zPolkadotLikeStakingFields.shape).meta({ description: "Polkadot-like" });
-var zPolkadotLikeTransactionType = z11.enum([
-  "POLKADOT_LIKE_SEND",
+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 };
+};
+
+// src/__fakes__/models/accounts.ts
+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":
+      return {
+        type,
+        currency: faker.helpers.arrayElement(["ethereum", "ethereum_goerli"]),
+        derivationPath: "44'/60'/0'",
+        address: faker.finance.ethereumAddress(),
+        contractAddress: null,
+        xpub: null,
+        hsmXpub,
+        hsmChainCode
+      };
+    case "CANTON_LIKE":
+      return {
+        type,
+        currency: "canton",
+        derivationPath: "44'/6767'/0'/0'/0'",
+        address: faker.string.alphanumeric({ length: 34, casing: "mixed" }),
+        contractAddress: null,
+        xpub: null,
+        hsmXpub,
+        hsmChainCode: null
+      };
+    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 "TRON_LIKE":
+      return {
+        type,
+        currency: faker.helpers.arrayElement(["tron"]),
+        derivationPath: "44'/195'/0'",
+        address: faker.string.alphanumeric({ length: 34, casing: "mixed" }),
+        contractAddress: null,
+        xpub: null,
+        hsmXpub,
+        hsmChainCode
+      };
+    case "SUI_LIKE":
+      return {
+        type,
+        currency: faker.helpers.arrayElement(["sui"]),
+        derivationPath: "44'/784'/0'",
+        address: faker.string.alphanumeric({ length: 34, casing: "mixed" }),
+        contractAddress: null,
+        xpub: null,
+        hsmXpub,
+        hsmChainCode: null
+      };
+    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
+      };
+    case "RAW_SIGNING":
+      return {
+        type,
+        currency: faker.helpers.arrayElement(["ethereum", "bitcoin"]),
+        derivationPath: "44'/118'/0'",
+        address: null,
+        contractAddress: null,
+        xpub: null,
+        hsmXpub,
+        hsmChainCode
+      };
+  }
+};
+var genGovernanceFieldsForType = (governanceType, {
+  accountId,
+  policyId,
+  assetManagerId
+}) => {
+  switch (governanceType) {
+    case AccountGovernanceType.CLASSIC:
+    case AccountGovernanceType.RAW_SIGNING:
+      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: fakeUniqueName(),
+    hsmId: fakeHsmObjectId(),
+    status: ActivationStatus.ACTIVE,
+    index: faker.number.int({ min: 0, max: 10 }),
+    gateId: fakeGateId(),
+    gateType: GateAccountType.Account,
+    lesWalletId: faker.string.uuid(),
+    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 zHexString = z.string().regex(/^[0-9a-fA-F]+$/);
+var zIntString = z.string().nonempty().regex(/^(-?[1-9]\d*|0)$/);
+var zUnsignedIntString = z.string().nonempty().regex(/^([1-9]\d*|0)$/);
+var zCurrencyString = z.string().nonempty().max(40).regex(/^\w+$/).meta({ description: "Will be deprecated soon, use network instead. Currency" });
+var zNetwork = z.string().nonempty().max(40).regex(/^\w+$/).meta({ description: "Network (Same as currency for now)" });
+var zCurrency = z.object({
+  network: zNetwork,
+  contractAddress: z.string().nonempty().nullable().meta({ description: "Token contract address" })
+});
+z.string().regex(/^[\w-]+$/).nonempty();
+var zHsmObjectId = z.string().regex(/^[\w-]+$/).nonempty();
+z.codec(z.iso.datetime(), z.date(), {
+  decode: (isoString) => new Date(isoString),
+  // ISO string → Date
+  encode: (date) => date.toISOString()
+  // Date → ISO string
+});
+var NetworkFamily = omit(AccountType, ["RAW_SIGNING"]);
+var zHexDataString = z9.codec(z9.string().regex(/^(?:0x|0X)?[a-fA-F0-9]+$/), z9.string(), {
+  decode: (hex) => `0x${hex.toLowerCase().replace("0x", "")}`,
+  encode: (hex) => hex
+});
+var zCommonLiveData = z9.object({
+  id: z9.string().meta({ description: "Account internal unique identifier" }),
+  balance: z9.object({
+    total: z9.string().meta({ description: "Total balance" }),
+    pending: z9.string().meta({ description: "Pending balance" })
+  }).meta({ description: "Balance fields" })
+});
+var zCommonTransactionData = z9.object({
+  amount: zUnsignedIntString.meta({ description: "Transaction amount" }),
+  currency: zCurrencyString.meta({
+    description: "Will be deprecated soon, use Account.network. Transaction currency"
+  }),
+  // TODO: to remove, use account.network instead
+  maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
+  recipient: z9.string().nonempty().meta({ description: "Transaction recipient" })
+});
+var zFeeStrategyCustom = z9.object({
+  type: z9.enum(["SLOW", "NORMAL", "FAST", "CUSTOM"])
+});
+var zFeeStrategy = z9.object({
+  type: z9.enum(["SLOW", "NORMAL", "FAST"])
+});
+var zTransactionStatus = z9.enum(["SUCCESSFUL", "FAILED"]);
+var zCommonTransactionResponse = z9.object({
+  id: z9.string().meta({ description: "Internal unique identifier" }),
+  hash: z9.string().meta({ description: "Transaction hash" }),
+  block: z9.object({
+    height: z9.string().nullable().meta({ description: "Transaction block height" }),
+    time: z9.string().nullable().meta({ description: "Transaction block time" })
+  }),
+  status: zTransactionStatus.meta({ description: "Transaction status" }),
+  confirmations: z9.string().meta({ description: "Block confirmations" }),
+  amount: z9.string().meta({ description: "Transaction amount" }),
+  fee: z9.string().meta({ description: "Transaction fee" }),
+  senders: z9.array(z9.string()).meta({ description: "Senders (can be multiple for UTXOs-based accounts)" }),
+  recipients: z9.array(z9.string()).meta({ description: "Recipients (can be multiple for multi-output transactions)" })
+});
+
+// src/networks/bitcoin.ts
+var zBitcoinLikeAssetFields = z9.object({
+  type: z9.literal(NetworkFamily.BITCOIN_LIKE).meta({ description: "Account type" }),
+  xpub: z9.string().meta({ description: "xpub (extended public key)" })
+}).meta({ description: "Bitcoin-like" });
+var zBitcoinLikeLiveData = zCommonLiveData.extend({
+  type: z9.literal(NetworkFamily.BITCOIN_LIKE).meta({ description: "Account type" })
+}).meta({ description: "Bitcoin-like" });
+var zBitcoinLikeTransactionType = z9.enum(["BITCOIN_LIKE_SEND", "BITCOIN_LIKE_RECEIVE"]).meta({ description: "Bitcoin-like transaction type" });
+var zBitcoinLikeFeeStrategy = zFeeStrategyCustom.extend({
+  // nullish is optional + nullable, it is easier to seed rather than just optional
+  feePerByte: zUnsignedIntString.nullish().meta({ description: "Fee per byte" })
+}).meta({ description: "Bitcoin-like fee strategy" });
+var zBitcoinLikeSendData = zCommonTransactionData.extend({
+  type: z9.literal(zBitcoinLikeTransactionType.enum.BITCOIN_LIKE_SEND),
+  feeStrategy: zBitcoinLikeFeeStrategy
+}).meta({
+  description: "Bitcoin-like send data",
+  id: "BitcoinLikeSendData"
+});
+var zBitcoinLikeTransactionData = z9.discriminatedUnion("type", [zBitcoinLikeSendData]);
+var zBitcoinLikeTransactionResponse = zCommonTransactionResponse.extend({ type: zBitcoinLikeTransactionType }).meta({ description: "Bitcoin-like transaction" });
+var zCantonLikeAssetFields = z9.object({
+  type: z9.literal(NetworkFamily.CANTON_LIKE).meta({ description: "Account type" }),
+  address: z9.string().nullable().meta({ description: "Account address" })
+}).meta({ description: "Canton-like" });
+var zCantonLikeLiveData = zCommonLiveData.extend({
+  type: z9.literal(NetworkFamily.CANTON_LIKE).meta({ description: "Account type" })
+}).meta({ description: "Canton-like" });
+var zCantonLikeTransactionType = z9.enum(["CANTON_LIKE_SEND", "CANTON_LIKE_RECEIVE"]).meta({ description: "Canton-like transaction type" });
+var zCantonLikeSendData = zCommonTransactionData.extend({
+  type: z9.literal(zCantonLikeTransactionType.enum.CANTON_LIKE_SEND)
+}).meta({
+  description: "Canton-like send data",
+  id: "CantonLikeSendData"
+});
+var zCantonLikeTransactionData = z9.discriminatedUnion("type", [zCantonLikeSendData]);
+var zCantonLikeTransactionResponse = zCommonTransactionResponse.extend({ type: zCantonLikeTransactionType }).meta({ description: "Canton-like transaction" });
+var zCardanoLikeAssetFields = z9.object({
+  type: z9.literal(NetworkFamily.CARDANO_LIKE).meta({ description: "Account type" }),
+  address: z9.string().nullable().meta({ description: "Account address" })
+}).meta({ description: "Cardano-like" });
+var zCardanoLikeStakingData = z9.object({
+  staked: z9.string().meta({ description: "Staked balance" })
+}).nullable().meta({ description: "Cardano-like staking data" });
+var zCardanoLikeStakingFields = z9.object({
+  type: z9.literal(NetworkFamily.CARDANO_LIKE).meta({ description: "Account type" }),
+  staking: zCardanoLikeStakingData.optional()
+});
+var zCardanoLikeLiveData = zCommonLiveData.extend(zCardanoLikeStakingFields.shape).meta({ description: "Cardano-like" });
+var zCardanoLikeTransactionType = z9.enum([
+  "CARDANO_LIKE_SEND",
+  "CARDANO_LIKE_RECEIVE",
+  "CARDANO_LIKE_STAKING_REGISTER",
+  "CARDANO_LIKE_STAKING_DEREGISTER",
+  "CARDANO_LIKE_STAKING_DELEGATE",
+  "CARDANO_LIKE_STAKING_WITHDRAW"
+]).meta({ description: "Cardano-like transaction type" });
+var zCardanoLikeSendData = zCommonTransactionData.extend({
+  type: z9.literal(zCardanoLikeTransactionType.enum.CARDANO_LIKE_SEND),
+  feeStrategy: zFeeStrategy.meta({ description: "Cardano-like fee strategy" })
+}).meta({
+  description: "Cardano-like send data",
+  id: "CardanoSendData"
+});
+var zCardanoStakingDelegateData = z9.object({
+  type: z9.literal(zCardanoLikeTransactionType.enum.CARDANO_LIKE_STAKING_DELEGATE),
+  currency: zCurrencyString.meta({ description: "Transaction currency" }),
+  // TODO: strict literal or enum?
+  maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
+  feeStrategy: zFeeStrategy.meta({ description: "Cardano-like fee strategy" }),
+  // DELEGATE doesn't have neither amount nor recipient
+  stakePoolId: z9.string().min(1).max(100).meta({ description: "" })
+}).meta({
+  description: "Cardano-like staking delegate",
+  id: "CardanoStakingDelegateData"
+});
+var zCardanoStakingDeregisterData = z9.object({
+  type: z9.literal(zCardanoLikeTransactionType.enum.CARDANO_LIKE_STAKING_DEREGISTER),
+  currency: zCurrencyString.meta({ description: "Transaction currency" }),
+  // TODO: strict literal or enum?
+  maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
+  feeStrategy: zFeeStrategy.meta({ description: "Cardano-like fee strategy" }),
+  // DEREGISTER doesn't have a recipient
+  amount: zUnsignedIntString.meta({ description: "Amount to deregister" })
+}).meta({
+  description: "Cardano-like staking deregister data",
+  id: "CardanoStakingDeregisterData"
+});
+var zCardanoStakingRegisterData = z9.object({
+  type: z9.literal(zCardanoLikeTransactionType.enum.CARDANO_LIKE_STAKING_REGISTER),
+  currency: zCurrencyString.meta({ description: "Transaction currency" }),
+  // TODO: strict literal or enum?
+  maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
+  feeStrategy: zFeeStrategy.meta({ description: "Cardano-like fee strategy" }),
+  // REGISTER doesn't have a recipient
+  amount: zUnsignedIntString.meta({ description: "Amount to register" })
+}).meta({
+  description: "Cardano-like staking register data",
+  id: "CardanoStakingRegisterData"
+});
+var zCardanoStakingWithdrawData = z9.object({
+  type: z9.literal(zCardanoLikeTransactionType.enum.CARDANO_LIKE_STAKING_WITHDRAW),
+  currency: zCurrencyString.meta({ description: "Transaction currency" }),
+  // TODO: strict literal or enum?
+  maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
+  feeStrategy: zFeeStrategy.meta({ description: "Cardano-like fee strategy" }),
+  // WITHDRAW doesn't have a recipient
+  amount: zUnsignedIntString.meta({ description: "Amount to withdraw" })
+}).meta({
+  description: "Cardano-like staking withdraw data",
+  id: "CardanoStakingWithdrawData"
+});
+var zCardanoLikeTransactionData = z9.discriminatedUnion("type", [
+  zCardanoLikeSendData,
+  zCardanoStakingDelegateData,
+  zCardanoStakingDeregisterData,
+  zCardanoStakingRegisterData,
+  zCardanoStakingWithdrawData
+]);
+var zCardanoLikeTransactionResponse = zCommonTransactionResponse.extend({ type: zCardanoLikeTransactionType }).meta({ description: "Cardano-like transaction" });
+var zEthereumLikeAssetFields = z9.object({
+  type: z9.literal(NetworkFamily.ETHEREUM_LIKE).meta({ description: "Account type" }),
+  address: z9.string().nullable().meta({ description: "Account address" }),
+  contractAddress: z9.string().nullable().meta({
+    description: "Will be deprecated, Use contractAddress at root level instead; Token contract address"
+  }).optional()
+}).meta({ description: "Ethereum-like" });
+var zEthereumLikeStakingData = z9.object({
+  totalStaking: z9.string().meta({ description: "Total staked amount" }),
+  totalRewards: z9.string().meta({ description: "Total of rewards" }),
+  availableRewards: z9.string().meta({ description: "Available rewards" }),
+  networkApy: z9.number().meta({ description: "Network APY" })
+}).nullable().meta({ description: "Ethereum-like staking data" });
+var zEthereumLikeStakingFields = z9.object({
+  type: z9.literal(NetworkFamily.ETHEREUM_LIKE).meta({ description: "Account type" }),
+  staking: zEthereumLikeStakingData.optional()
+});
+var zEthereumLikeLiveData = zCommonLiveData.extend(zEthereumLikeStakingFields.shape).meta({ description: "Ethereum-like" });
+var zEthereumLikeEstimatedFees = z9.object({
+  type: z9.literal(NetworkFamily.ETHEREUM_LIKE),
+  baseFees: zIntString,
+  gasLimit: zIntString,
+  nonce: z9.string(),
+  priorityFees: zIntString
+}).meta({ description: "Ethereum-like fees" });
+var zEthereumLikeTransferTransactionType = z9.enum(["ETHEREUM_LIKE_SEND", "ETHEREUM_LIKE_RECEIVE"]).meta({ description: "Ethereum-like transaction type" });
+var zEthereumLikeContractTransactionType = z9.enum(["ETHEREUM_LIKE_EXECUTE_CONTRACT", "ETHEREUM_LIKE_DEPLOY_CONTRACT"]).meta({ description: "Ethereum-like transaction type" });
+var zEthereumLikeLegacyFeeStrategy = zFeeStrategyCustom.extend({
+  gasPrice: zUnsignedIntString.meta({ description: "Gas price" }),
+  gasLimit: zUnsignedIntString.meta({ description: "Gas limit" })
+}).meta({ description: "Ethereum-like legacy fee strategy" });
+var zEthereumLikeEip1559FeeStrategy = zFeeStrategyCustom.extend({
+  maxPriorityFeePerGas: zUnsignedIntString.meta({ description: "Maximum priority fee per gas" }),
+  maxFeePerGas: zUnsignedIntString.meta({ description: "Maximum fee per gas (base + priority)" }),
+  gasLimit: zUnsignedIntString.meta({ description: "Gas limit" })
+}).meta({ description: "Ethereum-like EIP-1559 fee strategy" });
+var zEthereumLikeFeeStrategy = z9.union([zEthereumLikeLegacyFeeStrategy, zEthereumLikeEip1559FeeStrategy]).meta({
+  description: "Ethereum-like fee strategy",
+  id: "EthereumLikeFeeStrategy"
+});
+var zEthereumLikeDeployContractData = zCommonTransactionData.extend({
+  type: z9.literal(zEthereumLikeContractTransactionType.enum.ETHEREUM_LIKE_DEPLOY_CONTRACT),
+  // force the recipient to be the zero address
+  recipient: z9.literal("0x0000000000000000000000000000000000000000"),
+  contractData: zHexDataString.meta({ description: "Contract data in hexadecimal format" }),
+  feeStrategy: zEthereumLikeFeeStrategy
+}).meta({
+  description: "Ethereum-like deploy contract data",
+  id: "EthereumLikeDeployContractData"
+});
+var zEthereumLikeExecuteContractData = zCommonTransactionData.extend({
+  type: z9.literal(zEthereumLikeContractTransactionType.enum.ETHEREUM_LIKE_EXECUTE_CONTRACT),
+  contractData: zHexDataString.meta({ description: "Contract call data in hexadecimal format" }),
+  feeStrategy: zEthereumLikeFeeStrategy
+}).meta({
+  description: "Ethereum-like execute contract data",
+  id: "EthereumLikeExecuteContractData"
+});
+var zEthereumLikeSendData = zCommonTransactionData.extend({
+  type: z9.literal(zEthereumLikeTransferTransactionType.enum.ETHEREUM_LIKE_SEND),
+  feeStrategy: zEthereumLikeFeeStrategy
+}).meta({
+  description: "Ethereum-like send data",
+  id: "EthereumLikeSendData"
+});
+var zEthereumLikeTransactionData = z9.discriminatedUnion("type", [
+  zEthereumLikeDeployContractData,
+  zEthereumLikeExecuteContractData,
+  zEthereumLikeSendData
+]);
+var zEthereumLikeTransferCoinFields = z9.object({
+  type: zEthereumLikeTransferTransactionType,
+  gasPrice: z9.string(),
+  gasLimit: z9.string(),
+  nonce: z9.string()
+});
+var zEthereumLikeContractCoinFields = zEthereumLikeTransferCoinFields.extend({
+  type: zEthereumLikeContractTransactionType,
+  contractData: z9.string().meta({ description: "Contract deployment or contract execution data" })
+});
+var zEthereumLikeTransferTransactionResponse = zCommonTransactionResponse.extend(zEthereumLikeTransferCoinFields.shape).meta({ description: "Ethereum-like transfer transaction" });
+var zEthereumLikeContractTransactionResponse = zCommonTransactionResponse.extend(zEthereumLikeContractCoinFields.shape).meta({ description: "Ethereum-like contract transaction" });
+var zGenericLikeAssetFields = z9.object({ type: z9.literal(NetworkFamily.GENERIC_LIKE).meta({ description: "Account type" }) }).meta({ description: "Generic-like" });
+var zGenericLikeLiveData = zCommonLiveData.extend({
+  type: z9.literal(NetworkFamily.GENERIC_LIKE).meta({ description: "Account type" })
+}).meta({ description: "Generic-like" });
+var zGenericTransactionType = z9.enum(["GENERIC_TRANSACTION"]).meta({ description: "Generic transaction type" });
+var zGenericTransactionData = z9.object({
+  type: z9.literal(zGenericTransactionType.enum.GENERIC_TRANSACTION),
+  currency: zCurrencyString.meta({ description: "Transaction currency" }),
+  rawTx: z9.string().meta({ description: "Raw tx" })
+}).meta({
+  description: "Generic transaction data",
+  id: "GenericTransactionData"
+});
+var zGenericTransactionResponse = zCommonTransactionResponse.extend({ type: zGenericTransactionType }).meta({ description: "Generic transaction" });
+var zPolkadotLikeAssetFields = z9.object({
+  type: z9.literal(NetworkFamily.POLKADOT_LIKE).meta({ description: "Account type" }),
+  address: z9.string().nullable().meta({ description: "Account address" })
+}).meta({ description: "Polkadot-like" });
+var zPolkadotUnbondingAmount = z9.object({
+  amount: z9.string().meta({ description: "Amount" }),
+  waiting_time: z9.string().meta({ description: "Waiting time" })
+});
+var zPolkadotLikeStakingData = z9.object({
+  info: z9.object({
+    controllerAddress: z9.string().nullable().meta({ description: "Controller address" }),
+    rewardsDestination: z9.string().nullable().meta({ description: "Rewards destination" }),
+    proxies: z9.array(z9.string()).meta({ description: "Proxies" }),
+    legacyStaking: z9.boolean().meta({ description: "True if account uses legacy staking" }),
+    isNominator: z9.boolean().meta({ description: "True if is nominator" })
+  }),
+  balances: z9.object({
+    free: z9.string().meta({ description: "Free balance" }),
+    reserved: z9.string().meta({ description: "Reserved balance" }),
+    frozen: z9.string().meta({ description: "Frozen balance" }),
+    bonded: z9.string().meta({ description: "Bonded balance" }),
+    available: z9.string().meta({ description: "Available balance" }),
+    unbonding: z9.array(zPolkadotUnbondingAmount).meta({ description: "Unbonding balances" }),
+    unbonded: z9.array(zPolkadotUnbondingAmount).meta({ description: "Unbonded balances" }),
+    totalUnbonding: z9.string().meta({ description: "Total unbonding" }),
+    totalUnbonded: z9.string().meta({ description: "Total unbonded" })
+  }),
+  anonymousProxy: z9.object({
+    address: z9.string().meta({ description: "Address" }),
+    createdAt: z9.string().meta({ description: "Creation date" }),
+    isController: z9.boolean().meta({ description: "True if is controller" }),
+    isMain: z9.boolean().meta({ description: "True if is main" }),
+    balances: z9.object({
+      free: z9.string().meta({ description: "Anonymous proxy free balance" }),
+      reserved: z9.string().meta({ description: "Anonymous proxy reserved balance" }),
+      frozen: z9.string().meta({ description: "Anonymous proxy frozen balance" }),
+      bonded: z9.string().meta({ description: "Anonymous proxy bonded balance" }),
+      available: z9.string().meta({ description: "Anonymous proxy available balance" }),
+      total: z9.string().meta({ description: "Anonymous proxy total balance" })
+    }).nullable(),
+    blockHeight: z9.string().meta({ description: "Anonymous proxy block height" }),
+    extIndex: z9.string().meta({ description: "Ext index" }),
+    index: z9.string().meta({ description: "Index" }),
+    kind: z9.string().meta({ description: "Kind" })
+  }).nullable().meta({ description: "Anonymous proxy" })
+}).nullable().meta({ description: "Polkadot-like staking data" });
+var zPolkadotLikeStakingFields = z9.object({
+  type: z9.literal(NetworkFamily.POLKADOT_LIKE).meta({ description: "Account type" }),
+  staking: zPolkadotLikeStakingData.optional()
+});
+var zPolkadotLikeLiveData = zCommonLiveData.extend(zPolkadotLikeStakingFields.shape).meta({ description: "Polkadot-like" });
+var zPolkadotLikeTransactionType = z9.enum([
+  "POLKADOT_LIKE_SEND",
   "POLKADOT_LIKE_RECEIVE",
   "POLKADOT_LIKE_ADDPROXY",
   "POLKADOT_LIKE_REMOVEPROXY",
@@ -425,25 +630,25 @@ var zPolkadotLikeTransactionType = z11.enum([
   "POLKADOT_LIKE_CHILL",
   "POLKADOT_LIKE_TRANSFERALL"
 ]).meta({ description: "Polkadot-like transaction type" });
-var zPolkadotRewardDestination = z11.enum(["Staked", "Stash"]);
-var zPolkadotLikeAddProxyData = z11.object({
-  type: z11.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_ADDPROXY),
+var zPolkadotRewardDestination = z9.enum(["Staked", "Stash"]);
+var zPolkadotLikeAddProxyData = z9.object({
+  type: z9.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_ADDPROXY),
   currency: zCurrencyString.meta({ description: "Transaction currency" }),
-  kind: z11.literal("Staking").meta({ description: "Proxy kind" }),
-  proxy: z11.string().meta({ description: "Proxy address" })
+  kind: z9.literal("Staking").meta({ description: "Proxy kind" }),
+  proxy: z9.string().meta({ description: "Proxy address" })
 }).meta({
   description: "Polkadot-like add proxy data",
   id: "PolkadotLikeAddProxyData"
 });
-var zPolkadotLikeAnonymousProxyData = z11.object({
-  type: z11.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_ANONYMOUSPROXY),
+var zPolkadotLikeAnonymousProxyData = z9.object({
+  type: z9.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_ANONYMOUSPROXY),
   currency: zCurrencyString.meta({ description: "Transaction currency" })
 }).meta({
   description: "Polkadot-like anonymous proxy data",
   id: "PolkadotLikeAnonymousProxyData"
 });
-var zPolkadotLikeBondData = z11.object({
-  type: z11.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_BOND),
+var zPolkadotLikeBondData = z9.object({
+  type: z9.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_BOND),
   currency: zCurrencyString.meta({ description: "Transaction currency" }),
   payee: zPolkadotRewardDestination,
   amount: zUnsignedIntString.meta({ description: "Amount" })
@@ -451,75 +656,75 @@ var zPolkadotLikeBondData = z11.object({
   description: "Polkadot-like bond data",
   id: "PolkadotLikeBondData"
 });
-var zPolkadotLikeBondExtraData = z11.object({
-  type: z11.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_BONDEXTRA),
+var zPolkadotLikeBondExtraData = z9.object({
+  type: z9.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_BONDEXTRA),
   currency: zCurrencyString.meta({ description: "Transaction currency" }),
   amount: zUnsignedIntString.meta({ description: "Amount" })
 }).meta({
   description: "Polkadot-like bond extra data",
   id: "PolkadotLikeBondExtraData"
 });
-var zPolkadotLikeChillData = z11.object({
-  type: z11.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_CHILL),
+var zPolkadotLikeChillData = z9.object({
+  type: z9.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_CHILL),
   currency: zCurrencyString.meta({ description: "Transaction currency" })
 }).meta({
   description: "Polkadot-like chill data",
   id: "PolkadotLikeChillData"
 });
-var zPolkadotLikeKillAnonymousData = z11.object({
-  type: z11.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_KILLANONYMOUS),
+var zPolkadotLikeKillAnonymousData = z9.object({
+  type: z9.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_KILLANONYMOUS),
   currency: zCurrencyString.meta({ description: "Transaction currency" })
 }).meta({
   description: "Polkadot-like kill anonymous data",
   id: "PolkadotLikeKillAnonymousData"
 });
-var zPolkadotLikeRebondData = z11.object({
-  type: z11.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_REBOND),
+var zPolkadotLikeRebondData = z9.object({
+  type: z9.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_REBOND),
   currency: zCurrencyString.meta({ description: "Transaction currency" }),
   amount: zUnsignedIntString.meta({ description: "Amount" })
 }).meta({
   description: "Polkadot-like rebond data",
   id: "PolkadotLikeRebondData"
 });
-var zPolkadotLikeRemoveProxyData = z11.object({
-  type: z11.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_REMOVEPROXY),
+var zPolkadotLikeRemoveProxyData = z9.object({
+  type: z9.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_REMOVEPROXY),
   currency: zCurrencyString.meta({ description: "Transaction currency" }),
-  kind: z11.literal("Staking"),
-  proxy: z11.string().meta({ description: "Proxy address" })
+  kind: z9.literal("Staking"),
+  proxy: z9.string().meta({ description: "Proxy address" })
 }).meta({
   description: "Polkadot-like remove proxy data",
   id: "PolkadotLikeRemoveProxyData"
 });
 var zPolkadotLikeSendData = zCommonTransactionData.extend({
-  type: z11.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_SEND)
+  type: z9.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_SEND)
 }).meta({
   description: "Polkadot-like send data",
   id: "PolkadotLikeSendData"
 });
-var zPolkadotLikeSetPayeeData = z11.object({
-  type: z11.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_SETPAYEE),
+var zPolkadotLikeSetPayeeData = z9.object({
+  type: z9.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_SETPAYEE),
   currency: zCurrencyString.meta({ description: "Transaction currency" }),
   payee: zPolkadotRewardDestination
 }).meta({
   description: "Polkadot-like set payee data",
   id: "PolkadotLikeSetPayeeData"
 });
-var zPolkadotLikeUnbondData = z11.object({
-  type: z11.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_UNBOND),
+var zPolkadotLikeUnbondData = z9.object({
+  type: z9.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_UNBOND),
   currency: zCurrencyString.meta({ description: "Transaction currency" }),
   amount: zUnsignedIntString.meta({ description: "Amount" })
 }).meta({
   description: "Polkadot-like unbond data",
   id: "PolkadotLikeUnbondData"
 });
-var zPolkadotLikeWithdrawUnbondedData = z11.object({
-  type: z11.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_WITHDRAWUNBONDED),
+var zPolkadotLikeWithdrawUnbondedData = z9.object({
+  type: z9.literal(zPolkadotLikeTransactionType.enum.POLKADOT_LIKE_WITHDRAWUNBONDED),
   currency: zCurrencyString.meta({ description: "Transaction currency" })
 }).meta({
   description: "Polkadot-like withdraw unbonded data",
   id: "PolkadotLikeWithdrawUnbondedData"
 });
-var zPolkadotLikeTransactionData = z11.discriminatedUnion("type", [
+var zPolkadotLikeTransactionData = z9.discriminatedUnion("type", [
   zPolkadotLikeAddProxyData,
   zPolkadotLikeAnonymousProxyData,
   zPolkadotLikeBondData,
@@ -534,77 +739,77 @@ var zPolkadotLikeTransactionData = z11.discriminatedUnion("type", [
   zPolkadotLikeWithdrawUnbondedData
 ]);
 var zPolkadotLikeTransactionResponse = zCommonTransactionResponse.extend({ type: zPolkadotLikeTransactionType }).meta({ description: "Polkadot-like transaction" });
-var zRippleLikeAssetFields = z11.object({
-  type: z11.literal(NetworkFamily.RIPPLE_LIKE).meta({ description: "Account type" }),
-  address: z11.string().nullable().meta({ description: "Account address" })
+var zRippleLikeAssetFields = z9.object({
+  type: z9.literal(NetworkFamily.RIPPLE_LIKE).meta({ description: "Account type" }),
+  address: z9.string().nullable().meta({ description: "Account address" })
 }).meta({ description: "Ripple-like" });
 var zRippleLikeLiveData = zCommonLiveData.extend({
-  type: z11.literal(NetworkFamily.RIPPLE_LIKE).meta({ description: "Account type" })
+  type: z9.literal(NetworkFamily.RIPPLE_LIKE).meta({ description: "Account type" })
 }).meta({ description: "Ripple-like" });
-var zRippleLikeEstimatedFees = z11.object({
-  type: z11.literal(NetworkFamily.RIPPLE_LIKE),
+var zRippleLikeEstimatedFees = z9.object({
+  type: z9.literal(NetworkFamily.RIPPLE_LIKE),
   fee: zIntString
 }).meta({ description: "Ripple-like fees" });
-var zRippleLikeTransactionType = z11.enum(["RIPPLE_LIKE_SEND", "RIPPLE_LIKE_RECEIVE"]).meta({ description: "Ripple-like transaction type" });
+var zRippleLikeTransactionType = z9.enum(["RIPPLE_LIKE_SEND", "RIPPLE_LIKE_RECEIVE"]).meta({ description: "Ripple-like transaction type" });
 var zRippleLikeSendData = zCommonTransactionData.extend({
-  type: z11.literal(zRippleLikeTransactionType.enum.RIPPLE_LIKE_SEND),
+  type: z9.literal(zRippleLikeTransactionType.enum.RIPPLE_LIKE_SEND),
   destinationTag: zIntString.nullable().meta({ description: "Destination tag" }),
   feeStrategy: zFeeStrategyCustom.meta({ description: "Ripple-like fee strategy" })
 }).meta({
   description: "Ripple-like send data",
   id: "RippleLikeSendData"
 });
-var zRippleLikeTransactionData = z11.discriminatedUnion("type", [zRippleLikeSendData]);
+var zRippleLikeTransactionData = z9.discriminatedUnion("type", [zRippleLikeSendData]);
 var zRippleLikeTransactionResponse = zCommonTransactionResponse.extend({
   type: zRippleLikeTransactionType,
-  memos: z11.array(z11.string()),
-  destinationTag: z11.string()
+  memos: z9.array(z9.string()),
+  destinationTag: z9.string()
 }).meta({ description: "Ripple-like transaction" });
-var zSolanaLikeAssetFields = z11.object({
-  type: z11.literal(NetworkFamily.SOLANA_LIKE).meta({ description: "Account type" }),
-  address: z11.string().nullable().meta({ description: "Account address" }),
-  contractAddress: z11.string().meta({
+var zSolanaLikeAssetFields = z9.object({
+  type: z9.literal(NetworkFamily.SOLANA_LIKE).meta({ description: "Account type" }),
+  address: z9.string().nullable().meta({ description: "Account address" }),
+  contractAddress: z9.string().meta({
     description: "Will be deprecated, Use contractAddress at root level instead; Token contract address"
   }).nullable().optional()
 }).meta({ description: "Solana-like" });
-var zSolanaStakingAccountStatus = z11.enum(["not_sync", "activating", "activated", "deactivating", "deactivated", "deleted"]).meta({ description: "Staking account status" });
-var zSolanaLikeStakingData = z11.object({
-  staked: z11.string().meta({ description: "Staked balance" }),
-  rewards: z11.object({
-    total: z11.string().meta({ description: "Total rewards" }),
-    last7: z11.string().meta({ description: "Rewards on last 7 days" }),
-    last30: z11.string().meta({ description: "Rewards on last 30 days" })
+var zSolanaStakingAccountStatus = z9.enum(["not_sync", "activating", "activated", "deactivating", "deactivated", "deleted"]).meta({ description: "Staking account status" });
+var zSolanaLikeStakingData = z9.object({
+  staked: z9.string().meta({ description: "Staked balance" }),
+  rewards: z9.object({
+    total: z9.string().meta({ description: "Total rewards" }),
+    last7: z9.string().meta({ description: "Rewards on last 7 days" }),
+    last30: z9.string().meta({ description: "Rewards on last 30 days" })
   }),
-  stakes: z11.array(
-    z11.object({
-      uid: z11.string(),
-      baseAccountUid: z11.string(),
-      pubKey: z11.string().meta({ description: "Public key" }),
-      validatorPubKey: z11.string().nullable().meta({ description: "Validator public key" }),
-      initialAmount: z11.string().meta({ description: "Initial amount" }),
-      activeAmount: z11.string().meta({ description: "Active amount" }),
-      inactiveAmount: z11.string().meta({ description: "Inactive amount" }),
-      totalBalance: z11.string().meta({ description: "Total balance" }),
-      creationDate: z11.string().meta({ description: "Creation date" }),
-      activationEpoch: z11.string().nullable().meta({ description: "Activation epoch" }),
-      activationDate: z11.string().nullable().meta({ description: "Activation date" }),
-      deactivationEpoch: z11.string().nullable().meta({ description: "Deactivation epoch" }),
-      deactivationDate: z11.string().nullable().meta({ description: "Deactivation date" }),
+  stakes: z9.array(
+    z9.object({
+      uid: z9.string(),
+      baseAccountUid: z9.string(),
+      pubKey: z9.string().meta({ description: "Public key" }),
+      validatorPubKey: z9.string().nullable().meta({ description: "Validator public key" }),
+      initialAmount: z9.string().meta({ description: "Initial amount" }),
+      activeAmount: z9.string().meta({ description: "Active amount" }),
+      inactiveAmount: z9.string().meta({ description: "Inactive amount" }),
+      totalBalance: z9.string().meta({ description: "Total balance" }),
+      creationDate: z9.string().meta({ description: "Creation date" }),
+      activationEpoch: z9.string().nullable().meta({ description: "Activation epoch" }),
+      activationDate: z9.string().nullable().meta({ description: "Activation date" }),
+      deactivationEpoch: z9.string().nullable().meta({ description: "Deactivation epoch" }),
+      deactivationDate: z9.string().nullable().meta({ description: "Deactivation date" }),
       status: zSolanaStakingAccountStatus,
-      rentExemptReserve: z11.string().meta({ description: "Rent exempt reserve" }),
-      withdrawableAmount: z11.string().meta({ description: "Withdrawable amount" }),
-      totalRewards: z11.string().meta({ description: "Total rewards" }),
-      creationTxHash: z11.string().nullable().meta({ description: "Creation transaction hash" }),
-      actionsTxHashes: z11.array(z11.string()).meta({ description: "Actions transactions hashes" })
+      rentExemptReserve: z9.string().meta({ description: "Rent exempt reserve" }),
+      withdrawableAmount: z9.string().meta({ description: "Withdrawable amount" }),
+      totalRewards: z9.string().meta({ description: "Total rewards" }),
+      creationTxHash: z9.string().nullable().meta({ description: "Creation transaction hash" }),
+      actionsTxHashes: z9.array(z9.string()).meta({ description: "Actions transactions hashes" })
     })
   )
 }).nullable().meta({ description: "Solana-like staking data" });
-var zSolanaLikeStakingFields = z11.object({
-  type: z11.literal(NetworkFamily.SOLANA_LIKE).meta({ description: "Account type" }),
+var zSolanaLikeStakingFields = z9.object({
+  type: z9.literal(NetworkFamily.SOLANA_LIKE).meta({ description: "Account type" }),
   staking: zSolanaLikeStakingData.optional()
 });
 var zSolanaLikeLiveData = zCommonLiveData.extend(zSolanaLikeStakingFields.shape).meta({ description: "Solana-like" });
-var zSolanaLikeTransactionType = z11.enum([
+var zSolanaLikeTransactionType = z9.enum([
   "SOLANA_LIKE_SEND",
   "SOLANA_LIKE_RECEIVE",
   "SOLANA_LIKE_CREATE_DELEGATE_STAKE",
@@ -619,43 +824,43 @@ var zSolanaLikeTransactionType = z11.enum([
   "SOLANA_LIKE_CREATE_SPL_TOKEN_ACCOUNT"
 ]).meta({ description: "Solana-like transaction type" });
 var zSolanaLikeCreateDelegateStakeData = zCommonTransactionData.extend({
-  type: z11.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_CREATE_DELEGATE_STAKE),
-  recipient: z11.string().meta({ description: "Delegated vote address" }),
+  type: z9.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_CREATE_DELEGATE_STAKE),
+  recipient: z9.string().meta({ description: "Delegated vote address" }),
   // Re-described
   feeStrategy: zFeeStrategy.meta({ description: "Solana-like fee strategy" })
 }).meta({
   description: "Solana-like create delegate stake data",
   id: "SolanaLikeCreateDelegateStakeData"
 });
-var zSolanaLikeDeactivateStakeData = z11.object({
-  type: z11.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_DEACTIVATE_STAKE),
+var zSolanaLikeDeactivateStakeData = z9.object({
+  type: z9.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_DEACTIVATE_STAKE),
   currency: zCurrencyString.meta({ description: "Transaction currency" }),
   maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
-  stakeAccount: z11.string().meta({ description: "Stake account address" }),
+  stakeAccount: z9.string().meta({ description: "Stake account address" }),
   feeStrategy: zFeeStrategy.meta({ description: "Solana-like fee strategy" })
   // No recipient, no amount
 }).meta({
   description: "Solana-like deactivate stake data",
   id: "SolanaLikeDeactivateStakeData"
 });
-var zSolanaLikeDelegateStakeData = z11.object({
-  type: z11.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_DELEGATE_STAKE),
+var zSolanaLikeDelegateStakeData = z9.object({
+  type: z9.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_DELEGATE_STAKE),
   currency: zCurrencyString.meta({ description: "Transaction currency" }),
   maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
-  recipient: z11.string().meta({ description: "Delegated vote address" }),
-  stakeAccount: z11.string().meta({ description: "Stake account address" }),
+  recipient: z9.string().meta({ description: "Delegated vote address" }),
+  stakeAccount: z9.string().meta({ description: "Stake account address" }),
   feeStrategy: zFeeStrategy.meta({ description: "Solana-like fee strategy" })
   // No amount
 }).meta({
   description: "Solana-like delegate stake data",
   id: "SolanaLikeDelegateStakeData"
 });
-var zSolanaLikeMergeStakeData = z11.object({
-  type: z11.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_MERGE_STAKE),
+var zSolanaLikeMergeStakeData = z9.object({
+  type: z9.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_MERGE_STAKE),
   currency: zCurrencyString.meta({ description: "Transaction currency" }),
   maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
-  mergeSrcAccount: z11.string().meta({ description: "Source stake address" }),
-  mergeDstAccount: z11.string().meta({ description: "Destination stake address" }),
+  mergeSrcAccount: z9.string().meta({ description: "Source stake address" }),
+  mergeDstAccount: z9.string().meta({ description: "Destination stake address" }),
   feeStrategy: zFeeStrategy.meta({ description: "Solana-like fee strategy" })
   // No recipient, no amount
 }).meta({
@@ -663,42 +868,42 @@ var zSolanaLikeMergeStakeData = z11.object({
   id: "SolanaLikeMergeStakeData"
 });
 var zSolanaLikeSendData = zCommonTransactionData.extend({
-  type: z11.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_SEND),
+  type: z9.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_SEND),
   feeStrategy: zFeeStrategy.meta({ description: "Solana-like fee strategy" })
 }).meta({
   description: "Solana-like send data",
   id: "SolanaLikeSendData"
 });
-var zSolanaLikeSplitDeactivateStakeData = z11.object({
-  type: z11.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_SPLIT_DEACTIVATE_STAKE),
+var zSolanaLikeSplitDeactivateStakeData = z9.object({
+  type: z9.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_SPLIT_DEACTIVATE_STAKE),
   amount: zUnsignedIntString.meta({ description: "Transaction amount" }),
   currency: zCurrencyString.meta({ description: "Transaction currency" }),
   maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
-  stakeAccount: z11.string().meta({ description: "Stake account address" }),
+  stakeAccount: z9.string().meta({ description: "Stake account address" }),
   feeStrategy: zFeeStrategy.meta({ description: "Solana-like fee strategy" })
   // No recipient
 }).meta({
   description: "Solana-like split deactivate stake data",
   id: "SolanaLikeSplitDeactivateStakeData"
 });
-var zSolanaLikeSplitStakeData = z11.object({
-  type: z11.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_SPLIT_STAKE),
+var zSolanaLikeSplitStakeData = z9.object({
+  type: z9.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_SPLIT_STAKE),
   amount: zUnsignedIntString.meta({ description: "Transaction amount" }),
   currency: zCurrencyString.meta({ description: "Transaction currency" }),
   maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
-  stakeAccount: z11.string().meta({ description: "Stake account address" }),
+  stakeAccount: z9.string().meta({ description: "Stake account address" }),
   feeStrategy: zFeeStrategy.meta({ description: "Solana-like fee strategy" })
   // No recipient
 }).meta({
   description: "Solana-like split stake data",
   id: "SolanaLikeSplitStakeData"
 });
-var zSolanaLikeWithdrawStakeData = z11.object({
-  type: z11.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_WITHDRAW_STAKE),
+var zSolanaLikeWithdrawStakeData = z9.object({
+  type: z9.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_WITHDRAW_STAKE),
   amount: zUnsignedIntString.meta({ description: "Transaction amount" }),
   currency: zCurrencyString.meta({ description: "Transaction currency" }),
   maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
-  stakeAccount: z11.string().meta({ description: "Stake account address" }),
+  stakeAccount: z9.string().meta({ description: "Stake account address" }),
   feeStrategy: zFeeStrategy.meta({ description: "Solana-like fee strategy" })
   // No recipient
 }).meta({
@@ -706,21 +911,21 @@ var zSolanaLikeWithdrawStakeData = z11.object({
   id: "SolanaLikeWithdrawStakeData"
 });
 var zSolanaLikeSendTokenData = zCommonTransactionData.extend({
-  type: z11.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_SEND_TOKEN),
+  type: z9.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_SEND_TOKEN),
   feeStrategy: zFeeStrategy.meta({ description: "Solana-like fee strategy" })
 }).meta({
   description: "Solana-like send token data",
   id: "SolanaLikeSendTokenData"
 });
 var zSolanaLikeFundAndSendTokenData = zCommonTransactionData.extend({
-  type: z11.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_FUND_AND_SEND_TOKEN),
+  type: z9.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_FUND_AND_SEND_TOKEN),
   feeStrategy: zFeeStrategy.meta({ description: "Solana-like fee strategy" })
 }).meta({
   description: "Solana-like fund token account and send token data",
   id: "SolanaLikeFundAndSendTokenData"
 });
-var zSolanaLikeCreateTokenAccountData = z11.object({
-  type: z11.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_CREATE_SPL_TOKEN_ACCOUNT),
+var zSolanaLikeCreateTokenAccountData = z9.object({
+  type: z9.literal(zSolanaLikeTransactionType.enum.SOLANA_LIKE_CREATE_SPL_TOKEN_ACCOUNT),
   currency: zCurrencyString.meta({ description: "Transaction currency" }),
   maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
   feeStrategy: zFeeStrategy.meta({ description: "Solana-like fee strategy" })
@@ -728,7 +933,7 @@ var zSolanaLikeCreateTokenAccountData = z11.object({
   description: "Solana-like create token account",
   id: "SolanaLikeCreateTokenAccountData"
 });
-var zSolanaLikeTransactionData = z11.discriminatedUnion("type", [
+var zSolanaLikeTransactionData = z9.discriminatedUnion("type", [
   zSolanaLikeCreateDelegateStakeData,
   zSolanaLikeDeactivateStakeData,
   zSolanaLikeDelegateStakeData,
@@ -742,60 +947,60 @@ var zSolanaLikeTransactionData = z11.discriminatedUnion("type", [
   zSolanaLikeCreateTokenAccountData
 ]);
 var zSolanaLikeTransactionResponse = zCommonTransactionResponse.extend({ type: zSolanaLikeTransactionType }).meta({ description: "Solana-like transaction" });
-var zStellarLikeAssetFields = z11.object({
-  type: z11.literal(NetworkFamily.STELLAR_LIKE).meta({ description: "Account type" }),
-  address: z11.string().nullable().meta({ description: "Account address" })
+var zStellarLikeAssetFields = z9.object({
+  type: z9.literal(NetworkFamily.STELLAR_LIKE).meta({ description: "Account type" }),
+  address: z9.string().nullable().meta({ description: "Account address" })
 }).meta({ description: "Stellar-like" });
 var zStellarLikeLiveData = zCommonLiveData.extend({
-  type: z11.literal(NetworkFamily.STELLAR_LIKE).meta({ description: "Account type" })
+  type: z9.literal(NetworkFamily.STELLAR_LIKE).meta({ description: "Account type" })
 }).meta({ description: "Stellar-like" });
-var zStellarLikeEstimatedFees = z11.object({
-  type: z11.literal(NetworkFamily.STELLAR_LIKE),
+var zStellarLikeEstimatedFees = z9.object({
+  type: z9.literal(NetworkFamily.STELLAR_LIKE),
   fee: zIntString
 }).meta({ description: "Stellar-like fees" });
-var zStellarLikeTransactionType = z11.enum(["STELLAR_LIKE_SEND", "STELLAR_LIKE_RECEIVE"]).meta({ description: "Stellar-like transaction type" });
-var zStellarMemo = z11.union([
-  z11.object({
-    MEMO_TEXT: z11.string().max(28).meta({ description: "Text memo (at most a 28 bytes string)" })
+var zStellarLikeTransactionType = z9.enum(["STELLAR_LIKE_SEND", "STELLAR_LIKE_RECEIVE"]).meta({ description: "Stellar-like transaction type" });
+var zStellarMemo = z9.union([
+  z9.object({
+    MEMO_TEXT: z9.string().max(28).meta({ description: "Text memo (at most a 28 bytes string)" })
   }).meta({ description: "Text memo" }),
-  z11.object({ MEMO_ID: zIntString.meta({ description: "Id memo (unsigned 64 bits integer)" }) }).meta({ description: "Id memo" }),
-  z11.object({
-    MEMO_HASH: z11.string().max(128).regex(/^[a-fA-F0-9]+$/).meta({ description: "Transaction hash memo (64 bytes hexadecimal string)" })
+  z9.object({ MEMO_ID: zIntString.meta({ description: "Id memo (unsigned 64 bits integer)" }) }).meta({ description: "Id memo" }),
+  z9.object({
+    MEMO_HASH: z9.string().max(128).regex(/^[a-fA-F0-9]+$/).meta({ description: "Transaction hash memo (64 bytes hexadecimal string)" })
   }).meta({ description: "Hash memo" }),
-  z11.object({
-    MEMO_RETURN: z11.string().max(128).regex(/^[a-fA-F0-9]+$/).meta({
+  z9.object({
+    MEMO_RETURN: z9.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" })
 ]);
 var zStellarLikeSendData = zCommonTransactionData.extend({
-  type: z11.literal(zStellarLikeTransactionType.enum.STELLAR_LIKE_SEND),
+  type: z9.literal(zStellarLikeTransactionType.enum.STELLAR_LIKE_SEND),
   memo: zStellarMemo.nullable().meta({ description: "Stellar memo" }),
   feeStrategy: zFeeStrategy.meta({ description: "Stellar-like fee strategy" })
 }).meta({
   description: "Stellar-like send data",
   id: "StellarLikeSendData"
 });
-var zStellarLikeTransactionData = z11.discriminatedUnion("type", [zStellarLikeSendData]);
+var zStellarLikeTransactionData = z9.discriminatedUnion("type", [zStellarLikeSendData]);
 var zStellarLikeTransactionResponse = zCommonTransactionResponse.extend({ type: zStellarLikeTransactionType }).meta({ description: "Stellar-like transaction" });
-var zSuiLikeAssetFields = z11.object({
-  type: z11.literal(NetworkFamily.SUI_LIKE).meta({ description: "Account type" }),
-  address: z11.string().nullable().meta({ description: "Account address" })
+var zSuiLikeAssetFields = z9.object({
+  type: z9.literal(NetworkFamily.SUI_LIKE).meta({ description: "Account type" }),
+  address: z9.string().nullable().meta({ description: "Account address" })
 }).meta({ description: "Sui-like" });
-var zSuiLikeStakingData = z11.object({
-  totalStaked: z11.string().meta({ description: "Total staked amount" }),
-  totalRewards: z11.string().meta({ description: "Total of rewards" })
+var zSuiLikeStakingData = z9.object({
+  totalStaked: z9.string().meta({ description: "Total staked amount" }),
+  totalRewards: z9.string().meta({ description: "Total of rewards" })
 }).nullable().meta({ description: "Sui-like staking data" });
-var zSuiLikeStakingFields = z11.object({
-  type: z11.literal(NetworkFamily.SUI_LIKE).meta({ description: "Account type" }),
+var zSuiLikeStakingFields = z9.object({
+  type: z9.literal(NetworkFamily.SUI_LIKE).meta({ description: "Account type" }),
   staking: zSuiLikeStakingData.optional()
 });
 var zSuiLikeLiveData = zCommonLiveData.extend(zSuiLikeStakingFields.shape).meta({ description: "Sui-like" });
-var zSuiLikeEstimatedFees = z11.object({
-  type: z11.literal(NetworkFamily.SUI_LIKE),
+var zSuiLikeEstimatedFees = z9.object({
+  type: z9.literal(NetworkFamily.SUI_LIKE),
   fee: zIntString
 }).meta({ description: "Sui-like fees" });
-var zSuiLikeTransactionType = z11.enum([
+var zSuiLikeTransactionType = z9.enum([
   "SUI_LIKE_SEND",
   "SUI_LIKE_RECEIVE",
   "SUI_LIKE_SEND_TOKEN",
@@ -804,21 +1009,21 @@ var zSuiLikeTransactionType = z11.enum([
   "SUI_LIKE_UNSTAKE"
 ]).meta({ description: "Sui-like transaction type" });
 var zSuiLikeSendData = zCommonTransactionData.extend({
-  type: z11.literal(zSuiLikeTransactionType.enum.SUI_LIKE_SEND),
+  type: z9.literal(zSuiLikeTransactionType.enum.SUI_LIKE_SEND),
   feeStrategy: zFeeStrategy.meta({ description: "Sui-like fee strategy" })
 }).meta({
   description: "Sui-like send data",
   id: "SuiLikeSendData"
 });
 var zSuiLikeTransferTokenData = zCommonTransactionData.extend({
-  type: z11.literal(zSuiLikeTransactionType.enum.SUI_LIKE_SEND_TOKEN),
+  type: z9.literal(zSuiLikeTransactionType.enum.SUI_LIKE_SEND_TOKEN),
   feeStrategy: zFeeStrategy.meta({ description: "Sui-like fee strategy" })
 }).meta({
   description: "Sui-like transfer token data",
   id: "SuiLikeTransferTokenData"
 });
-var zSuiLikeStakeData = z11.object({
-  type: z11.literal(zSuiLikeTransactionType.enum.SUI_LIKE_STAKE),
+var zSuiLikeStakeData = z9.object({
+  type: z9.literal(zSuiLikeTransactionType.enum.SUI_LIKE_STAKE),
   feeStrategy: zFeeStrategy.meta({ description: "Sui-like fee strategy" }),
   amount: zUnsignedIntString.meta({ description: "Transaction amount" }),
   currency: zCurrencyString.meta({
@@ -826,55 +1031,55 @@ var zSuiLikeStakeData = z11.object({
   }),
   maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
   // DELEGATE does not have recipient, but has validator instead
-  validator: z11.string().nonempty().meta({ description: "Validator address" })
+  validator: z9.string().nonempty().meta({ description: "Validator address" })
 }).meta({
   description: "Sui-like stake data",
   id: "SuiLikeStakeData"
 });
-var zSuiLikeUnstakeData = z11.object({
-  type: z11.literal(zSuiLikeTransactionType.enum.SUI_LIKE_UNSTAKE),
+var zSuiLikeUnstakeData = z9.object({
+  type: z9.literal(zSuiLikeTransactionType.enum.SUI_LIKE_UNSTAKE),
   feeStrategy: zFeeStrategy.meta({ description: "Sui-like fee strategy" }),
   currency: zCurrencyString.meta({
     description: "Will be deprecated soon, use Account.network. Transaction currency"
   }),
   maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
-  stakedSuiId: z11.string().nonempty().meta({ description: "Staked object to (partially?) unstake" }),
+  stakedSuiId: z9.string().nonempty().meta({ description: "Staked object to (partially?) unstake" }),
   amount: zUnsignedIntString.meta({ description: "Amount to unstake from the position" }),
-  useAllAmount: z11.boolean().meta({
+  useAllAmount: z9.boolean().meta({
     description: "Whether to unstake the full amount (triggers different sets of transaction commands)"
   })
 }).meta({
   description: "Sui-like unstake data",
   id: "SuiLikeUnstakeData"
 });
-var zSuiLikeTransactionData = z11.discriminatedUnion("type", [
+var zSuiLikeTransactionData = z9.discriminatedUnion("type", [
   zSuiLikeSendData,
   zSuiLikeTransferTokenData,
   zSuiLikeStakeData,
   zSuiLikeUnstakeData
 ]);
 var zSuiLikeTransactionResponse = zCommonTransactionResponse.extend({ type: zSuiLikeTransactionType }).meta({ description: "Sui-like transaction" });
-var zTezosLikeAssetFields = z11.object({
-  type: z11.literal(NetworkFamily.TEZOS_LIKE).meta({ description: "Account type" }),
-  address: z11.string().nullable().meta({ description: "Account address" })
+var zTezosLikeAssetFields = z9.object({
+  type: z9.literal(NetworkFamily.TEZOS_LIKE).meta({ description: "Account type" }),
+  address: z9.string().nullable().meta({ description: "Account address" })
 }).meta({ description: "Tezos-like" });
-var zTezosLikeStakingData = z11.object({
-  delegations: z11.array(
-    z11.object({
-      address: z11.string()
+var zTezosLikeStakingData = z9.object({
+  delegations: z9.array(
+    z9.object({
+      address: z9.string()
     })
   )
 }).nullable().meta({ description: "Tezos-like staking data" });
-var zTezosLikeStakingFields = z11.object({
-  type: z11.literal(NetworkFamily.TEZOS_LIKE).meta({ description: "Account type" }),
+var zTezosLikeStakingFields = z9.object({
+  type: z9.literal(NetworkFamily.TEZOS_LIKE).meta({ description: "Account type" }),
   staking: zTezosLikeStakingData.optional()
 });
 var zTezosLikeLiveData = zCommonLiveData.extend(zTezosLikeStakingFields.shape).meta({ description: "Tezos-like" });
-var zTezosLikeEstimatedFees = z11.object({
-  type: z11.literal(NetworkFamily.TEZOS_LIKE),
+var zTezosLikeEstimatedFees = z9.object({
+  type: z9.literal(NetworkFamily.TEZOS_LIKE),
   fee: zIntString
 }).describe("Tezos-like fees");
-var zTezosLikeTransactionType = z11.enum([
+var zTezosLikeTransactionType = z9.enum([
   "TEZOS_LIKE_SEND",
   "TEZOS_LIKE_RECEIVE",
   "TEZOS_LIKE_REVEAL",
@@ -883,76 +1088,76 @@ var zTezosLikeTransactionType = z11.enum([
 ]).meta({ description: "Tezos-like transaction type" });
 var zTezosLikeFeeStrategy = zFeeStrategyCustom.meta({ description: "Tezos-like fee strategy" });
 var zTezosLikeSendData = zCommonTransactionData.extend({
-  type: z11.literal(zTezosLikeTransactionType.enum.TEZOS_LIKE_SEND),
+  type: z9.literal(zTezosLikeTransactionType.enum.TEZOS_LIKE_SEND),
   feeStrategy: zTezosLikeFeeStrategy
 }).meta({
   description: "Tezos-like send data",
   id: "TezosLikeSendData"
 });
-var zTezosLikeDelegateData = z11.object({
-  type: z11.literal(zTezosLikeTransactionType.enum.TEZOS_LIKE_DELEGATE),
+var zTezosLikeDelegateData = z9.object({
+  type: z9.literal(zTezosLikeTransactionType.enum.TEZOS_LIKE_DELEGATE),
   amount: zUnsignedIntString.optional().meta({ description: "Deprecated: DO NOT USE!" }),
   currency: zCurrencyString.meta({ description: "Transaction currency" }),
   maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
-  recipient: z11.string().nonempty().meta({ description: "Transaction recipient" }),
+  recipient: z9.string().nonempty().meta({ description: "Transaction recipient" }),
   feeStrategy: zTezosLikeFeeStrategy
 }).meta({
   description: "Tezos-like delegate data",
   id: "TezosLikeDelegateData"
 });
-var zTezosLikeUndelegateData = z11.object({
-  type: z11.literal(zTezosLikeTransactionType.enum.TEZOS_LIKE_UNDELEGATE),
+var zTezosLikeUndelegateData = z9.object({
+  type: z9.literal(zTezosLikeTransactionType.enum.TEZOS_LIKE_UNDELEGATE),
   amount: zUnsignedIntString.optional().meta({ description: "Deprecated: DO NOT USE!" }),
   currency: zCurrencyString.meta({ description: "Transaction currency" }),
   maxFee: zUnsignedIntString.nullable().meta({ description: "Transaction max fee" }),
-  recipient: z11.string().nonempty().optional().meta({ description: "Deprecated: DO NOT USE!" }),
+  recipient: z9.string().nonempty().optional().meta({ description: "Deprecated: DO NOT USE!" }),
   feeStrategy: zTezosLikeFeeStrategy
 }).meta({
   description: "Tezos-like undelegate data",
   id: "TezosLikeUndelegateData"
 });
-var zTezosLikeTransactionData = z11.discriminatedUnion("type", [
+var zTezosLikeTransactionData = z9.discriminatedUnion("type", [
   zTezosLikeSendData,
   zTezosLikeDelegateData,
   zTezosLikeUndelegateData
 ]);
 var zTezosLikeTransactionResponse = zCommonTransactionResponse.extend({ type: zTezosLikeTransactionType }).meta({ description: "Tezos-like transaction" });
-var zTronLikeAssetFields = z11.object({
-  type: z11.literal(NetworkFamily.TRON_LIKE).meta({ description: "Account type" }),
-  address: z11.string().nullable().meta({ description: "Account address" }),
-  contractAddress: z11.string().nullable().meta({
+var zTronLikeAssetFields = z9.object({
+  type: z9.literal(NetworkFamily.TRON_LIKE).meta({ description: "Account type" }),
+  address: z9.string().nullable().meta({ description: "Account address" }),
+  contractAddress: z9.string().nullable().meta({
     description: "Will be deprecated, Use contractAddress at root level instead; Token contract address"
   }).optional()
 }).meta({ description: "Tron-like" });
 var zTronLikeLiveData = zCommonLiveData.extend({
-  type: z11.literal(NetworkFamily.TRON_LIKE).meta({ description: "Account type" })
+  type: z9.literal(NetworkFamily.TRON_LIKE).meta({ description: "Account type" })
 }).meta({ description: "Tron-like" });
-var zTronLikeEstimatedFees = z11.object({
-  type: z11.literal(NetworkFamily.TRON_LIKE),
+var zTronLikeEstimatedFees = z9.object({
+  type: z9.literal(NetworkFamily.TRON_LIKE),
   fee: zIntString
 }).meta({ description: "Tron-like fees" });
-var zTronLikeTransactionType = z11.enum(["TRON_LIKE_SEND", "TRON_LIKE_RECEIVE", "TRON_LIKE_SEND_TOKEN", "TRON_LIKE_RECEIVE_TOKEN"]).meta({ description: "Tron-like transaction type" });
+var zTronLikeTransactionType = z9.enum(["TRON_LIKE_SEND", "TRON_LIKE_RECEIVE", "TRON_LIKE_SEND_TOKEN", "TRON_LIKE_RECEIVE_TOKEN"]).meta({ description: "Tron-like transaction type" });
 var zTronLikeSendData = zCommonTransactionData.extend({
-  type: z11.literal(zTronLikeTransactionType.enum.TRON_LIKE_SEND),
+  type: z9.literal(zTronLikeTransactionType.enum.TRON_LIKE_SEND),
   feeStrategy: zFeeStrategy.meta({ description: "Tron-like fee strategy" })
 }).meta({
   description: "Tron-like send data",
   id: "TronLikeSendData"
 });
 var zTronLikeSendTokenData = zCommonTransactionData.extend({
-  type: z11.literal(zTronLikeTransactionType.enum.TRON_LIKE_SEND_TOKEN),
+  type: z9.literal(zTronLikeTransactionType.enum.TRON_LIKE_SEND_TOKEN),
   feeStrategy: zFeeStrategy.meta({ description: "Tron-like fee strategy" })
 }).meta({
   description: "Tron-like send token data",
   id: "TronLikeSendTokenData"
 });
-var zTronLikeTransactionData = z11.discriminatedUnion("type", [
+var zTronLikeTransactionData = z9.discriminatedUnion("type", [
   zTronLikeSendData,
   zTronLikeSendTokenData
 ]);
 
 // src/networks/index.ts
-var zNetworkAssetFields = z11.discriminatedUnion("type", [
+var zNetworkAssetFields = z9.discriminatedUnion("type", [
   zBitcoinLikeAssetFields,
   zCantonLikeAssetFields,
   zCardanoLikeAssetFields,
@@ -966,7 +1171,7 @@ var zNetworkAssetFields = z11.discriminatedUnion("type", [
   zSuiLikeAssetFields,
   zTronLikeAssetFields
 ]).meta({ description: "Network asset fields" });
-var zAccountLiveData = z11.discriminatedUnion("type", [
+var zAccountLiveData = z9.discriminatedUnion("type", [
   zBitcoinLikeLiveData,
   zCantonLikeLiveData,
   zCardanoLikeLiveData,
@@ -980,7 +1185,7 @@ var zAccountLiveData = z11.discriminatedUnion("type", [
   zTezosLikeLiveData,
   zTronLikeLiveData
 ]);
-z11.discriminatedUnion("type", [
+z9.discriminatedUnion("type", [
   zCardanoLikeStakingFields,
   zEthereumLikeStakingFields,
   zPolkadotLikeStakingFields,
@@ -988,7 +1193,7 @@ z11.discriminatedUnion("type", [
   zSuiLikeStakingFields,
   zTezosLikeStakingFields
 ]);
-z11.discriminatedUnion("type", [
+z9.discriminatedUnion("type", [
   zEthereumLikeEstimatedFees,
   zRippleLikeEstimatedFees,
   zStellarLikeEstimatedFees,
@@ -996,7 +1201,7 @@ z11.discriminatedUnion("type", [
   zTezosLikeEstimatedFees,
   zTronLikeEstimatedFees
 ]);
-z11.union([
+z9.union([
   zBitcoinLikeTransactionType,
   zCantonLikeTransactionType,
   zCardanoLikeTransactionType,
@@ -1031,7 +1236,7 @@ z11.union([
   // TODO: Sometimes `NetworkFamily` is not a `TransactionType` prefix - but why?
   [NetworkFamily.GENERIC_LIKE]: "GENERIC"
 });
-var zTransactionData = z11.discriminatedUnion("type", [
+var zTransactionData = z9.discriminatedUnion("type", [
   ...zBitcoinLikeTransactionData.options,
   ...zCantonLikeTransactionData.options,
   ...zCardanoLikeTransactionData.options,
@@ -1045,7 +1250,7 @@ var zTransactionData = z11.discriminatedUnion("type", [
   ...zTronLikeTransactionData.options,
   zGenericTransactionData
 ]);
-var zSendOnlyTransactionData = z11.discriminatedUnion("type", [
+var zSendOnlyTransactionData = z9.discriminatedUnion("type", [
   zBitcoinLikeSendData,
   zCantonLikeSendData,
   zCardanoLikeSendData,
@@ -1057,7 +1262,7 @@ var zSendOnlyTransactionData = z11.discriminatedUnion("type", [
   zSuiLikeSendData,
   zTezosLikeSendData
 ]);
-var zTransactionResponse = z11.discriminatedUnion("type", [
+var zTransactionResponse = z9.discriminatedUnion("type", [
   zBitcoinLikeTransactionResponse,
   zCantonLikeTransactionResponse,
   zCardanoLikeTransactionResponse,
@@ -1071,71 +1276,163 @@ var zTransactionResponse = z11.discriminatedUnion("type", [
   zSuiLikeTransactionResponse,
   zTezosLikeTransactionResponse
 ]);
-
-// src/accounts/clients/types.ts
-z11.discriminatedUnion(
-  zTransactionResponse._zod.def.discriminator,
-  ensureNonEmptyArray(
-    zTransactionResponse.options.map((_) => _.extend({ note: zNote.nullable() }))
-  )
-);
-var zReviewStepWithUsers = z.object({
-  quorum: z.number().min(0).meta({ description: "Number of required approvals for the step" }),
-  userIds: z.array(z.string().min(1)).meta({ description: "User ids in the step" })
-  // PKs to `User` model
-}).meta({ description: "Review step with users" });
-var zReviewStepWithUsersArray = z.array(zReviewStepWithUsers);
-var zReviewStepData = z.union([
-  zReviewStepWithUsers,
-  z.object({
-    quorum: z.number().min(0).meta({ description: "Number of required approvals for the step" }),
-    groupId: z.string().min(1).meta({ description: "Group id in the step" })
-    // PKs to `Group` model
-  }).meta({ description: "Review step with group" })
-]);
-var zReviewStepsArray = z.array(zReviewStepData).min(1).meta({ description: "Review steps" });
-
-// src/prisma-utils/policy.ts
-var policy_exports = {};
-__export(policy_exports, {
-  parseFields: () => parseFields,
-  zGovRuleJsonObject: () => zGovRuleJsonObject,
-  zGovRulesJsonArray: () => zGovRulesJsonArray,
-  zThreshold: () => zThreshold,
-  zWhitelistIds: () => zWhitelistIds
-});
-var zThreshold = z.object({
-  min: zUnsignedIntString.nullable().meta({ description: "Minimum transaction amount" }),
-  max: zUnsignedIntString.nullable().meta({ description: "Maximum transaction amount" })
-}).meta({ description: "Threshold for the transaction value" });
-var zWhitelistIds = z.array(z.string().min(1)).meta({ description: "IDs of whitelists for the recipient address" });
-var zGovRuleJsonObject = z.object({
-  // Required.
-  operationType: zOperationType.meta({ description: "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: z.string().min(1).meta({ description: "Id of ReviewConfig" }),
-  // HSM id for the rule
-  hsmId: zHsmObjectId
-}).meta({ description: "INTERNAL: Governance rule JSON representation in DB" });
-var zGovRulesJsonArray = z.array(zGovRuleJsonObject);
-var parseFields = (policy) => {
-  const rulesJsonArray = zGovRulesJsonArray.parse(policy.rulesJsonArray);
-  return { ...policy, rulesJsonArray };
+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.EDIT_WORKSPACE_RULE:
+    case RequestType.UPDATE_QUORUM:
+      return false;
+    case RequestType.CREATE_PSD_USER:
+    case RequestType.CREATE_API_USER:
+    case RequestType.CREATE_API_USER_ACCESS:
+    // targeting / editing an existing `User`
+    case RequestType.REVOKE_USER:
+    case RequestType.CREATE_TRANSACTION:
+    case RequestType.SIGN_MESSAGE:
+    case RequestType.SIGN_DIGESTS:
+    case RequestType.CREATE_ACCOUNT:
+    case RequestType.EDIT_ACCOUNT:
+    case RequestType.TRADELINK_ACTIVATE_ACCOUNT:
+    case RequestType.CREATE_GROUP:
+    case RequestType.EDIT_GROUP:
+    case RequestType.REVOKE_GROUP:
+    case RequestType.CREATE_WHITELIST:
+    case RequestType.EDIT_WHITELIST:
+    case RequestType.CREATE_POLICY:
+    case RequestType.EDIT_POLICY:
+    case RequestType.TRADELINK_CREATE_CUSTODIAN:
+    case RequestType.TRADELINK_EDIT_CUSTODIAN:
+    case RequestType.TRADELINK_CREATE_EXCHANGE:
+    case RequestType.TRADELINK_EDIT_EXCHANGE:
+    case RequestType.TRADELINK_CREATE_ASSET_MANAGER:
+    case RequestType.TRADELINK_EDIT_ASSET_MANAGER:
+      return request.state !== RequestState.INITIAL;
+    case RequestType.EDIT_TOKEN_RULE:
+      return true;
+  }
+};
+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:
+    case RequestType.SIGN_DIGESTS:
+      return false;
+    case RequestType.UPDATE_QUORUM:
+    case RequestType.CREATE_PSD_USER:
+    case RequestType.CREATE_API_USER:
+    case RequestType.CREATE_ACCOUNT:
+    case RequestType.CREATE_GROUP:
+    case RequestType.CREATE_WHITELIST:
+    case RequestType.CREATE_ENTITY:
+    case RequestType.CREATE_SCICONFIG:
+    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.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.TRADELINK_EDIT_CUSTODIAN:
+    case RequestType.TRADELINK_EDIT_EXCHANGE:
+    case RequestType.TRADELINK_EDIT_ASSET_MANAGER:
+    case RequestType.TRADELINK_ADJUST_PLEDGE:
+    case RequestType.TRADELINK_REPLEDGE:
+    case RequestType.TRADELINK_CREATE_SETTLEMENT:
+    case RequestType.TRADELINK_FORCE_UNPLEDGE:
+    case RequestType.TRADELINK_WITHDRAW:
+    case RequestType.TRADELINK_ARBITRATE:
+      return true;
+  }
 };
 
-// src/prisma-utils/review-config.ts
-var review_config_exports = {};
-__export(review_config_exports, {
-  INCLUDE_MEMBERS: () => INCLUDE_MEMBERS
-});
-var INCLUDE_MEMBERS = {
-  users: true,
-  groups: {
-    include: { members: true }
+// src/__fakes__/models/requests/requests-and-reviews.ts
+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;
+  return injectSyncId({
+    id: faker.string.uuid(),
+    workspaceName: fakeWorkspaceName(),
+    type,
+    state,
+    reviewSteps: genRequestReviewSteps(),
+    currentStepIndex: 0,
+    expiresAt: faker.date.future(),
+    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
+  };
 };
 var zPubKey = zHexString.meta({ description: "Public key" });
 var zHsmCertificate = z.object({
@@ -1242,7 +1539,7 @@ var zHsmSignature = z.object({
   }),
   pubkey: zHexString.nullable().meta({ description: "Public key for signature verification, 32 or 33 bytes" })
 });
-var zWorkspaceName = z11.string().min(1).max(20).regex(/^[a-z0-9]+$/);
+var zWorkspaceName = z9.string().min(1).max(20).regex(/^[a-z0-9]+$/);
 var zUserName = z.string().min(1).max(19).meta({ description: "User name" });
 var zUserRegistrationCreateInput = z.object({
   name: zUserName,
@@ -1258,1336 +1555,1044 @@ zUserRegistrationCreateInput.extend({
 });
 
 // src/users/request-data.ts
-var zCreatePsdUserRequestData = z11.object({
-  registrationId: z11.string().meta({ description: "User registration ID" })
+var zCreatePsdUserRequestData = z9.object({
+  registrationId: z9.string().meta({ description: "User registration ID" })
 });
-var zCreateApiUserRequestData = z11.object({
+var zCreateApiUserRequestData = z9.object({
   name: zUserName,
-  pubKey: z11.string().meta({ description: "Public key" }),
-  role: z11.enum(["ADMIN", "OPERATOR"]).meta({ description: "User role" }),
-  viewAll: z11.boolean().meta({ description: "View all data" }).optional()
+  pubKey: z9.string().meta({ description: "Public key" }),
+  role: z9.enum(["ADMIN", "OPERATOR"]).meta({ description: "User role" }),
+  viewAll: z9.boolean().meta({ description: "View all data" }).optional()
 }).meta({ description: "Create API user request data" });
-var zCreateApiUserAccessRequestData = z11.object({
+var zCreateApiUserAccessRequestData = z9.object({
   name: zUserName
 }).meta({ description: "Create API user credential request data" });
-z11.object({
-  authUserId: z11.string().meta({ description: "Authentication broker ID" })
-}).meta({ description: "Managed data for API user" });
-var zRevokeUserRequestData = z11.object({});
-var zUpdateQuorumRequestData = z11.object({
-  quorum: z11.number().int().min(2).meta({ description: "Workspace quorum" })
-});
-var NonRootAdminPermission = omit(AdminPermission, "ROOT");
-var zWorkspaceRuleRequestData = z11.object({
-  permission: z11.enum(NonRootAdminPermission).meta({ description: "Granted permissions" }),
-  reviewConfig: zReviewStepWithUsersArray.meta({ description: "List of admin review steps" })
-});
-var zTradelinkWhitelistAddress = z11.object({
-  name: z11.string().min(1),
-  currency: zCurrencyString,
-  address: z11.string().min(1)
-});
-z11.array(zTradelinkWhitelistAddress);
-var zTradelinkId = z11.string().meta({ description: "Unique identifier in Tradelink service" });
-var zTradelinkOrgEntityResponse = z11.object({
-  tradelinkId: zTradelinkId,
-  name: z11.string().meta({ description: "Name" }),
-  code: z11.string().meta({ description: "Code" }),
-  logoUrl: z11.string().meta({ description: "Logo URL" })
-});
-zTradelinkOrgEntityResponse.omit({
-  tradelinkId: true
-});
-z11.object({
-  tradelinkId: zTradelinkId
-});
-var zTradelinkExchangeConfig = z11.object({
-  exchangeId: z11.string().meta({ description: "Tradelink exchange id" }),
-  repledgeAuthorized: z11.boolean().meta({
-    description: "Determines whether this exchange is authorized to repledge on this account"
-  }),
-  needsAssetManagerApprovalForSettlements: z11.boolean().meta({
-    description: 'Determines whether asset manager will "pre-approve" the settlement requests on this account'
-  })
-});
-var zTradelinkExchangeConfigs = z11.array(zTradelinkExchangeConfig);
-z11.object({
-  workspaceName: zWorkspaceName,
-  custodian: z11.object({ name: z11.string() }),
-  assetManagers: z11.array(z11.object({ name: z11.string() })),
-  exchanges: z11.array(z11.object({ name: z11.string() }))
-});
-z11.object({
-  tradelinkId: z11.string(),
-  workspaceName: zWorkspaceName,
-  custodian: zTradelinkOrgEntityResponse,
-  assetManagers: z11.array(zTradelinkOrgEntityResponse),
-  exchanges: z11.array(zTradelinkOrgEntityResponse)
-});
-var zTradelinkAsset = z11.object({
-  name: z11.string(),
-  magnitude: z11.number().int().nonnegative()
-});
-z11.object({
-  tradelinkId: zTradelinkId,
-  asset: zTradelinkAsset,
-  state: z11.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: z11.boolean(),
-  amount: z11.string().meta({ description: "Currently pledged amount" }),
-  pending: z11.string().meta({ description: "Requested pledge increment, not yet approved" }),
-  repledge: z11.string().meta({ description: "TODO: describe this field" }),
-  exchangeTradelinkId: z11.string(),
-  accountId: z11.string()
-});
-z11.object({
-  workspaceName: z11.string(),
-  clientAccountId: z11.string().meta({ description: "Account ID from the client side" }),
-  exchangeTradelinkId: zTradelinkId,
-  asset: zTradelinkAsset
-});
-z11.object({
-  pledgeTradelinkId: zTradelinkId,
-  amount: zUnsignedIntString,
-  asset: zTradelinkAsset
-});
-z11.object({
-  tradelinkId: z11.string(),
-  pledgeTradelinkId: z11.string(),
-  state: z11.enum([
-    "REGISTERED",
-    "PENDING_REPLEDGE_CREATION_APPROVAL",
-    "PENDING_REPLEDGE_APPROVAL",
-    "PENDING_CREATION_APPROVAL",
-    "PENDING_PRE_APPROVAL",
-    "PRE_APPROVED",
-    "APPROVED",
-    "REJECTED",
-    "CONFIRMED",
-    "FAILED",
-    "CANCELED"
-  ]),
-  // For now we only consider the outbound settlement
-  outboundTransactionHash: z11.string().nullable()
-});
-
-// src/tradelink/request-data.ts
-var zTradelinkActivateAccountRequestData = z11.null();
-var zTradelinkCustodianRequestData = z11.object({
-  settlement: zReviewStepWithUsersArray.meta({ description: "List of settlement review steps" }),
-  withdraw: zReviewStepWithUsersArray.meta({ description: "List of withdraw review steps" }),
-  arbitration: zReviewStepWithUsersArray.meta({ description: "List of arbitration review steps" })
-});
-var zTradelinkEntityRequestData = z11.object({
-  tradelinkId: z11.string().min(1),
-  groups: zReviewStepWithUsersArray.meta({ description: "List of asset manager review groups" }),
-  whitelist: z11.array(zTradelinkWhitelistAddress).meta({ description: "List of asset manager whitelisted addresses" })
-});
-var zTradelinkAdjustPledgeRequestData = z11.object({
-  accountId: z11.string().meta({ description: "Account id" }),
-  exchangeId: z11.string().meta({ description: "Exchange id" }),
-  amount: zIntString.meta({ description: "Amount to add to pledge" })
-});
-var zTradelinkRepledgeRequestData = z11.object({
-  accountId: z11.string().meta({ description: "Account id" }),
-  exchangeId: z11.string().meta({ description: "Exchange id" }),
-  amount: zIntString.meta({ description: "Amount to add to pledge" })
-});
-var zTradelinkCreateSettlementRequestData = z11.object({
-  accountId: z11.string().meta({ description: "Account id" }),
-  exchangeId: z11.string().meta({ description: "Exchange id" }),
-  transaction: zSendOnlyTransactionData
-});
-var zTradelinkForceUnpledgeRequestData = z11.object({
-  accountId: z11.string().meta({ description: "Account id" }),
-  exchangeId: z11.string().meta({ description: "Exchange id" })
-});
-var zTradelinkWithdrawRequestData = z11.object({
-  accountId: z11.string().meta({ description: "Account id" }),
-  transaction: zSendOnlyTransactionData
-});
-var zTradelinkArbitrationRequestData = z11.object({
-  accountId: z11.string().meta({ description: "Account id" }),
-  transaction: zSendOnlyTransactionData
-});
-var zTradelinkRequestMixinsByType = {
-  [RequestType.TRADELINK_ACTIVATE_ACCOUNT]: z11.object({
-    type: z11.literal(RequestType.TRADELINK_ACTIVATE_ACCOUNT),
-    targetId: z11.string(),
-    data: zTradelinkActivateAccountRequestData
-  }),
-  [RequestType.TRADELINK_CREATE_CUSTODIAN]: z11.object({
-    type: z11.literal(RequestType.TRADELINK_CREATE_CUSTODIAN),
-    data: zTradelinkCustodianRequestData
-  }),
-  [RequestType.TRADELINK_EDIT_CUSTODIAN]: z11.object({
-    type: z11.literal(RequestType.TRADELINK_EDIT_CUSTODIAN),
-    targetId: z11.string(),
-    data: zTradelinkCustodianRequestData
-  }),
-  [RequestType.TRADELINK_CREATE_EXCHANGE]: z11.object({
-    type: z11.literal(RequestType.TRADELINK_CREATE_EXCHANGE),
-    data: zTradelinkEntityRequestData
-  }),
-  [RequestType.TRADELINK_EDIT_EXCHANGE]: z11.object({
-    type: z11.literal(RequestType.TRADELINK_EDIT_EXCHANGE),
-    targetId: z11.string(),
-    data: zTradelinkEntityRequestData
-  }),
-  [RequestType.TRADELINK_CREATE_ASSET_MANAGER]: z11.object({
-    type: z11.literal(RequestType.TRADELINK_CREATE_ASSET_MANAGER),
-    data: zTradelinkEntityRequestData
-  }),
-  [RequestType.TRADELINK_EDIT_ASSET_MANAGER]: z11.object({
-    type: z11.literal(RequestType.TRADELINK_EDIT_ASSET_MANAGER),
-    targetId: z11.string(),
-    data: zTradelinkEntityRequestData
-  }),
-  [RequestType.TRADELINK_ADJUST_PLEDGE]: z11.object({
-    type: z11.literal(RequestType.TRADELINK_ADJUST_PLEDGE),
-    data: zTradelinkAdjustPledgeRequestData
-  }),
-  [RequestType.TRADELINK_REPLEDGE]: z11.object({
-    type: z11.literal(RequestType.TRADELINK_REPLEDGE),
-    data: zTradelinkRepledgeRequestData
-  }),
-  [RequestType.TRADELINK_CREATE_SETTLEMENT]: z11.object({
-    type: z11.literal(RequestType.TRADELINK_CREATE_SETTLEMENT),
-    data: zTradelinkCreateSettlementRequestData,
-    meta: z11.object({
-      hash: z11.string().nullable()
-    }).optional().nullable()
-  }),
-  [RequestType.TRADELINK_FORCE_UNPLEDGE]: z11.object({
-    type: z11.literal(RequestType.TRADELINK_FORCE_UNPLEDGE),
-    data: zTradelinkForceUnpledgeRequestData
-  }),
-  [RequestType.TRADELINK_WITHDRAW]: z11.object({
-    type: z11.literal(RequestType.TRADELINK_WITHDRAW),
-    data: zTradelinkWithdrawRequestData,
-    meta: z11.object({
-      hash: z11.string().nullable()
-    }).optional().nullable()
-  }),
-  [RequestType.TRADELINK_ARBITRATE]: z11.object({
-    type: z11.literal(RequestType.TRADELINK_ARBITRATE),
-    data: zTradelinkArbitrationRequestData,
-    meta: z11.object({
-      hash: z11.string().nullable()
-    }).optional().nullable()
-  })
-};
-var zMessageType = z11.enum(MessageType).meta({ description: "Type of the message to sign" });
-var zMessageData = zHexString.nonempty().meta({
-  description: "Hex data to sign, either a json string for EIP712, or a raw string for EIP191"
-});
-var zMessage = z11.object({
-  type: zMessageType,
-  data: zMessageData
-});
-z11.object({
-  id: z11.string().meta({ description: "Unique identifier" }),
-  type: zMessageType,
-  data: zMessageData,
-  address: z11.string().meta({ description: "Address of the signing key" }),
-  derivationPath: z11.string().meta({ description: "Derivation path of the signing key" }),
-  signature: zHsmSignature.meta({ description: "Signature of the message" }),
-  createdById: z11.string().meta({ description: "ID of the creator" }),
-  createdAt: z11.coerce.date().meta({ description: "Creation timestamp" })
-}).meta({ description: "Signed message", id: "SignedMessageResponse" });
-var zCreateTransactionRequestData = z11.object({
-  accountId: z11.string().min(1).meta({ description: "Target account id" }),
-  transaction: zTransactionData
-}).meta({
-  description: "Create transaction request data",
-  id: "CreateTransactionRequestData"
-});
-var zSignMessageRequestData = z11.object({
-  message: zMessage.meta({ description: "Message to sign" }),
-  accountId: z11.string().min(1).meta({ description: "Target account id" }),
-  address: z11.string().nonempty().meta({ description: "Address with which to sign the message" }),
-  derivationPath: z11.string().nonempty().meta({ description: "Derivation path of the signing address" })
-});
-var zSignMessageUserInputData = zSignMessageRequestData.partial({
-  address: true,
-  derivationPath: true
-});
-var zDigestData = z11.object({
-  digest: zHexString.meta({ description: "The hex string digest to sign" }),
-  derivationPath: z11.string().nonempty().meta({ description: "The derivation path with which to sign the digest" })
-});
-var zSignDigestsRequestData = z11.object({
-  accountId: z11.string().min(1).meta({ description: "Target account id" }),
-  digests: z11.array(zDigestData).meta({ description: "The digests to sign" })
-});
-z11.object({
-  signatures: z11.array(zHsmSignature)
-});
-
-// src/accounts/account-governance-fields.ts
-var zClassicAccountGovernanceFields = z.object({
-  type: z.literal(AccountGovernanceType.CLASSIC).meta({ description: "Classic account governance" }),
-  policyId: z.string().meta({ description: "Identifier of corresponding governance policy" })
-}).meta({ description: "Classic" });
-var zTradelinkAccountGovernanceFields = z.object({
-  type: z.literal(AccountGovernanceType.TRADELINK).meta({ description: "Tradelink account governance" }),
-  assetManagerId: z.string().meta({ description: "Identifier of corresponding asset manager" }),
-  exchangeConfigs: zTradelinkExchangeConfigs.meta({
-    description: "Tradelink exchange configurations"
-  })
-}).meta({ description: "Tradelink" });
-var zAccountGovernanceFields = z.discriminatedUnion("type", [zClassicAccountGovernanceFields, zTradelinkAccountGovernanceFields]).meta({ description: "Governance fields" });
-
-// src/accounts/types.ts
-var zAccountCommonFields = z11.object({
-  id: z11.string().meta({ description: "Internal unique identifier" }),
-  legacyId: z11.number().meta({ description: "Legacy internal unique identifier (for retro-compatibility)" }),
-  name: z11.string().meta({ description: "Name" }),
-  currency: zCurrencyString,
-  network: zNetwork,
-  contractAddress: z11.string().nullable().meta({ description: "Token contract address for Token account" }),
-  index: z11.number().gte(0).meta({ description: "BIP44 account index" }),
-  derivationPath: z11.string().meta({ description: "Derivation path" }),
-  status: z11.enum(ActivationStatus).meta({ description: "Status" }),
-  createdAt: z11.coerce.date().meta({ description: "Creation timestamp" }),
-  updatedAt: z11.coerce.date().meta({ description: "Last modification timestamp" })
-});
-var zRawSigningAssetFields = z11.object({ type: z11.literal(AccountType.RAW_SIGNING).meta({ description: "Account type" }) }).meta({ description: "Raw signing account" });
-var zAccountAssetFields = z11.discriminatedUnion("type", [zRawSigningAssetFields, ...zNetworkAssetFields.options]).meta({ description: "Account asset fields" });
-var zAccountResponse = zAccountCommonFields.extend({
-  asset: zAccountAssetFields,
-  governance: zAccountGovernanceFields
-});
-z11.enum([
-  "name",
-  "currency",
-  "index",
-  "createdAt",
-  "updatedAt"
-]).default("createdAt");
-var zRawSigningLiveData = zCommonLiveData.extend({
-  type: z11.literal(AccountType.RAW_SIGNING).meta({ description: "Account type" })
-}).meta({ description: "Raw signing account" });
-z11.discriminatedUnion("type", [
-  zRawSigningLiveData,
-  ...zAccountLiveData.options
-]);
-z11.object({
-  address: z11.string().meta({ description: "Address" }),
-  derivationPath: z11.string().nullable().meta({ description: "Derivation path" })
-});
-z11.object({
-  amount: zIntString.meta({ description: "Amount in the smallest unit of the currency" }),
-  currency: zCurrency
-});
-z11.object({
-  id: z11.string().nonempty().meta({ description: "Staking position ID (if applicable)" }),
-  validator: z11.string().nonempty().meta({ description: "Validator address" }),
-  state: z11.enum(["ACTIVE", "INACTIVE", "ACTIVATING", "DEACTIVATING", "UNKNOWN"]).meta({ description: "Stake state" }),
-  staked: z11.string().meta({ description: "Staked amount" }),
-  rewards: z11.object({
-    total: z11.string().meta({ description: "Total rewards" })
-  })
-});
-z11.object({
-  address: z11.string().meta({ description: "Validator address" }),
-  apy: z11.string().nullable().meta({ description: "Validator APY" }),
-  balance: z11.string().nullable().meta({ description: "Validator balance" }),
-  commissionRate: z11.string().nullable().meta({ description: "Validator commission rate" }),
-  description: z11.string().nullable().meta({ description: "Description" }),
-  logo: z11.string().nullable().meta({ description: "Logo URL" }),
-  name: z11.string().nullable().meta({ description: "Validator name" }),
-  url: z11.string().nullable().meta({ description: "Validator URL" })
-});
-
-// src/accounts/app-types.ts
-z11.discriminatedUnion(
-  zTransactionResponse._zod.def.discriminator,
-  ensureNonEmptyArray(
-    zTransactionResponse.options.map(
-      (_) => _.extend({
-        note: zNote.nullable().meta({ description: "Optional transaction note" })
-      })
-    )
-  )
-);
-var zWhitelistAddress = z11.object({
-  name: z11.string().min(1).max(50),
-  currency: zCurrencyString,
-  address: z11.string().min(1).max(200),
-  // Destination tags are numeric-only or alpha-numeric.
-  // Empty array (or undefined) means no check on destination tag.
-  destinationTags: z11.array(z11.string().min(1).regex(/^\w+$/)).optional()
-});
-var zWhitelistAddresses = z11.array(zWhitelistAddress);
-var zWhitelistName = z11.string().min(1).max(45).meta({ description: "Whitelist name" });
-var zCreateWhitelistRequestData = z11.object({
-  name: zWhitelistName,
-  description: z11.string().nullable(),
-  addresses: zWhitelistAddresses,
-  type: z11.enum(WhitelistType)
-});
-var zEditWhitelistRequestData = z11.object({
-  name: zWhitelistName,
-  addresses: zWhitelistAddresses
-});
-
-// src/policies/db-utils.ts
-var zBaseGovRuleData = z11.object({
-  // Steps of users that will need to review operations
-  reviewSteps: zReviewStepsArray,
-  // Optional threshold on transaction value: null `min` = 0, null `max` = +inf
-  threshold: policy_exports.zThreshold.optional(),
-  // Optional whitelist on transaction recipient: Empty list means no whitelist.
-  whitelistIds: policy_exports.zWhitelistIds.optional()
-});
-var zClassicGovRuleData = zBaseGovRuleData.extend({
-  operationType: zClassicOperationType.meta({ description: "Allowed operation type" })
-}).meta({ description: "Account governance rule", id: "ClassicGovRuleData" });
-zBaseGovRuleData.extend({
-  operationType: zOperationType.meta({ description: "Allowed operation type" })
-}).meta({ description: "Governance rule", id: "GovRuleResponse" });
-({
-  reviewConfigs: { include: review_config_exports.INCLUDE_MEMBERS }
-});
-var zPolicyName = z11.string().min(1).max(19).meta({ description: "Policy name" });
-var zCurrency2 = z11.string().min(1).max(40).regex(/^\w+$/).meta({ description: "Currency" });
-var zCreatePublicPolicyRequestData = z11.object({
-  name: zPolicyName,
-  description: z11.string().nullable().meta({ description: "Description" }),
-  currency: zCurrency2.nullable(),
-  govRules: z11.array(zClassicGovRuleData).meta({ description: "Governance rules" })
+z9.object({
+  authUserId: z9.string().meta({ description: "Authentication broker ID" })
+}).meta({ description: "Managed data for API user" });
+var zRevokeUserRequestData = z9.object({});
+var zReviewStepWithUsers = z.object({
+  quorum: z.number().min(0).meta({ description: "Number of required approvals for the step" }),
+  userIds: z.array(z.string().min(1)).meta({ description: "User ids in the step" })
+  // PKs to `User` model
+}).meta({ description: "Review step with users" });
+var zReviewStepWithUsersArray = z.array(zReviewStepWithUsers);
+var zReviewStepData = z.union([
+  zReviewStepWithUsers,
+  z.object({
+    quorum: z.number().min(0).meta({ description: "Number of required approvals for the step" }),
+    groupId: z.string().min(1).meta({ description: "Group id in the step" })
+    // PKs to `Group` model
+  }).meta({ description: "Review step with group" })
+]);
+var zReviewStepsArray = z.array(zReviewStepData).min(1).meta({ description: "Review steps" });
+
+// src/prisma-utils/policy.ts
+var policy_exports = {};
+__export(policy_exports, {
+  parseFields: () => parseFields,
+  zGovRuleJsonObject: () => zGovRuleJsonObject,
+  zGovRulesJsonArray: () => zGovRulesJsonArray,
+  zThreshold: () => zThreshold,
+  zWhitelistIds: () => zWhitelistIds
 });
-var zEditPublicPolicyRequestData = z11.object({
-  name: zPolicyName,
-  description: z11.string().nullable().meta({ description: "Description" }),
-  govRules: z11.array(zClassicGovRuleData).meta({ description: "Governance rules" })
+var zNote = z9.object({
+  title: z9.string().meta({ description: "Note title" }),
+  content: z9.string().meta({ description: "Note content" })
 });
-var zAccountName = z11.string().min(1).max(40).meta({ description: "Account name" });
-var zSignDigestsGovRuleData = z11.object({
-  operationType: z11.literal("SIGN_DIGESTS"),
-  reviewSteps: zReviewStepWithUsersArray
-  // we need to control for API users only
-}).meta({ description: "Digest signing rule" });
-var zAccountPolicyRequestData = z11.union([
-  z11.object({ policyId: z11.string() }).meta({ description: "Account policy" }),
-  z11.object({ rules: z11.array(zClassicGovRuleData) }).meta({ description: "Account governance rules" })
-]).meta({ description: "Account policy or governance rules" });
-var zCreateAccountGovernanceData = z11.discriminatedUnion("type", [
-  z11.object({
-    type: z11.literal(AccountGovernanceType.CLASSIC),
-    policy: zAccountPolicyRequestData
-  }).meta({ description: "Classic governance" }),
-  z11.object({
-    type: z11.literal(AccountGovernanceType.TRADELINK),
-    assetManagerId: z11.string(),
-    exchangeConfigs: zTradelinkExchangeConfigs
-  }).meta({ description: "Tradelink governance" }),
-  z11.object({
-    type: z11.literal(AccountGovernanceType.RAW_SIGNING),
-    policy: z11.object({ rules: z11.array(zSignDigestsGovRuleData) })
-  }).meta({ description: "Raw signing governance" })
-]).meta({ description: "Governance fields" });
-var zCreateAccountUserInputData = z11.object({
-  name: zAccountName,
+var zValueTransactionOperationType = z.enum([
+  AllowedAction.SEND,
+  AllowedAction.STAKE,
+  AllowedAction.DEPLOY_CONTRACT,
+  AllowedAction.EXECUTE_CONTRACT,
+  AllowedAction.ACTIVATE_TOKEN,
+  AllowedAction.RECEIVE
+]);
+var zValueTransactionOperation = z.object({
+  type: zValueTransactionOperationType,
   currency: zCurrencyString,
-  // "bitcoin"
-  index: z11.number().nonnegative().optional().meta({ description: "Account index" }),
-  contractAddress: z11.string().min(1).optional().meta({ description: "Account contract address" }),
-  governance: zCreateAccountGovernanceData
-});
-var zCreateAccountRequestData = zCreateAccountUserInputData.omit({ index: true }).extend({
-  index: z11.number().nonnegative().meta({ description: "Account index" }),
-  derivationPath: z11.string().meta({ description: "Account bip44 derivation path" }),
-  type: z11.enum(AccountType)
-  // "BITCOIN_LIKE"
-}).meta({
-  description: "Create account request data",
-  id: "CreateAccountRequestData"
-});
-var zEditAccountGovernanceData = z11.discriminatedUnion("type", [
-  z11.object({
-    type: z11.literal(AccountGovernanceType.CLASSIC),
-    policy: zAccountPolicyRequestData
-  }).meta({ description: "Classic governance" }),
-  z11.object({
-    type: z11.literal(AccountGovernanceType.TRADELINK),
-    exchangeConfigs: zTradelinkExchangeConfigs
-  }).meta({ description: "Tradelink governance" }),
-  z11.object({
-    type: z11.literal(AccountGovernanceType.RAW_SIGNING),
-    policy: z11.object({ rules: z11.array(zSignDigestsGovRuleData) })
-  }).meta({ description: "Raw signing governance" })
-]).meta({ description: "Governance fields" });
-var zEditAccountRequestData = z11.object({
-  name: zAccountName,
-  governance: zEditAccountGovernanceData
-}).meta({
-  description: "Edit account request data",
-  id: "EditAccountRequestData"
+  recipient: z.string().nonempty(),
+  destinationTag: z.string().nonempty().optional(),
+  value: zUnsignedIntString
 });
-var zEditTokenRuleRequestData = z11.object({
-  parentAccountId: z11.string().min(1).meta({ description: "Parent account unique ID" }),
-  contractAddress: z11.string().min(1).meta({ description: "Token contract address" }),
-  rules: z11.array(zClassicGovRuleData).meta({ description: "Account governance rules" })
+var zSigningOperationType = z.enum([AllowedAction.SIGN_MESSAGE, AllowedAction.SIGN_DIGESTS]);
+var zSigningOperation = z.object({
+  type: zSigningOperationType
 });
+var zClassicOperationType = z.enum([
+  AllowedAction.SEND,
+  AllowedAction.STAKE,
+  AllowedAction.DEPLOY_CONTRACT,
+  AllowedAction.EXECUTE_CONTRACT,
+  AllowedAction.SIGN_MESSAGE,
+  AllowedAction.ACTIVATE_TOKEN,
+  AllowedAction.RECEIVE
+]);
+z.enum([AllowedAction.SIGN_DIGESTS]);
+var zOperationType = z.enum([
+  ...zValueTransactionOperationType.options,
+  ...zSigningOperationType.options
+]);
+z.discriminatedUnion("type", [
+  zValueTransactionOperation,
+  zSigningOperation
+]);
 
-// src/accounts/app-utils.ts
-var getAccountAssetFields = (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,
-        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.SUI_LIKE:
-      return {
-        type: account.type,
-        address: account.address
-      };
-    case AccountType.RIPPLE_LIKE:
-      return {
-        type: account.type,
-        address: account.address
-      };
-    case AccountType.POLKADOT_LIKE:
-      return {
-        type: account.type,
-        address: account.address
-      };
-    case AccountType.TRON_LIKE:
-      return {
-        type: account.type,
-        address: account.address,
-        contractAddress: account.contractAddress
-      };
-    case AccountType.GENERIC_LIKE:
-    case AccountType.RAW_SIGNING:
-      return {
-        type: account.type
-      };
-    case AccountType.CANTON_LIKE:
-      return {
-        type: account.type,
-        address: account.address
-      };
-    /* v8 ignore start */
-    default:
-      unreachable(account.type);
-  }
-};
-var getAccountGovernanceFields = (account) => {
-  switch (account.governanceType) {
-    case AccountGovernanceType.CLASSIC:
-    case AccountGovernanceType.RAW_SIGNING:
-      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 = getAccountAssetFields(account);
-  const governance = getAccountGovernanceFields(account);
-  const response = {
-    ...account,
-    network: account.currency,
-    legacyId: account.gateId,
-    governance,
-    asset
-  };
-  return zAccountResponse.parse(response);
+// src/prisma-utils/policy.ts
+var zThreshold = z.object({
+  min: zUnsignedIntString.nullable().meta({ description: "Minimum transaction amount" }),
+  max: zUnsignedIntString.nullable().meta({ description: "Maximum transaction amount" })
+}).meta({ description: "Threshold for the transaction value" });
+var zWhitelistIds = z.array(z.string().min(1)).meta({ description: "IDs of whitelists for the recipient address" });
+var zGovRuleJsonObject = z.object({
+  // Required.
+  operationType: zOperationType.meta({ description: "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: z.string().min(1).meta({ description: "Id of ReviewConfig" }),
+  // HSM id for the rule
+  hsmId: zHsmObjectId
+}).meta({ description: "INTERNAL: Governance rule JSON representation in DB" });
+var zGovRulesJsonArray = z.array(zGovRuleJsonObject);
+var parseFields = (policy) => {
+  const rulesJsonArray = zGovRulesJsonArray.parse(policy.rulesJsonArray);
+  return { ...policy, rulesJsonArray };
 };
 
-// src/compat/patch-request-expired-at.ts
-var patchRequestExpiredAt = (data) => ({
-  ...data,
-  expiredAt: data.expiresAt
+// src/prisma-utils/review-config.ts
+var review_config_exports = {};
+__export(review_config_exports, {
+  INCLUDE_MEMBERS: () => INCLUDE_MEMBERS
 });
-var patchTezosRequestData = (data) => {
-  if (data.type !== RequestType.CREATE_TRANSACTION) {
-    return data;
-  }
-  const transaction = get(data, ["data", "transaction"]);
-  if (!isRecord(transaction)) {
-    return data;
-  }
-  if (transaction.type === "TEZOS_LIKE_DELEGATE") {
-    transaction.amount = transaction.amount ?? "0";
-  } else if (transaction.type === "TEZOS_LIKE_UNDELEGATE") {
-    transaction.amount = transaction.amount ?? "0";
-    transaction.recipient = transaction.recipient ?? "0";
+var INCLUDE_MEMBERS = {
+  users: true,
+  groups: {
+    include: { members: true }
   }
-  return data;
 };
-var zSciConfigData = z11.object({
-  dapps: z11.array(z11.string()).nullable().meta({ description: "Allowed DApps, null allows all" }),
-  customContractCallEnabled: z11.boolean().meta({ description: "Allow non-DApp SCI" })
+var zUpdateQuorumRequestData = z9.object({
+  quorum: z9.number().int().min(2).meta({ description: "Workspace quorum" })
+});
+var NonRootAdminPermission = omit(AdminPermission, "ROOT");
+var zWorkspaceRuleRequestData = z9.object({
+  permission: z9.enum(NonRootAdminPermission).meta({ description: "Granted permissions" }),
+  reviewConfig: zReviewStepWithUsersArray.meta({ description: "List of admin review steps" })
+});
+z9.discriminatedUnion(
+  zTransactionResponse._zod.def.discriminator,
+  ensureNonEmptyArray(
+    zTransactionResponse.options.map((_) => _.extend({ note: zNote.nullable() }))
+  )
+);
+var zMessageType = z9.enum(MessageType).meta({ description: "Type of the message to sign" });
+var zMessageData = zHexString.nonempty().meta({
+  description: "Hex data to sign, either a json string for EIP712, or a raw string for EIP191"
+});
+var zMessage = z9.object({
+  type: zMessageType,
+  data: zMessageData
+});
+z9.object({
+  id: z9.string().meta({ description: "Unique identifier" }),
+  type: zMessageType,
+  data: zMessageData,
+  address: z9.string().meta({ description: "Address of the signing key" }),
+  derivationPath: z9.string().meta({ description: "Derivation path of the signing key" }),
+  signature: zHsmSignature.meta({ description: "Signature of the message" }),
+  createdById: z9.string().meta({ description: "ID of the creator" }),
+  createdAt: z9.coerce.date().meta({ description: "Creation timestamp" })
+}).meta({ description: "Signed message", id: "SignedMessageResponse" });
+var zCreateTransactionRequestData = z9.object({
+  accountId: z9.string().min(1).meta({ description: "Target account id" }),
+  transaction: zTransactionData
+}).meta({
+  description: "Create transaction request data",
+  id: "CreateTransactionRequestData"
 });
-var zCreateSciConfigRequestData = z11.object({
-  account: z11.string().meta({ description: "Account UUID" }),
-  config: zSciConfigData
+var zSignMessageRequestData = z9.object({
+  message: zMessage.meta({ description: "Message to sign" }),
+  accountId: z9.string().min(1).meta({ description: "Target account id" }),
+  address: z9.string().nonempty().meta({ description: "Address with which to sign the message" }),
+  derivationPath: z9.string().nonempty().meta({ description: "Derivation path of the signing address" })
 });
-var zEditSciConfigRequestData = z11.object({
-  config: zSciConfigData
+var zSignMessageUserInputData = zSignMessageRequestData.partial({
+  address: true,
+  derivationPath: true
 });
-var zRequestReviewStep = z.object({
-  stageName: z.string().regex(/^\w+$/).meta({ description: "The review stage name" }),
-  quorum: z.int().min(1).meta({ description: "Quorum for the review step" })
+var zDigestData = z9.object({
+  digest: zHexString.meta({ description: "The hex string digest to sign" }),
+  derivationPath: z9.string().nonempty().meta({ description: "The derivation path with which to sign the digest" })
 });
-var zRequestReviewSteps = z.array(zRequestReviewStep);
-var zGroupName = z11.string().min(1).max(19).meta({ description: "Group name" });
-var zCreateGroupRequestData = z11.object({
-  name: zGroupName,
-  description: z11.string().nullable().meta({ description: "Group description" }),
-  members: z11.array(z11.string()).meta({ description: "List of group members ids" })
+var zSignDigestsRequestData = z9.object({
+  accountId: z9.string().min(1).meta({ description: "Target account id" }),
+  digests: z9.array(zDigestData).meta({ description: "The digests to sign" })
 });
-var zEditGroupRequestData = z11.object({
-  name: zGroupName,
-  description: z11.string().nullable().meta({ description: "Group description" }),
-  members: z11.array(z11.string()).meta({ description: "List of group members ids" })
+z9.object({
+  signatures: z9.array(zHsmSignature)
 });
-var zApiKeyName = z11.string().min(1).max(19).meta({ description: "API key name" });
-var zCreateApiKeyRequestData = z11.object({
-  name: zApiKeyName,
-  entities: z11.array(z11.string()).meta({ description: "List of related entities ids" }),
-  scopes: z11.object({}).meta({ description: "FIXME to be precised" })
-}).meta({ description: "Create read-only API key request data" });
-var zEditApiKeyRequestData = zCreateApiKeyRequestData.meta({
-  description: "Edit read-only API key request data"
+var zTradelinkWhitelistAddress = z9.object({
+  name: z9.string().min(1),
+  currency: zCurrencyString,
+  address: z9.string().min(1)
 });
-var zEntityName = z11.string().min(1).max(19).meta({ description: "Entity name" });
-var zCreateEntityRequestData = z11.object({
-  name: zEntityName,
-  accounts: z11.array(z11.string())
+z9.array(zTradelinkWhitelistAddress);
+var zTradelinkId = z9.string().meta({ description: "Unique identifier in Tradelink service" });
+var zTradelinkOrgEntityResponse = z9.object({
+  tradelinkId: zTradelinkId,
+  name: z9.string().meta({ description: "Name" }),
+  code: z9.string().meta({ description: "Code" }),
+  logoUrl: z9.string().meta({ description: "Logo URL" })
 });
-var zEditEntityRequestData = z11.object({
-  name: zEntityName,
-  accounts: z11.array(z11.string())
+zTradelinkOrgEntityResponse.omit({
+  tradelinkId: true
 });
-
-// src/requests/request-data.ts
-var zVaultRequestMixinsByType = {
-  // Workspaces
-  [RequestType.UPDATE_QUORUM]: z11.object({
-    type: z11.literal(RequestType.UPDATE_QUORUM),
-    data: zUpdateQuorumRequestData
-  }),
-  // Operator requests
-  [RequestType.CREATE_TRANSACTION]: z11.object({
-    type: z11.literal(RequestType.CREATE_TRANSACTION),
-    data: zCreateTransactionRequestData,
-    meta: z11.object({
-      hash: z11.string().nullable()
-    }).optional().nullable()
-  }),
-  [RequestType.SIGN_MESSAGE]: z11.object({
-    type: z11.literal(RequestType.SIGN_MESSAGE),
-    data: zSignMessageRequestData
-  }),
-  [RequestType.SIGN_DIGESTS]: z11.object({
-    type: z11.literal(RequestType.SIGN_DIGESTS),
-    data: zSignDigestsRequestData
-  }),
-  // Accounts
-  [RequestType.CREATE_ACCOUNT]: z11.object({
-    type: z11.literal(RequestType.CREATE_ACCOUNT),
-    data: zCreateAccountRequestData
-  }),
-  [RequestType.EDIT_ACCOUNT]: z11.object({
-    type: z11.literal(RequestType.EDIT_ACCOUNT),
-    targetId: z11.string(),
-    data: zEditAccountRequestData
-  }),
-  [RequestType.EDIT_TOKEN_RULE]: z11.object({
-    type: z11.literal(RequestType.EDIT_TOKEN_RULE),
-    targetId: z11.string(),
-    data: zEditTokenRuleRequestData
-  }),
-  // Groups
-  [RequestType.CREATE_GROUP]: z11.object({
-    type: z11.literal(RequestType.CREATE_GROUP),
-    data: zCreateGroupRequestData
-  }),
-  [RequestType.EDIT_GROUP]: z11.object({
-    type: z11.literal(RequestType.EDIT_GROUP),
-    targetId: z11.string(),
-    data: zEditGroupRequestData
-  }),
-  [RequestType.REVOKE_GROUP]: z11.object({
-    type: z11.literal(RequestType.REVOKE_GROUP),
-    targetId: z11.string(),
-    data: zRevokeUserRequestData
-  }),
-  // Whitelists
-  [RequestType.CREATE_WHITELIST]: z11.object({
-    type: z11.literal(RequestType.CREATE_WHITELIST),
-    data: zCreateWhitelistRequestData
-  }),
-  [RequestType.EDIT_WHITELIST]: z11.object({
-    type: z11.literal(RequestType.EDIT_WHITELIST),
-    targetId: z11.string(),
-    data: zEditWhitelistRequestData
-  }),
-  // Entities
-  [RequestType.CREATE_ENTITY]: z11.object({
-    type: z11.literal(RequestType.CREATE_ENTITY),
-    data: zCreateEntityRequestData
-  }),
-  [RequestType.EDIT_ENTITY]: z11.object({
-    type: z11.literal(RequestType.EDIT_ENTITY),
-    data: zEditEntityRequestData
-  }),
-  [RequestType.REVOKE_ENTITY]: z11.object({
-    type: z11.literal(RequestType.REVOKE_ENTITY),
-    data: z11.object({})
+z9.object({
+  tradelinkId: zTradelinkId
+});
+var zTradelinkExchangeConfig = z9.object({
+  exchangeId: z9.string().meta({ description: "Tradelink exchange id" }),
+  repledgeAuthorized: z9.boolean().meta({
+    description: "Determines whether this exchange is authorized to repledge on this account"
   }),
-  // Users
-  [RequestType.CREATE_PSD_USER]: z11.object({
-    type: z11.literal(RequestType.CREATE_PSD_USER),
-    data: zCreatePsdUserRequestData
+  needsAssetManagerApprovalForSettlements: z9.boolean().meta({
+    description: 'Determines whether asset manager will "pre-approve" the settlement requests on this account'
+  })
+});
+var zTradelinkExchangeConfigs = z9.array(zTradelinkExchangeConfig);
+z9.object({
+  workspaceName: zWorkspaceName,
+  custodian: z9.object({ name: z9.string() }),
+  assetManagers: z9.array(z9.object({ name: z9.string() })),
+  exchanges: z9.array(z9.object({ name: z9.string() }))
+});
+z9.object({
+  tradelinkId: z9.string(),
+  workspaceName: zWorkspaceName,
+  custodian: zTradelinkOrgEntityResponse,
+  assetManagers: z9.array(zTradelinkOrgEntityResponse),
+  exchanges: z9.array(zTradelinkOrgEntityResponse)
+});
+var zTradelinkAsset = z9.object({
+  name: z9.string(),
+  magnitude: z9.number().int().nonnegative()
+});
+z9.object({
+  tradelinkId: zTradelinkId,
+  asset: zTradelinkAsset,
+  state: z9.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: z9.boolean(),
+  amount: z9.string().meta({ description: "Currently pledged amount" }),
+  pending: z9.string().meta({ description: "Requested pledge increment, not yet approved" }),
+  repledge: z9.string().meta({ description: "TODO: describe this field" }),
+  exchangeTradelinkId: z9.string(),
+  accountId: z9.string()
+});
+z9.object({
+  workspaceName: z9.string(),
+  clientAccountId: z9.string().meta({ description: "Account ID from the client side" }),
+  exchangeTradelinkId: zTradelinkId,
+  asset: zTradelinkAsset
+});
+z9.object({
+  pledgeTradelinkId: zTradelinkId,
+  amount: zUnsignedIntString,
+  asset: zTradelinkAsset
+});
+z9.object({
+  tradelinkId: z9.string(),
+  pledgeTradelinkId: z9.string(),
+  state: z9.enum([
+    "REGISTERED",
+    "PENDING_REPLEDGE_CREATION_APPROVAL",
+    "PENDING_REPLEDGE_APPROVAL",
+    "PENDING_CREATION_APPROVAL",
+    "PENDING_PRE_APPROVAL",
+    "PRE_APPROVED",
+    "APPROVED",
+    "REJECTED",
+    "CONFIRMED",
+    "FAILED",
+    "CANCELED"
+  ]),
+  // For now we only consider the outbound settlement
+  outboundTransactionHash: z9.string().nullable()
+});
+var zTradelinkActivateAccountRequestData = z9.null();
+var zTradelinkCustodianRequestData = z9.object({
+  settlement: zReviewStepWithUsersArray.meta({ description: "List of settlement review steps" }),
+  withdraw: zReviewStepWithUsersArray.meta({ description: "List of withdraw review steps" }),
+  arbitration: zReviewStepWithUsersArray.meta({ description: "List of arbitration review steps" })
+});
+var zTradelinkEntityRequestData = z9.object({
+  tradelinkId: z9.string().min(1),
+  groups: zReviewStepWithUsersArray.meta({ description: "List of asset manager review groups" }),
+  whitelist: z9.array(zTradelinkWhitelistAddress).meta({ description: "List of asset manager whitelisted addresses" })
+});
+var zTradelinkAdjustPledgeRequestData = z9.object({
+  accountId: z9.string().meta({ description: "Account id" }),
+  exchangeId: z9.string().meta({ description: "Exchange id" }),
+  amount: zIntString.meta({ description: "Amount to add to pledge" })
+});
+var zTradelinkRepledgeRequestData = z9.object({
+  accountId: z9.string().meta({ description: "Account id" }),
+  exchangeId: z9.string().meta({ description: "Exchange id" }),
+  amount: zIntString.meta({ description: "Amount to add to pledge" })
+});
+var zTradelinkCreateSettlementRequestData = z9.object({
+  accountId: z9.string().meta({ description: "Account id" }),
+  exchangeId: z9.string().meta({ description: "Exchange id" }),
+  transaction: zSendOnlyTransactionData
+});
+var zTradelinkForceUnpledgeRequestData = z9.object({
+  accountId: z9.string().meta({ description: "Account id" }),
+  exchangeId: z9.string().meta({ description: "Exchange id" })
+});
+var zTradelinkWithdrawRequestData = z9.object({
+  accountId: z9.string().meta({ description: "Account id" }),
+  transaction: zSendOnlyTransactionData
+});
+var zTradelinkArbitrationRequestData = z9.object({
+  accountId: z9.string().meta({ description: "Account id" }),
+  transaction: zSendOnlyTransactionData
+});
+var zTradelinkRequestMixinsByType = {
+  [RequestType.TRADELINK_ACTIVATE_ACCOUNT]: z9.object({
+    type: z9.literal(RequestType.TRADELINK_ACTIVATE_ACCOUNT),
+    targetId: z9.string(),
+    data: zTradelinkActivateAccountRequestData
   }),
-  [RequestType.CREATE_API_USER]: z11.object({
-    type: z11.literal(RequestType.CREATE_API_USER),
-    data: zCreateApiUserRequestData
+  [RequestType.TRADELINK_CREATE_CUSTODIAN]: z9.object({
+    type: z9.literal(RequestType.TRADELINK_CREATE_CUSTODIAN),
+    data: zTradelinkCustodianRequestData
   }),
-  [RequestType.CREATE_API_USER_ACCESS]: z11.object({
-    type: z11.literal(RequestType.CREATE_API_USER_ACCESS),
-    data: zCreateApiUserAccessRequestData
+  [RequestType.TRADELINK_EDIT_CUSTODIAN]: z9.object({
+    type: z9.literal(RequestType.TRADELINK_EDIT_CUSTODIAN),
+    targetId: z9.string(),
+    data: zTradelinkCustodianRequestData
   }),
-  [RequestType.REVOKE_USER]: z11.object({
-    type: z11.literal(RequestType.REVOKE_USER),
-    targetId: z11.string(),
-    data: zRevokeUserRequestData
+  [RequestType.TRADELINK_CREATE_EXCHANGE]: z9.object({
+    type: z9.literal(RequestType.TRADELINK_CREATE_EXCHANGE),
+    data: zTradelinkEntityRequestData
   }),
-  // Admin gov rules
-  [RequestType.EDIT_WORKSPACE_RULE]: z11.object({
-    type: z11.literal(RequestType.EDIT_WORKSPACE_RULE),
-    data: zWorkspaceRuleRequestData
+  [RequestType.TRADELINK_EDIT_EXCHANGE]: z9.object({
+    type: z9.literal(RequestType.TRADELINK_EDIT_EXCHANGE),
+    targetId: z9.string(),
+    data: zTradelinkEntityRequestData
   }),
-  // SCI configs
-  [RequestType.CREATE_SCICONFIG]: z11.object({
-    type: z11.literal(RequestType.CREATE_SCICONFIG),
-    data: zCreateSciConfigRequestData
+  [RequestType.TRADELINK_CREATE_ASSET_MANAGER]: z9.object({
+    type: z9.literal(RequestType.TRADELINK_CREATE_ASSET_MANAGER),
+    data: zTradelinkEntityRequestData
   }),
-  [RequestType.EDIT_SCICONFIG]: z11.object({
-    type: z11.literal(RequestType.EDIT_SCICONFIG),
-    data: zEditSciConfigRequestData
+  [RequestType.TRADELINK_EDIT_ASSET_MANAGER]: z9.object({
+    type: z9.literal(RequestType.TRADELINK_EDIT_ASSET_MANAGER),
+    targetId: z9.string(),
+    data: zTradelinkEntityRequestData
   }),
-  // API keys
-  [RequestType.CREATE_API_KEY]: z11.object({
-    type: z11.literal(RequestType.CREATE_API_KEY),
-    data: zCreateApiKeyRequestData
+  [RequestType.TRADELINK_ADJUST_PLEDGE]: z9.object({
+    type: z9.literal(RequestType.TRADELINK_ADJUST_PLEDGE),
+    data: zTradelinkAdjustPledgeRequestData
   }),
-  [RequestType.EDIT_API_KEY]: z11.object({
-    type: z11.literal(RequestType.EDIT_API_KEY),
-    data: zEditApiKeyRequestData
+  [RequestType.TRADELINK_REPLEDGE]: z9.object({
+    type: z9.literal(RequestType.TRADELINK_REPLEDGE),
+    data: zTradelinkRepledgeRequestData
   }),
-  [RequestType.REVOKE_API_KEY]: z11.object({
-    type: z11.literal(RequestType.REVOKE_API_KEY),
-    data: z11.object({})
+  [RequestType.TRADELINK_CREATE_SETTLEMENT]: z9.object({
+    type: z9.literal(RequestType.TRADELINK_CREATE_SETTLEMENT),
+    data: zTradelinkCreateSettlementRequestData,
+    meta: z9.object({
+      hash: z9.string().nullable()
+    }).optional().nullable()
   }),
-  // Policies
-  [RequestType.CREATE_POLICY]: z11.object({
-    type: z11.literal(RequestType.CREATE_POLICY),
-    data: zCreatePublicPolicyRequestData
+  [RequestType.TRADELINK_FORCE_UNPLEDGE]: z9.object({
+    type: z9.literal(RequestType.TRADELINK_FORCE_UNPLEDGE),
+    data: zTradelinkForceUnpledgeRequestData
   }),
-  [RequestType.EDIT_POLICY]: z11.object({
-    type: z11.literal(RequestType.EDIT_POLICY),
-    targetId: z11.string(),
-    data: zEditPublicPolicyRequestData
+  [RequestType.TRADELINK_WITHDRAW]: z9.object({
+    type: z9.literal(RequestType.TRADELINK_WITHDRAW),
+    data: zTradelinkWithdrawRequestData,
+    meta: z9.object({
+      hash: z9.string().nullable()
+    }).optional().nullable()
   }),
-  // Tradelink-related requests
-  ...zTradelinkRequestMixinsByType
+  [RequestType.TRADELINK_ARBITRATE]: z9.object({
+    type: z9.literal(RequestType.TRADELINK_ARBITRATE),
+    data: zTradelinkArbitrationRequestData,
+    meta: z9.object({
+      hash: z9.string().nullable()
+    }).optional().nullable()
+  })
 };
 
-// src/requests/app-types.ts
-var zRequestReviewResponse = z11.object({
-  // Note: Do NOT include `quorum` as it is already available in the request's `reviewSteps` field.
-  stepIndex: z11.number().int().meta({ description: "Index of the governance step in the request workflow" }),
-  userId: z11.string().meta({ description: "Reviewer id" }),
-  status: z11.enum(RequestReviewStatus).meta({ description: "Review status" }),
-  createdAt: z11.coerce.date().meta({ description: "Created date" }),
-  updatedAt: z11.coerce.date().meta({ description: "Updated date" })
-});
-var zVaultRequestCommonMixin = z11.object({
-  id: z11.string().meta({ description: "Request unique identifier" }),
-  legacyId: z11.number().meta({ description: "Legacy internal unique identifier (for retro-compatibility)" }),
-  state: z11.enum(RequestState).meta({ description: "Request state" }),
-  reviewSteps: zRequestReviewSteps.meta({ description: "Request review steps" }),
-  currentStepIndex: z11.number().int().min(0).meta({ description: "Index of the current approval step" }),
-  expiresAt: z11.coerce.date().meta({ description: "Request expiration date" }),
-  expiredAt: z11.coerce.date().optional().meta({ description: "Deprecated: use expiresAt" }),
-  targetId: z11.string().nullable().meta({ description: "Optional ID of the target object" }),
-  note: zNote.nullable().meta({ description: "Optional request note" }),
-  reviews: z11.array(zRequestReviewResponse).meta({ description: "Requests reviews" }),
-  // `type` and `data` are correlated -- See `zVaultRequestMixinsByType`
-  createdAt: z11.coerce.date().meta({ description: "Creation timestamp" }),
-  updatedAt: z11.coerce.date().meta({ description: "Last modification timestamp" }),
-  createdById: z11.string().meta({ description: "ID of the user who created the request" }),
-  // `inflight` is fetched from ONGOING RequestSaga
-  inflight: z11.object({
-    lastError: z11.string().nullable().meta({ description: "Error message from the last failure" }),
-    numFailed: z11.number().int().meta({ description: "Number of failures so far" }),
-    retryAfter: z11.coerce.date().meta({ description: "Date after which next retry is scheduled" })
-  }).optional().meta({ description: "Extra information if the request is currently being processed" })
-});
-var allowedRequestCreationInputByType = {
-  [RequestType.UPDATE_QUORUM]: zVaultRequestMixinsByType[RequestType.UPDATE_QUORUM],
-  [RequestType.CREATE_PSD_USER]: zVaultRequestMixinsByType[RequestType.CREATE_PSD_USER],
-  [RequestType.CREATE_API_USER]: zVaultRequestMixinsByType[RequestType.CREATE_API_USER],
-  [RequestType.CREATE_GROUP]: zVaultRequestMixinsByType[RequestType.CREATE_GROUP],
-  [RequestType.EDIT_GROUP]: zVaultRequestMixinsByType[RequestType.EDIT_GROUP],
-  [RequestType.CREATE_WHITELIST]: zVaultRequestMixinsByType[RequestType.CREATE_WHITELIST],
-  [RequestType.EDIT_WHITELIST]: zVaultRequestMixinsByType[RequestType.EDIT_WHITELIST],
-  [RequestType.CREATE_TRANSACTION]: zVaultRequestMixinsByType[RequestType.CREATE_TRANSACTION],
-  [RequestType.SIGN_MESSAGE]: z11.object({
-    type: z11.literal(RequestType.SIGN_MESSAGE),
-    data: zSignMessageUserInputData
-  }),
-  [RequestType.CREATE_POLICY]: zVaultRequestMixinsByType[RequestType.CREATE_POLICY],
-  [RequestType.EDIT_POLICY]: zVaultRequestMixinsByType[RequestType.EDIT_POLICY],
-  [RequestType.CREATE_ACCOUNT]: z11.object({
-    type: z11.literal(RequestType.CREATE_ACCOUNT),
-    data: zCreateAccountUserInputData
-  }),
-  [RequestType.EDIT_ACCOUNT]: zVaultRequestMixinsByType[RequestType.EDIT_ACCOUNT],
-  [RequestType.TRADELINK_ACTIVATE_ACCOUNT]: zVaultRequestMixinsByType[RequestType.TRADELINK_ACTIVATE_ACCOUNT],
-  [RequestType.TRADELINK_CREATE_CUSTODIAN]: zVaultRequestMixinsByType[RequestType.TRADELINK_CREATE_CUSTODIAN],
-  [RequestType.TRADELINK_EDIT_CUSTODIAN]: zVaultRequestMixinsByType[RequestType.TRADELINK_EDIT_CUSTODIAN],
-  [RequestType.TRADELINK_CREATE_EXCHANGE]: zVaultRequestMixinsByType[RequestType.TRADELINK_CREATE_EXCHANGE],
-  [RequestType.TRADELINK_EDIT_EXCHANGE]: zVaultRequestMixinsByType[RequestType.TRADELINK_EDIT_EXCHANGE],
-  [RequestType.TRADELINK_CREATE_ASSET_MANAGER]: zVaultRequestMixinsByType[RequestType.TRADELINK_CREATE_ASSET_MANAGER],
-  [RequestType.TRADELINK_EDIT_ASSET_MANAGER]: zVaultRequestMixinsByType[RequestType.TRADELINK_EDIT_ASSET_MANAGER],
-  [RequestType.TRADELINK_ADJUST_PLEDGE]: zVaultRequestMixinsByType[RequestType.TRADELINK_ADJUST_PLEDGE],
-  [RequestType.TRADELINK_REPLEDGE]: zVaultRequestMixinsByType[RequestType.TRADELINK_REPLEDGE],
-  [RequestType.TRADELINK_FORCE_UNPLEDGE]: zVaultRequestMixinsByType[RequestType.TRADELINK_FORCE_UNPLEDGE],
-  [RequestType.TRADELINK_CREATE_SETTLEMENT]: zVaultRequestMixinsByType[RequestType.TRADELINK_CREATE_SETTLEMENT],
-  [RequestType.TRADELINK_WITHDRAW]: zVaultRequestMixinsByType[RequestType.TRADELINK_WITHDRAW],
-  [RequestType.TRADELINK_ARBITRATE]: zVaultRequestMixinsByType[RequestType.TRADELINK_ARBITRATE],
-  [RequestType.REVOKE_USER]: zVaultRequestMixinsByType[RequestType.REVOKE_USER],
-  [RequestType.EDIT_WORKSPACE_RULE]: zVaultRequestMixinsByType[RequestType.EDIT_WORKSPACE_RULE]
-};
-var zRequestCreationInputCommonMixin = z11.object({
-  note: zNote.optional().meta({ description: "Optional request note" })
-});
-z11.object({
-  request: z11.discriminatedUnion(
-    "type",
-    ensureNonEmptyArray(
-      Object.values(allowedRequestCreationInputByType).map((_) => {
-        const requestType = _.shape.type.value;
-        return _.extend(zRequestCreationInputCommonMixin.shape).meta({
-          description: `${requestType} request data`
-        });
-      })
-    )
-  )
-});
-var zVaultRequestResponse = z11.discriminatedUnion(
-  "type",
-  ensureNonEmptyArray(
-    Object.values(zVaultRequestMixinsByType).map((_) => {
-      const requestType = _.shape.type.value;
-      return _.extend(zVaultRequestCommonMixin.shape).meta({
-        description: `${requestType} request`
-      });
-    })
-  )
-).meta({
-  description: "Vault request response data",
-  id: "VaultRequestResponse"
+// src/accounts/account-governance-fields.ts
+var zClassicAccountGovernanceFields = z.object({
+  type: z.literal(AccountGovernanceType.CLASSIC).meta({ description: "Classic account governance" }),
+  policyId: z.string().meta({ description: "Identifier of corresponding governance policy" })
+}).meta({ description: "Classic" });
+var zTradelinkAccountGovernanceFields = z.object({
+  type: z.literal(AccountGovernanceType.TRADELINK).meta({ description: "Tradelink account governance" }),
+  assetManagerId: z.string().meta({ description: "Identifier of corresponding asset manager" }),
+  exchangeConfigs: zTradelinkExchangeConfigs.meta({
+    description: "Tradelink exchange configurations"
+  })
+}).meta({ description: "Tradelink" });
+var zAccountGovernanceFields = z.discriminatedUnion("type", [zClassicAccountGovernanceFields, zTradelinkAccountGovernanceFields]).meta({ description: "Governance fields" });
+
+// src/accounts/types.ts
+var zAccountCommonFields = z9.object({
+  id: z9.string().meta({ description: "Internal unique identifier" }),
+  legacyId: z9.number().meta({ description: "Legacy internal unique identifier (for retro-compatibility)" }),
+  name: z9.string().meta({ description: "Name" }),
+  currency: zCurrencyString,
+  network: zNetwork,
+  contractAddress: z9.string().nullable().meta({ description: "Token contract address for Token account" }),
+  index: z9.number().gte(0).meta({ description: "BIP44 account index" }),
+  derivationPath: z9.string().meta({ description: "Derivation path" }),
+  status: z9.enum(ActivationStatus).meta({ description: "Status" }),
+  createdAt: z9.coerce.date().meta({ description: "Creation timestamp" }),
+  updatedAt: z9.coerce.date().meta({ description: "Last modification timestamp" })
+});
+var zRawSigningAssetFields = z9.object({ type: z9.literal(AccountType.RAW_SIGNING).meta({ description: "Account type" }) }).meta({ description: "Raw signing account" });
+var zAccountAssetFields = z9.discriminatedUnion("type", [zRawSigningAssetFields, ...zNetworkAssetFields.options]).meta({ description: "Account asset fields" });
+var zAccountResponse = zAccountCommonFields.extend({
+  asset: zAccountAssetFields,
+  governance: zAccountGovernanceFields
 });
-z11.enum([
-  "state",
-  "expiresAt",
+z9.enum([
+  "name",
+  "currency",
+  "index",
   "createdAt",
   "updatedAt"
 ]).default("createdAt");
-z11.object({
-  pubKey: z11.string().meta({ description: "Public key of the current user" }),
-  challenge: zUserChallenge.meta({
-    description: "Challenge data to sign with the user's private key"
+var zRawSigningLiveData = zCommonLiveData.extend({
+  type: z9.literal(AccountType.RAW_SIGNING).meta({ description: "Account type" })
+}).meta({ description: "Raw signing account" });
+z9.discriminatedUnion("type", [
+  zRawSigningLiveData,
+  ...zAccountLiveData.options
+]);
+z9.object({
+  address: z9.string().meta({ description: "Address" }),
+  derivationPath: z9.string().nullable().meta({ description: "Derivation path" })
+});
+z9.object({
+  amount: zIntString.meta({ description: "Amount in the smallest unit of the currency" }),
+  currency: zCurrency
+});
+z9.object({
+  id: z9.string().nonempty().meta({ description: "Staking position ID (if applicable)" }),
+  validator: z9.string().nonempty().meta({ description: "Validator address" }),
+  state: z9.enum(["ACTIVE", "INACTIVE", "ACTIVATING", "DEACTIVATING", "UNKNOWN"]).meta({ description: "Stake state" }),
+  staked: z9.string().meta({ description: "Staked amount" }),
+  rewards: z9.object({
+    total: z9.string().meta({ description: "Total rewards" })
   })
 });
-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.EDIT_WORKSPACE_RULE:
-    case RequestType.UPDATE_QUORUM:
-      return false;
-    case RequestType.CREATE_PSD_USER:
-    case RequestType.CREATE_API_USER:
-    case RequestType.CREATE_API_USER_ACCESS:
-    // targeting / editing an existing `User`
-    case RequestType.REVOKE_USER:
-    case RequestType.CREATE_TRANSACTION:
-    case RequestType.SIGN_MESSAGE:
-    case RequestType.SIGN_DIGESTS:
-    case RequestType.CREATE_ACCOUNT:
-    case RequestType.EDIT_ACCOUNT:
-    case RequestType.TRADELINK_ACTIVATE_ACCOUNT:
-    case RequestType.CREATE_GROUP:
-    case RequestType.EDIT_GROUP:
-    case RequestType.REVOKE_GROUP:
-    case RequestType.CREATE_WHITELIST:
-    case RequestType.EDIT_WHITELIST:
-    case RequestType.CREATE_POLICY:
-    case RequestType.EDIT_POLICY:
-    case RequestType.TRADELINK_CREATE_CUSTODIAN:
-    case RequestType.TRADELINK_EDIT_CUSTODIAN:
-    case RequestType.TRADELINK_CREATE_EXCHANGE:
-    case RequestType.TRADELINK_EDIT_EXCHANGE:
-    case RequestType.TRADELINK_CREATE_ASSET_MANAGER:
-    case RequestType.TRADELINK_EDIT_ASSET_MANAGER:
-      return request.state !== RequestState.INITIAL;
-    case RequestType.EDIT_TOKEN_RULE:
-      return true;
-  }
-};
-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:
-    case RequestType.SIGN_DIGESTS:
-      return false;
-    case RequestType.UPDATE_QUORUM:
-    case RequestType.CREATE_PSD_USER:
-    case RequestType.CREATE_API_USER:
-    case RequestType.CREATE_ACCOUNT:
-    case RequestType.CREATE_GROUP:
-    case RequestType.CREATE_WHITELIST:
-    case RequestType.CREATE_ENTITY:
-    case RequestType.CREATE_SCICONFIG:
-    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.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.TRADELINK_EDIT_CUSTODIAN:
-    case RequestType.TRADELINK_EDIT_EXCHANGE:
-    case RequestType.TRADELINK_EDIT_ASSET_MANAGER:
-    case RequestType.TRADELINK_ADJUST_PLEDGE:
-    case RequestType.TRADELINK_REPLEDGE:
-    case RequestType.TRADELINK_CREATE_SETTLEMENT:
-    case RequestType.TRADELINK_FORCE_UNPLEDGE:
-    case RequestType.TRADELINK_WITHDRAW:
-    case RequestType.TRADELINK_ARBITRATE:
-      return true;
-  }
-};
+z9.enum(["staked", "rewards", "total"]).default("total");
+z9.object({
+  address: z9.string().meta({ description: "Validator address" }),
+  apy: z9.string().nullable().meta({ description: "Validator APY" }),
+  balance: z9.string().nullable().meta({ description: "Validator balance" }),
+  commissionRate: z9.string().nullable().meta({ description: "Validator commission rate" }),
+  description: z9.string().nullable().meta({ description: "Description" }),
+  logo: z9.string().nullable().meta({ description: "Logo URL" }),
+  name: z9.string().nullable().meta({ description: "Validator name" }),
+  url: z9.string().nullable().meta({ description: "Validator URL" })
+});
+z9.enum(["balance"]).default("balance");
 
-// src/requests/app-utils/index.ts
-function serializeVaultRequest(request) {
-  const serialized = {
-    ...request,
-    legacyId: request.gateId
-  };
-  switch (request.type) {
-    case "CREATE_TRANSACTION":
-    case "TRADELINK_WITHDRAW":
-    case "TRADELINK_ARBITRATE":
-    case "TRADELINK_CREATE_SETTLEMENT":
-      Object.assign(serialized, {
-        meta: {
-          hash: request.transactionMeta?.hash ?? null
-        }
-      });
-      break;
-  }
-  let patched = zVaultRequestResponse.parse(serialized);
-  patched = patchRequestExpiredAt(patched);
-  patched = patchTezosRequestData(patched);
-  return patched;
-}
-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 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)
+// src/accounts/app-types.ts
+z9.discriminatedUnion(
+  zTransactionResponse._zod.def.discriminator,
+  ensureNonEmptyArray(
+    zTransactionResponse.options.map(
+      (_) => _.extend({
+        note: zNote.nullable().meta({ description: "Optional transaction note" }),
+        requestId: z9.string().nullable().meta({ description: "Request ID associated with the transaction, if available" })
+      })
+    )
+  )
+);
+var zWhitelistAddress = z9.object({
+  name: z9.string().min(1).max(50),
+  currency: zCurrencyString,
+  address: z9.string().min(1).max(200),
+  // Destination tags are numeric-only or alpha-numeric.
+  // Empty array (or undefined) means no check on destination tag.
+  destinationTags: z9.array(z9.string().min(1).regex(/^\w+$/)).optional()
 });
-var fakePsdChallenge = () => ({
-  challengeType: "PSD",
-  wActions: [fakeBase64String(50), fakeBase64String(50), fakeBase64String(50)],
-  handshake: fakeBase64String(100),
-  handshakeAttestation: fakeHsmCertificate(),
-  partitionId: fakeBase64String(20)
+var zWhitelistAddresses = z9.array(zWhitelistAddress);
+var zWhitelistName = z9.string().min(1).max(45).meta({ description: "Whitelist name" });
+var zCreateWhitelistRequestData = z9.object({
+  name: zWhitelistName,
+  description: z9.string().nullable(),
+  addresses: zWhitelistAddresses,
+  type: z9.enum(WhitelistType)
 });
-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":
+var zEditWhitelistRequestData = z9.object({
+  name: zWhitelistName,
+  addresses: zWhitelistAddresses
+});
+
+// src/policies/db-utils.ts
+var zBaseGovRuleData = z9.object({
+  // Steps of users that will need to review operations
+  reviewSteps: zReviewStepsArray,
+  // Optional threshold on transaction value: null `min` = 0, null `max` = +inf
+  threshold: policy_exports.zThreshold.optional(),
+  // Optional whitelist on transaction recipient: Empty list means no whitelist.
+  whitelistIds: policy_exports.zWhitelistIds.optional()
+});
+var zClassicGovRuleData = zBaseGovRuleData.extend({
+  operationType: zClassicOperationType.meta({ description: "Allowed operation type" })
+}).meta({ description: "Account governance rule", id: "ClassicGovRuleData" });
+zBaseGovRuleData.extend({
+  operationType: zOperationType.meta({ description: "Allowed operation type" })
+}).meta({ description: "Governance rule", id: "GovRuleResponse" });
+({
+  reviewConfigs: { include: review_config_exports.INCLUDE_MEMBERS }
+});
+var zPolicyName = z9.string().min(1).max(19).meta({ description: "Policy name" });
+var zCurrency2 = z9.string().min(1).max(40).regex(/^\w+$/).meta({ description: "Currency" });
+var zCreatePublicPolicyRequestData = z9.object({
+  name: zPolicyName,
+  description: z9.string().nullable().meta({ description: "Description" }),
+  currency: zCurrency2.nullable(),
+  govRules: z9.array(zClassicGovRuleData).meta({ description: "Governance rules" })
+});
+var zEditPublicPolicyRequestData = z9.object({
+  name: zPolicyName,
+  description: z9.string().nullable().meta({ description: "Description" }),
+  govRules: z9.array(zClassicGovRuleData).meta({ description: "Governance rules" })
+});
+var zAccountName = z9.string().min(1).max(40).meta({ description: "Account name" });
+z9.enum(["standalone", "legacy"]);
+var zSignDigestsGovRuleData = z9.object({
+  operationType: z9.literal("SIGN_DIGESTS"),
+  reviewSteps: zReviewStepWithUsersArray
+  // we need to control for API users only
+}).meta({ description: "Digest signing rule" });
+var zAccountPolicyRequestData = z9.union([
+  z9.object({ policyId: z9.string() }).meta({ description: "Account policy" }),
+  z9.object({ rules: z9.array(zClassicGovRuleData) }).meta({ description: "Account governance rules" })
+]).meta({ description: "Account policy or governance rules" });
+var zCreateAccountGovernanceData = z9.discriminatedUnion("type", [
+  z9.object({
+    type: z9.literal(AccountGovernanceType.CLASSIC),
+    policy: zAccountPolicyRequestData
+  }).meta({ description: "Classic governance" }),
+  z9.object({
+    type: z9.literal(AccountGovernanceType.TRADELINK),
+    assetManagerId: z9.string(),
+    exchangeConfigs: zTradelinkExchangeConfigs
+  }).meta({ description: "Tradelink governance" }),
+  z9.object({
+    type: z9.literal(AccountGovernanceType.RAW_SIGNING),
+    policy: z9.object({ rules: z9.array(zSignDigestsGovRuleData) })
+  }).meta({ description: "Raw signing governance" })
+]).meta({ description: "Governance fields" });
+var zCreateAccountUserInputData = z9.object({
+  name: zAccountName,
+  currency: zCurrencyString,
+  // "bitcoin"
+  index: z9.number().nonnegative().optional().meta({ description: "Account index" }),
+  contractAddress: z9.string().min(1).optional().meta({ description: "Account contract address" }),
+  governance: zCreateAccountGovernanceData
+});
+var zCreateAccountRequestData = zCreateAccountUserInputData.omit({ index: true }).extend({
+  index: z9.number().nonnegative().meta({ description: "Account index" }),
+  derivationPath: z9.string().meta({ description: "Account bip44 derivation path" }),
+  type: z9.enum(AccountType)
+  // "BITCOIN_LIKE"
+}).meta({
+  description: "Create account request data",
+  id: "CreateAccountRequestData"
+});
+var zEditAccountGovernanceData = z9.discriminatedUnion("type", [
+  z9.object({
+    type: z9.literal(AccountGovernanceType.CLASSIC),
+    policy: zAccountPolicyRequestData
+  }).meta({ description: "Classic governance" }),
+  z9.object({
+    type: z9.literal(AccountGovernanceType.TRADELINK),
+    exchangeConfigs: zTradelinkExchangeConfigs
+  }).meta({ description: "Tradelink governance" }),
+  z9.object({
+    type: z9.literal(AccountGovernanceType.RAW_SIGNING),
+    policy: z9.object({ rules: z9.array(zSignDigestsGovRuleData) })
+  }).meta({ description: "Raw signing governance" })
+]).meta({ description: "Governance fields" });
+var zEditAccountRequestData = z9.object({
+  name: zAccountName,
+  governance: zEditAccountGovernanceData
+}).meta({
+  description: "Edit account request data",
+  id: "EditAccountRequestData"
+});
+var zEditTokenRuleRequestData = z9.object({
+  parentAccountId: z9.string().min(1).meta({ description: "Parent account unique ID" }),
+  contractAddress: z9.string().min(1).meta({ description: "Token contract address" }),
+  rules: z9.array(zClassicGovRuleData).meta({ description: "Account governance rules" })
+});
+
+// src/accounts/app-utils.ts
+var getAccountAssetFields = (account) => {
+  switch (account.type) {
+    case AccountType.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
+        type: account.type,
+        xpub: account.xpub
       };
-    case "ETHEREUM_LIKE":
+    case AccountType.ETHEREUM_LIKE:
       return {
-        type,
-        currency: faker.helpers.arrayElement(["ethereum", "ethereum_goerli"]),
-        derivationPath: "44'/60'/0'",
-        address: faker.finance.ethereumAddress(),
-        contractAddress: null,
-        xpub: null,
-        hsmXpub,
-        hsmChainCode
+        type: account.type,
+        address: account.address,
+        contractAddress: account.contractAddress
       };
-    case "CANTON_LIKE":
+    case AccountType.CARDANO_LIKE:
       return {
-        type,
-        currency: "canton",
-        derivationPath: "44'/6767'/0'/0'/0'",
-        address: faker.string.alphanumeric({ length: 34, casing: "mixed" }),
-        contractAddress: null,
-        xpub: null,
-        hsmXpub,
-        hsmChainCode: null
+        type: account.type,
+        address: account.address
       };
-    case "CARDANO_LIKE":
+    case AccountType.SOLANA_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
+        type: account.type,
+        address: account.address,
+        contractAddress: account.contractAddress
       };
-    case "SOLANA_LIKE":
+    case AccountType.TEZOS_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
+        type: account.type,
+        address: account.address
       };
-    case "TEZOS_LIKE":
+    case AccountType.STELLAR_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
+        type: account.type,
+        address: account.address
       };
-    case "STELLAR_LIKE":
+    case AccountType.SUI_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
+        type: account.type,
+        address: account.address
       };
-    case "RIPPLE_LIKE":
+    case AccountType.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
+        type: account.type,
+        address: account.address
       };
-    case "POLKADOT_LIKE":
+    case AccountType.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
+        type: account.type,
+        address: account.address
       };
-    case "TRON_LIKE":
+    case AccountType.TRON_LIKE:
       return {
-        type,
-        currency: faker.helpers.arrayElement(["tron"]),
-        derivationPath: "44'/195'/0'",
-        address: faker.string.alphanumeric({ length: 34, casing: "mixed" }),
-        contractAddress: null,
-        xpub: null,
-        hsmXpub,
-        hsmChainCode
+        type: account.type,
+        address: account.address,
+        contractAddress: account.contractAddress
       };
-    case "SUI_LIKE":
+    case AccountType.GENERIC_LIKE:
+    case AccountType.RAW_SIGNING:
       return {
-        type,
-        currency: faker.helpers.arrayElement(["sui"]),
-        derivationPath: "44'/784'/0'",
-        address: faker.string.alphanumeric({ length: 34, casing: "mixed" }),
-        contractAddress: null,
-        xpub: null,
-        hsmXpub,
-        hsmChainCode: null
+        type: account.type
       };
-    case "GENERIC_LIKE":
+    case AccountType.CANTON_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
+        type: account.type,
+        address: account.address
       };
-    case "RAW_SIGNING":
+    /* v8 ignore next -- @preserve */
+    default:
+      unreachable(account.type);
+  }
+};
+var getAccountGovernanceFields = (account) => {
+  switch (account.governanceType) {
+    case AccountGovernanceType.CLASSIC:
+    case AccountGovernanceType.RAW_SIGNING:
       return {
-        type,
-        currency: faker.helpers.arrayElement(["ethereum", "bitcoin"]),
-        derivationPath: "44'/118'/0'",
-        address: null,
-        contractAddress: null,
-        xpub: null,
-        hsmXpub,
-        hsmChainCode
+        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 next -- @preserve */
+    default:
+      unreachable(account.governanceType);
+  }
+};
+var serializeAccount = (account) => {
+  const asset = getAccountAssetFields(account);
+  const governance = getAccountGovernanceFields(account);
+  const response = {
+    ...account,
+    network: account.currency,
+    legacyId: account.gateId,
+    governance,
+    asset
+  };
+  return zAccountResponse.parse(response);
+};
+
+// src/compat/patch-request-expired-at.ts
+var patchRequestExpiredAt = (data) => ({
+  ...data,
+  expiredAt: data.expiresAt
+});
+var patchTezosRequestData = (data) => {
+  if (data.type !== RequestType.CREATE_TRANSACTION) {
+    return data;
+  }
+  const transaction = get(data, ["data", "transaction"]);
+  if (!isRecord(transaction)) {
+    return data;
+  }
+  if (transaction.type === "TEZOS_LIKE_DELEGATE") {
+    transaction.amount = transaction.amount ?? "0";
+  } else if (transaction.type === "TEZOS_LIKE_UNDELEGATE") {
+    transaction.amount = transaction.amount ?? "0";
+    transaction.recipient = transaction.recipient ?? "0";
   }
+  return data;
+};
+var zSciConfigData = z9.object({
+  dapps: z9.array(z9.string()).nullable().meta({ description: "Allowed DApps, null allows all" }),
+  customContractCallEnabled: z9.boolean().meta({ description: "Allow non-DApp SCI" })
+});
+var zCreateSciConfigRequestData = z9.object({
+  account: z9.string().meta({ description: "Account UUID" }),
+  config: zSciConfigData
+});
+var zEditSciConfigRequestData = z9.object({
+  config: zSciConfigData
+});
+var zRequestReviewStep = z.object({
+  stageName: z.string().regex(/^\w+$/).meta({ description: "The review stage name" }),
+  quorum: z.int().min(1).meta({ description: "Quorum for the review step" })
+});
+var zRequestReviewSteps = z.array(zRequestReviewStep);
+var zGroupName = z9.string().min(1).max(19).meta({ description: "Group name" });
+var zCreateGroupRequestData = z9.object({
+  name: zGroupName,
+  description: z9.string().nullable().meta({ description: "Group description" }),
+  members: z9.array(z9.string()).meta({ description: "List of group members ids" })
+});
+var zEditGroupRequestData = z9.object({
+  name: zGroupName,
+  description: z9.string().nullable().meta({ description: "Group description" }),
+  members: z9.array(z9.string()).meta({ description: "List of group members ids" })
+});
+var zApiKeyName = z9.string().min(1).max(19).meta({ description: "API key name" });
+var zCreateApiKeyRequestData = z9.object({
+  name: zApiKeyName,
+  entities: z9.array(z9.string()).meta({ description: "List of related entities ids" }),
+  scopes: z9.object({}).meta({ description: "FIXME to be precised" })
+}).meta({ description: "Create read-only API key request data" });
+var zEditApiKeyRequestData = zCreateApiKeyRequestData.meta({
+  description: "Edit read-only API key request data"
+});
+var zEntityName = z9.string().min(1).max(19).meta({ description: "Entity name" });
+var zCreateEntityRequestData = z9.object({
+  name: zEntityName,
+  accounts: z9.array(z9.string())
+});
+var zEditEntityRequestData = z9.object({
+  name: zEntityName,
+  accounts: z9.array(z9.string())
+});
+
+// src/requests/request-data.ts
+var zVaultRequestMixinsByType = {
+  // Workspaces
+  [RequestType.UPDATE_QUORUM]: z9.object({
+    type: z9.literal(RequestType.UPDATE_QUORUM),
+    data: zUpdateQuorumRequestData
+  }),
+  // Operator requests
+  [RequestType.CREATE_TRANSACTION]: z9.object({
+    type: z9.literal(RequestType.CREATE_TRANSACTION),
+    data: zCreateTransactionRequestData,
+    meta: z9.object({
+      hash: z9.string().nullable()
+    }).optional().nullable()
+  }),
+  [RequestType.SIGN_MESSAGE]: z9.object({
+    type: z9.literal(RequestType.SIGN_MESSAGE),
+    data: zSignMessageRequestData
+  }),
+  [RequestType.SIGN_DIGESTS]: z9.object({
+    type: z9.literal(RequestType.SIGN_DIGESTS),
+    data: zSignDigestsRequestData
+  }),
+  // Accounts
+  [RequestType.CREATE_ACCOUNT]: z9.object({
+    type: z9.literal(RequestType.CREATE_ACCOUNT),
+    data: zCreateAccountRequestData
+  }),
+  [RequestType.EDIT_ACCOUNT]: z9.object({
+    type: z9.literal(RequestType.EDIT_ACCOUNT),
+    targetId: z9.string(),
+    data: zEditAccountRequestData
+  }),
+  [RequestType.EDIT_TOKEN_RULE]: z9.object({
+    type: z9.literal(RequestType.EDIT_TOKEN_RULE),
+    targetId: z9.string(),
+    data: zEditTokenRuleRequestData
+  }),
+  // Groups
+  [RequestType.CREATE_GROUP]: z9.object({
+    type: z9.literal(RequestType.CREATE_GROUP),
+    data: zCreateGroupRequestData
+  }),
+  [RequestType.EDIT_GROUP]: z9.object({
+    type: z9.literal(RequestType.EDIT_GROUP),
+    targetId: z9.string(),
+    data: zEditGroupRequestData
+  }),
+  [RequestType.REVOKE_GROUP]: z9.object({
+    type: z9.literal(RequestType.REVOKE_GROUP),
+    targetId: z9.string(),
+    data: zRevokeUserRequestData
+  }),
+  // Whitelists
+  [RequestType.CREATE_WHITELIST]: z9.object({
+    type: z9.literal(RequestType.CREATE_WHITELIST),
+    data: zCreateWhitelistRequestData
+  }),
+  [RequestType.EDIT_WHITELIST]: z9.object({
+    type: z9.literal(RequestType.EDIT_WHITELIST),
+    targetId: z9.string(),
+    data: zEditWhitelistRequestData
+  }),
+  // Entities
+  [RequestType.CREATE_ENTITY]: z9.object({
+    type: z9.literal(RequestType.CREATE_ENTITY),
+    data: zCreateEntityRequestData
+  }),
+  [RequestType.EDIT_ENTITY]: z9.object({
+    type: z9.literal(RequestType.EDIT_ENTITY),
+    data: zEditEntityRequestData
+  }),
+  [RequestType.REVOKE_ENTITY]: z9.object({
+    type: z9.literal(RequestType.REVOKE_ENTITY),
+    data: z9.object({})
+  }),
+  // Users
+  [RequestType.CREATE_PSD_USER]: z9.object({
+    type: z9.literal(RequestType.CREATE_PSD_USER),
+    data: zCreatePsdUserRequestData
+  }),
+  [RequestType.CREATE_API_USER]: z9.object({
+    type: z9.literal(RequestType.CREATE_API_USER),
+    data: zCreateApiUserRequestData
+  }),
+  [RequestType.CREATE_API_USER_ACCESS]: z9.object({
+    type: z9.literal(RequestType.CREATE_API_USER_ACCESS),
+    data: zCreateApiUserAccessRequestData
+  }),
+  [RequestType.REVOKE_USER]: z9.object({
+    type: z9.literal(RequestType.REVOKE_USER),
+    targetId: z9.string(),
+    data: zRevokeUserRequestData
+  }),
+  // Admin gov rules
+  [RequestType.EDIT_WORKSPACE_RULE]: z9.object({
+    type: z9.literal(RequestType.EDIT_WORKSPACE_RULE),
+    data: zWorkspaceRuleRequestData
+  }),
+  // SCI configs
+  [RequestType.CREATE_SCICONFIG]: z9.object({
+    type: z9.literal(RequestType.CREATE_SCICONFIG),
+    data: zCreateSciConfigRequestData
+  }),
+  [RequestType.EDIT_SCICONFIG]: z9.object({
+    type: z9.literal(RequestType.EDIT_SCICONFIG),
+    data: zEditSciConfigRequestData
+  }),
+  // API keys
+  [RequestType.CREATE_API_KEY]: z9.object({
+    type: z9.literal(RequestType.CREATE_API_KEY),
+    data: zCreateApiKeyRequestData
+  }),
+  [RequestType.EDIT_API_KEY]: z9.object({
+    type: z9.literal(RequestType.EDIT_API_KEY),
+    data: zEditApiKeyRequestData
+  }),
+  [RequestType.REVOKE_API_KEY]: z9.object({
+    type: z9.literal(RequestType.REVOKE_API_KEY),
+    data: z9.object({})
+  }),
+  // Policies
+  [RequestType.CREATE_POLICY]: z9.object({
+    type: z9.literal(RequestType.CREATE_POLICY),
+    data: zCreatePublicPolicyRequestData
+  }),
+  [RequestType.EDIT_POLICY]: z9.object({
+    type: z9.literal(RequestType.EDIT_POLICY),
+    targetId: z9.string(),
+    data: zEditPublicPolicyRequestData
+  }),
+  // Tradelink-related requests
+  ...zTradelinkRequestMixinsByType
 };
-var genGovernanceFieldsForType = (governanceType, {
-  accountId,
-  policyId,
-  assetManagerId
-}) => {
-  switch (governanceType) {
-    case AccountGovernanceType.CLASSIC:
-    case AccountGovernanceType.RAW_SIGNING:
-      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
-        }
-      };
-  }
+
+// src/requests/app-types.ts
+var zRequestReviewResponse = z9.object({
+  // Note: Do NOT include `quorum` as it is already available in the request's `reviewSteps` field.
+  stepIndex: z9.number().int().meta({ description: "Index of the governance step in the request workflow" }),
+  userId: z9.string().meta({ description: "Reviewer id" }),
+  status: z9.enum(RequestReviewStatus).meta({ description: "Review status" }),
+  createdAt: z9.coerce.date().meta({ description: "Created date" }),
+  updatedAt: z9.coerce.date().meta({ description: "Updated date" })
+});
+var zVaultRequestCommonMixin = z9.object({
+  id: z9.string().meta({ description: "Request unique identifier" }),
+  legacyId: z9.number().meta({ description: "Legacy internal unique identifier (for retro-compatibility)" }),
+  state: z9.enum(RequestState).meta({ description: "Request state" }),
+  reviewSteps: zRequestReviewSteps.meta({ description: "Request review steps" }),
+  currentStepIndex: z9.number().int().min(0).meta({ description: "Index of the current approval step" }),
+  expiresAt: z9.coerce.date().meta({ description: "Request expiration date" }),
+  expiredAt: z9.coerce.date().optional().meta({ description: "Deprecated: use expiresAt" }),
+  targetId: z9.string().nullable().meta({ description: "Optional ID of the target object" }),
+  note: zNote.nullable().meta({ description: "Optional request note" }),
+  reviews: z9.array(zRequestReviewResponse).meta({ description: "Requests reviews" }),
+  // `type` and `data` are correlated -- See `zVaultRequestMixinsByType`
+  createdAt: z9.coerce.date().meta({ description: "Creation timestamp" }),
+  updatedAt: z9.coerce.date().meta({ description: "Last modification timestamp" }),
+  createdById: z9.string().meta({ description: "ID of the user who created the request" }),
+  // `inflight` is fetched from ONGOING RequestSaga
+  inflight: z9.object({
+    lastError: z9.string().nullable().meta({ description: "Error message from the last failure" }),
+    numFailed: z9.number().int().meta({ description: "Number of failures so far" }),
+    retryAfter: z9.coerce.date().meta({ description: "Date after which next retry is scheduled" })
+  }).optional().meta({ description: "Extra information if the request is currently being processed" })
+});
+var allowedRequestCreationInputByType = {
+  [RequestType.UPDATE_QUORUM]: zVaultRequestMixinsByType[RequestType.UPDATE_QUORUM],
+  [RequestType.CREATE_PSD_USER]: zVaultRequestMixinsByType[RequestType.CREATE_PSD_USER],
+  [RequestType.CREATE_API_USER]: zVaultRequestMixinsByType[RequestType.CREATE_API_USER],
+  [RequestType.CREATE_GROUP]: zVaultRequestMixinsByType[RequestType.CREATE_GROUP],
+  [RequestType.EDIT_GROUP]: zVaultRequestMixinsByType[RequestType.EDIT_GROUP],
+  [RequestType.CREATE_WHITELIST]: zVaultRequestMixinsByType[RequestType.CREATE_WHITELIST],
+  [RequestType.EDIT_WHITELIST]: zVaultRequestMixinsByType[RequestType.EDIT_WHITELIST],
+  [RequestType.CREATE_TRANSACTION]: zVaultRequestMixinsByType[RequestType.CREATE_TRANSACTION],
+  [RequestType.SIGN_MESSAGE]: z9.object({
+    type: z9.literal(RequestType.SIGN_MESSAGE),
+    data: zSignMessageUserInputData
+  }),
+  [RequestType.CREATE_POLICY]: zVaultRequestMixinsByType[RequestType.CREATE_POLICY],
+  [RequestType.EDIT_POLICY]: zVaultRequestMixinsByType[RequestType.EDIT_POLICY],
+  [RequestType.CREATE_ACCOUNT]: z9.object({
+    type: z9.literal(RequestType.CREATE_ACCOUNT),
+    data: zCreateAccountUserInputData
+  }),
+  [RequestType.EDIT_ACCOUNT]: zVaultRequestMixinsByType[RequestType.EDIT_ACCOUNT],
+  [RequestType.TRADELINK_ACTIVATE_ACCOUNT]: zVaultRequestMixinsByType[RequestType.TRADELINK_ACTIVATE_ACCOUNT],
+  [RequestType.TRADELINK_CREATE_CUSTODIAN]: zVaultRequestMixinsByType[RequestType.TRADELINK_CREATE_CUSTODIAN],
+  [RequestType.TRADELINK_EDIT_CUSTODIAN]: zVaultRequestMixinsByType[RequestType.TRADELINK_EDIT_CUSTODIAN],
+  [RequestType.TRADELINK_CREATE_EXCHANGE]: zVaultRequestMixinsByType[RequestType.TRADELINK_CREATE_EXCHANGE],
+  [RequestType.TRADELINK_EDIT_EXCHANGE]: zVaultRequestMixinsByType[RequestType.TRADELINK_EDIT_EXCHANGE],
+  [RequestType.TRADELINK_CREATE_ASSET_MANAGER]: zVaultRequestMixinsByType[RequestType.TRADELINK_CREATE_ASSET_MANAGER],
+  [RequestType.TRADELINK_EDIT_ASSET_MANAGER]: zVaultRequestMixinsByType[RequestType.TRADELINK_EDIT_ASSET_MANAGER],
+  [RequestType.TRADELINK_ADJUST_PLEDGE]: zVaultRequestMixinsByType[RequestType.TRADELINK_ADJUST_PLEDGE],
+  [RequestType.TRADELINK_REPLEDGE]: zVaultRequestMixinsByType[RequestType.TRADELINK_REPLEDGE],
+  [RequestType.TRADELINK_FORCE_UNPLEDGE]: zVaultRequestMixinsByType[RequestType.TRADELINK_FORCE_UNPLEDGE],
+  [RequestType.TRADELINK_CREATE_SETTLEMENT]: zVaultRequestMixinsByType[RequestType.TRADELINK_CREATE_SETTLEMENT],
+  [RequestType.TRADELINK_WITHDRAW]: zVaultRequestMixinsByType[RequestType.TRADELINK_WITHDRAW],
+  [RequestType.TRADELINK_ARBITRATE]: zVaultRequestMixinsByType[RequestType.TRADELINK_ARBITRATE],
+  [RequestType.REVOKE_USER]: zVaultRequestMixinsByType[RequestType.REVOKE_USER],
+  [RequestType.EDIT_WORKSPACE_RULE]: zVaultRequestMixinsByType[RequestType.EDIT_WORKSPACE_RULE]
 };
-var genAccount = (opts) => {
-  const { policyId, assetManagerId, ...rest } = opts ?? {};
-  const commonFields = {
-    id: faker.string.uuid(),
-    workspaceName: fakeWorkspaceName(),
-    name: fakeUniqueName(),
-    hsmId: fakeHsmObjectId(),
-    status: ActivationStatus.ACTIVE,
-    index: faker.number.int({ min: 0, max: 10 }),
-    gateId: fakeGateId(),
-    gateType: GateAccountType.Account,
-    lesWalletId: faker.string.uuid(),
-    createdAt: faker.date.past(),
-    updatedAt: faker.date.past()
+var zRequestCreationInputCommonMixin = z9.object({
+  note: zNote.optional().meta({ description: "Optional request note" })
+});
+z9.object({
+  request: z9.discriminatedUnion(
+    "type",
+    ensureNonEmptyArray(
+      Object.values(allowedRequestCreationInputByType).map((_) => {
+        const requestType = _.shape.type.value;
+        return _.extend(zRequestCreationInputCommonMixin.shape).meta({
+          description: `${requestType} request data`
+        });
+      })
+    )
+  )
+});
+var zVaultRequestResponse = z9.discriminatedUnion(
+  "type",
+  ensureNonEmptyArray(
+    Object.values(zVaultRequestMixinsByType).map((_) => {
+      const requestType = _.shape.type.value;
+      return _.extend(zVaultRequestCommonMixin.shape).meta({
+        description: `${requestType} request`
+      });
+    })
+  )
+).meta({
+  description: "Vault request response data",
+  id: "VaultRequestResponse"
+});
+z9.enum([
+  "state",
+  "expiresAt",
+  "createdAt",
+  "updatedAt"
+]).default("createdAt");
+z9.object({
+  pubKey: z9.string().meta({ description: "Public key of the current user" }),
+  challenge: zUserChallenge.meta({
+    description: "Challenge data to sign with the user's private key"
+  })
+});
+
+// src/requests/app-utils/index.ts
+function serializeVaultRequest(request) {
+  const serialized = {
+    ...request,
+    legacyId: request.gateId
   };
-  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 }) ? type === RequestType.CREATE_PSD_USER ? fakePubKey() : 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,
-    expiresAt: faker.date.future(),
-    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;
-    }
+  switch (request.type) {
+    case "CREATE_TRANSACTION":
+    case "TRADELINK_WITHDRAW":
+    case "TRADELINK_ARBITRATE":
+    case "TRADELINK_CREATE_SETTLEMENT":
+      Object.assign(serialized, {
+        meta: {
+          hash: request.transactionMeta?.hash ?? null
+        }
+      });
+      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
-  };
-};
+  let patched = zVaultRequestResponse.parse(serialized);
+  patched = patchRequestExpiredAt(patched);
+  patched = patchTezosRequestData(patched);
+  return patched;
+}
 
 // src/__fakes__/responses.ts
 function genVaultRequestResponse(opts, reviews = []) {
@@ -2600,6 +2605,7 @@ function genAccountResponse(overrides) {
   const account = serializeAccount(dbAccount);
   return zAccountResponse.parse(account);
 }
+/* v8 ignore next -- @preserve */
 
 export { genAccountResponse, genVaultRequestResponse, genVaultRequestReview };
 //# sourceMappingURL=fakes.mjs.map