Schema

The public resource schema for the Levain GraphQL API. This allows you to perform introspection and generate typesafe clients.

"""Information about pagination in a connection."""
type PageInfo {
  """When paginating forwards, the cursor to continue. `after=endCursor`"""
  endCursor: String

  """When paginating forwards, indicates if there is a next page."""
  hasNextPage: Boolean!

  """
  When paginating backwards, the cursor to continue. `before=startCursor`
  """
  startCursor: String

  """When paginating backwards, indicates if there is a next page."""
  hasPreviousPage: Boolean!
}

"""
The balance of an address / account, for a specific asset on the blockchain. Balances can be expressed in various denominations and units.
"""
type Balance {
  """The balance of the asset denominated in the smallest unit."""
  amount: String!

  """
  The number of decimal places to use when formatting the balance. For example, `18` for ETH, `8` for BTC, `6` for TRX.
  """
  decimals: String!

  """The symbol of the asset, if available."""
  symbol: String

  """
  The balance of the asset represented in a human-readable string. Computed as `amount / 10 ^ decimals`. This is meant to be used for display purposes only, and not for computation. If you need to perform any computation, use `amount` and `decimals` instead.
  """
  humanReadable: String!
}

"""A blockchain network."""
type Network {
  """A system-generated unique ID of the network."""
  networkId: ID!

  """The name of the protocol (e.g. Ethereum)."""
  protocolName: String!

  """The type of the protocol (e.g. EVM)."""
  protocolType: ProtocolType!

  """The name of the network."""
  networkName: String!

  """The family of the network (Main or Test)."""
  networkFamily: NetworkFamily!

  """The symbol of the native cryptocurrency."""
  cryptoSymbol: String!

  """The name of the native cryptocurrency."""
  cryptoName: String!

  """
  The chain-agnostic [CAIP-2 identifier](https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-2.md) of the network. E.g. `caip2:eip155:1` for Ethereum mainnet.
  """
  identifier: String!

  """
  The minimum number of block confirmations required for a transaction to be considered confirmed.
  """
  minConfirmations: Int

  """Whether the network is available for use."""
  available: Boolean!

  """The date and time when the network was created."""
  createdAt: DateTime!

  """
  The timestamp of when the network was soft-deleted. Will be null if the network has not been soft-deleted, or if it has been recovered.
  """
  deletedAt: DateTime

  """Retrieves a paginated list of assets supported by the network."""
  assets(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String
  ): PaginatedNetworkAsset!

  """Retrieves the native asset of the network."""
  nativeAsset: NetworkAsset!

  """
  The cost of creating a wallet of a specific type on the network. If null, the cost is unknown.
  """
  walletCreationCost(
    """The type of wallet to create."""
    type: WalletType!
  ): Balance
}

"""The type of the protocol (e.g. EVM, UTXO, etc.)."""
enum ProtocolType {
  """Etheruem Virtual Machine (EVM)"""
  EVM

  """Tron Virtual Machine (TVM)"""
  TVM

  """Unspent Transaction Output (UTXO)"""
  UTXO
}

"""The family of the network (Main, Test or Local)."""
enum NetworkFamily {
  """Network that is on localhost."""
  Local

  """Network that is on testnet."""
  Test

  """Network that is on mainnet."""
  Main
}

"""
A date-time string at UTC, such as 2019-12-03T09:54:33Z, compliant with the date-time format.
"""
scalar DateTime

"""The type of wallet."""
enum WalletType {
  """A 2-of-3 multi-sig wallet implemented as an Ethereum smart contract."""
  EvmContractSimpleMultiSig

  """
  A [Safe](https://docs.safe.global/getting-started/readme) smart contract wallet.
  """
  EvmContractSafe
  UtxoP2tr
  UtxoP2wshMultiSig
  TronNativeMultiSig
}

"""Paginated list of networks."""
type PaginatedNetwork {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [NetworkEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type NetworkEdge {
  """The item at the end of the edge in the connection."""
  node: Network!

  """A cursor for use in pagination."""
  cursor: String!
}

type OrganizationInvitation {
  """The system-generated unique ID of the organization invitation."""
  invitationId: ID!

  """A unique 12-digit identifier of an organization."""
  orgId: ID!

  """The role of the member in the organization."""
  role: OrganizationMemberRole!

  """The email address of the invited user."""
  email: String!

  """The status of the organization invitation."""
  status: OrganizationInvitationStatus!

  """The datetime that the organization invitation expires."""
  expiry: DateTime!

  """Indicates whether the organization invitation is currently active."""
  isActive: Boolean!

  """The datetime that the organization invitation was created."""
  createdAt: DateTime!

  """Retrieve details of the organization."""
  organization: Organization!
}

"""Organization member role."""
enum OrganizationMemberRole {
  """
  Owners can manage all settings within the organization account, including organization-level settings, users, API access tokens and wallets that they are assigned to. The first user created on every organization-level account will always be the first owner of that organization.
  """
  OWNER

  """
  Admins can manage most organization-level settings, users, API access tokens and wallets that they are assigned to.
  """
  ADMIN

  """Users have no access unless they are specifically added to wallets."""
  USER
}

"""Organization invitation status."""
enum OrganizationInvitationStatus {
  """
  The organization invite has been sent to the user and is pending their acceptance.
  """
  INVITED

  """The organization invite has been revoked."""
  REVOKED

  """The user has accepted the organization invite."""
  ACCEPTED
}

type PaginatedOrganizationInvitation {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [OrganizationInvitationEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type OrganizationInvitationEdge {
  """The item at the end of the edge in the connection."""
  node: OrganizationInvitation!

  """A cursor for use in pagination."""
  cursor: String!
}

type Organization {
  """A system-generated 12-digit number that is unique to the organization."""
  orgId: ID!

  """The name of the organization."""
  name: String!

  """The country of incorporation of the organization."""
  countryOfIncorporation: String

  """The business type of the organization."""
  businessType: String

  """The date the organization was created."""
  createdAt: DateTime!

  """The date the organization was last updated."""
  updatedAt: DateTime!

  """Lists all the members of an organization."""
  members(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String

    """Optionally filter by status of the member in the organization."""
    status: OrganizationMemberStatus
  ): PaginatedOrganizationMember!

  """Retrieve information about a member of the organization."""
  member(
    """The system-generated unique ID of the organization member."""
    memberId: ID!
  ): OrganizationMember

  """Retrieve organization membership details of the authenticated user."""
  viewer: OrganizationMember!

  """Lists all the networks enabled for the organization."""
  networks(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String
  ): PaginatedOrganizationNetwork!

  """Retrieve information about the network the organization has access to."""
  network(
    """The system-generated unique ID of the network."""
    networkId: ID!
  ): OrganizationNetwork

  """Get gas tank information associated with the Organization"""
  gasTank: GasTank

  """Lists the wallets that an organization member has access to."""
  wallets(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String
  ): PaginatedWallet!

  """Retrieve information about a wallet."""
  wallet(
    """The system-generated unique ID of the wallet."""
    walletId: ID!
  ): Wallet!

  """Lists all the active invitations to join an organization."""
  invitations(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String

    """If true, returns invitations that are currently active only."""
    isActive: Boolean

    """If provided, returns invitations that match the provided statuses."""
    statuses: [OrganizationInvitationStatus!]
  ): PaginatedOrganizationInvitation!

  """Retrieve details about an organization invite."""
  invitation(
    """The system-generated unique ID of the organization invitation."""
    invitationId: ID!
  ): OrganizationInvitation

  """
  Get the plan of the organization. Only owners and admins can fetch the plan.
  """
  plan: OrganizationPlan

  """Retrieve information about a key in an organization."""
  key(
    """The system-generated unique ID of the key."""
    keyId: ID!
  ): Key!

  """List all the keys in an organization."""
  keys(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String
  ): PaginatedKey!

  """Lists all the webhooks of an organization."""
  webhooks(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String
  ): PaginatedOrganizationWebhook!

  """Retrieve details of an organization webhook."""
  webhook(
    """The system-generated unique ID of the webhook."""
    webhookId: ID!
  ): OrganizationWebhook

  """List all supported networks for webhook service in your organization."""
  webhookSupportedNetworks(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String
  ): PaginatedOrganizationNetwork!

  """
  List all wallet transaction requests for wallets in an organization that the user has approver access to.
  """
  walletTransactionRequests(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String

    """
    Returns transaction requests for a given status. If not provided, all transaction requests will be returned.
    """
    status: TransactionRequestStatus
  ): PaginatedOrganizationTransactionRequest!
}

"""
Organization member status to indicate if the member is active or disabled.
"""
enum OrganizationMemberStatus {
  """The organization member is currently active."""
  ACTIVE

  """The organization member has been disabled."""
  DISABLED
}

"""The status of a wallet transaction request."""
enum TransactionRequestStatus {
  """
  The transaction request is pending approvals from other wallet approvers.
  """
  PENDING_APPROVALS

  """The transaction request has been approved by all wallet approvers."""
  APPROVED

  """The transaction request is pending signatures from wallet signers."""
  PENDING_SIGNATURES

  """
  The transaction request has been rejected by one or more wallet approvers.
  """
  REJECTED

  """
  The transaction request has been approved & signed by the signatories, and is ready to be signed by the gas tank for execution on-chain.
  """
  PENDING_GAS_TANK_SIGNATURE

  """
  The transaction has been signed by the gas tank, and is now ready to be executed on chain.
  """
  SIGNED

  """The transaction request has been sent to the blockchain."""
  EXECUTED

  """The transaction request has been withdrawn."""
  WITHDRAWN
}

type OrganizationEdge {
  """A cursor for use in pagination."""
  cursor: String!

  """The item at the end of the edge in the connection."""
  node: Organization!
}

type PaginatedOrganization {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [OrganizationEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

"""
A network asset is a cryptocurrency or token of a blockchain network stored in Levain's database.
"""
type NetworkAsset {
  """The system-generated unique ID of the network asset."""
  networkAssetId: ID!

  """The system-generated unique ID of the network."""
  networkId: ID!

  """The name of the network asset."""
  name: String!

  """The asset or token symbol of the network asset (e.g. ETH, USDT)."""
  symbol: String!

  """The number of decimals for the network asset."""
  decimals: Int!

  """
  The unique identifier of the token, formatted as a [CAIP-19](https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-19.md) compliant chain-agnostic URI.
  """
  identifier: String!

  """
  Indicates if the asset is the primary cryptocurrency or token originally created for and by the blockchain network.
  """
  isNative: Boolean!

  """
  The current cached price of the network asset. Cache refreshes every minute.
  """
  price: NetworkAssetPrice
}

type PaginatedNetworkAsset {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [NetworkAssetEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type NetworkAssetEdge {
  """The item at the end of the edge in the connection."""
  node: NetworkAsset!

  """A cursor for use in pagination."""
  cursor: String!
}

"""The price details of a network asset in USD."""
type NetworkAssetPrice {
  """The system-generated unique ID of the network asset."""
  networkAssetId: ID!

  """The price of the network asset in USD."""
  priceUsd: String!

  """Price change in percentage over the last 24 hours."""
  priceChangePercentage24h: String!

  """The database record creation timestamp."""
  createdAt: DateTime!

  """The database record update timestamp."""
  updatedAt: DateTime!
}

"""A user."""
type User {
  """The unique identifier provided by the authentication service."""
  userId: ID!

  """User's email address."""
  email: String!

  """User's first name."""
  firstName: String!

  """User's last name."""
  lastName: String!

  """User's marketing opt-in."""
  marketingOptIn: Boolean

  """User's product updates opt-in."""
  productUpdatesOptIn: Boolean

  """Fetches a paginated list of organizations the user is a member of."""
  organizations(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String
  ): PaginatedOrganization!

  """
  Get a user preference by key. Only the viewer can fetch its own preferences.
  """
  preference(
    """Key of the user preference to fetch."""
    key: String!
  ): UserPreference

  """
  Fetches a paginated list of user preferences. Only the viewer can fetch its own preferences.
  """
  preferences(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String
  ): PaginatedUserPreference!
}

"""A member of an organization."""
type OrganizationMember {
  """The system-generated unique ID of the organization member."""
  memberId: ID!

  """The system-generated unique ID of the user."""
  userId: ID!

  """A unique 12-digit identifier of an organization."""
  orgId: ID!

  """The role of the member in the organization."""
  role: OrganizationMemberRole!

  """The status of a member of an organization."""
  status: OrganizationMemberStatus!

  """The datetime the organization member was created."""
  createdAt: DateTime!

  """The datetime the organization member was last updated."""
  updatedAt: DateTime!

  """Retrieve user details of the organization member."""
  user: User!

  """
  Lists the wallets that an organization member has access to. You must be an `ADMIN` or the same `viewer` to query this field. You can also use `organization(orgId: '').wallets` query to view wallets you (the current viewer) have access to instead.
  """
  wallets(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String
  ): PaginatedWallet!

  """
  Lists the wallets accesses of an organization member. You must be an `ADMIN` or the same `viewer` to query this field. You can also use `organization(orgId: '').wallets` query to view wallets you (the current viewer) have access to instead.
  """
  walletAccesses(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String
  ): PaginatedWalletAccess!
}

type PaginatedOrganizationMember {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [OrganizationMemberEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type OrganizationMemberEdge {
  """The item at the end of the edge in the connection."""
  node: OrganizationMember!

  """A cursor for use in pagination."""
  cursor: String!
}

type OrganizationNetwork {
  """The system-generated unique ID of an organization network."""
  organizationNetworkId: ID!

  """A unique 12-digit identifier of an organization."""
  orgId: ID!

  """The system-generated unique ID of the network."""
  networkId: ID!

  """
  The timestamp of when the OrganizationNetwork was soft-deleted. Will be null if the OrganizationNetwork has not been soft-deleted, or if it has been restored.
  """
  deletedAt: DateTime

  """Retrieve information about a network."""
  network: Network!

  """
  Retrieve information of the Gas Tank that is confined to operate on the specified Network. For modern wallets, the Gas Tank is not confined to a single Network. 
  """
  gasTank: GasTank @deprecated(reason: "Gas tanks are no longer confined to a single chain. Use the org-level gas tank instead.")
}

type PaginatedOrganizationNetwork {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [OrganizationNetworkEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type OrganizationNetworkEdge {
  """The item at the end of the edge in the connection."""
  node: OrganizationNetwork!

  """A cursor for use in pagination."""
  cursor: String!
}

"""The fields of a wallet deposit address."""
type WalletDepositAddress {
  """The system-generated unique ID of the created deposit address."""
  walletDepositAddressId: ID!

  """The system-generated unique ID of the wallet."""
  walletId: ID!

  """The label of the deposit address."""
  label: String!

  """The deposit address for the wallet."""
  address: String!

  """The created datetime for the deposit address."""
  createdAt: DateTime!

  """The status of the deposit address."""
  status: WalletDepositAddressStatus!

  """The datetime the deposit address was last updated."""
  updatedAt: DateTime!

  """Get the details of a single transaction for a deposit address."""
  transaction(
    """The blockchain hash of the transaction."""
    transactionHash: String!
  ): Transaction!

  """List all the transactions for the given deposit address."""
  transactions(
    """The requested page number. Defaults to 1."""
    page: Int = 1

    "\n      Limit a rows to be queried.\n      Optional value, default value will be used when required and not specified.\n      Value could be omitted when pagination is not supported.\n    "
    limit: Int

    """Previous page query response `cursor` value."""
    cursor: String
  ): TransactionListResult!

  """List the asset balances of the deposit address."""
  balances: TokenBalanceResponse!
}

"""
Wallet deposit address status to indicate whether the wallet deposit address is active, deploying or failed.
"""
enum WalletDepositAddressStatus {
  """The wallet deposit address is not deployed yet."""
  PENDING_DEPLOYMENT

  """The wallet deposit address is deploying."""
  DEPLOYING

  """The wallet deposit address is active."""
  ACTIVE

  """The wallet deposit address failed to deploy."""
  FAILED
}

"""The result of the create wallet deposit address mutation operation."""
type CreateWalletDepositAddressResult {
  """The system-generated unique ID of the created deposit address."""
  walletDepositAddressId: ID!

  """The label of the deposit address."""
  label: String!

  """The deposit address for the wallet."""
  address: String!
}

type PaginatedWalletDepositAddress {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [WalletDepositAddressEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type WalletDepositAddressEdge {
  """The item at the end of the edge in the connection."""
  node: WalletDepositAddress!

  """A cursor for use in pagination."""
  cursor: String!
}

"""The result of the deploy wallet deposit address mutation operation."""
type DeployWalletDepositAddressResult {
  """Transaction hash of the contract deployment transaction."""
  transactionHash: String!
}

"""The result of the flush wallet deposit address mutation operation."""
type FlushWalletDepositAddressResult {
  """The transaction hash of the forwarder contract deployment."""
  transactionHash: String!

  """The forwarder address."""
  address: String!

  """The CAIP-10 Account URI of the deployer forwarder contract."""
  caip10: String!

  """The forwarder ID."""
  forwarderId: ID!
}

"""
The result of the batch flush wallet deposit address mutation operation.
"""
type BatchFlushWalletDepositAddressesResult {
  """The system-generated request ID of the batch flush transaction."""
  transactionRequestId: String! @deprecated(reason: "Use `requestId` instead.")

  """The system-generated request ID of the batch flush transaction."""
  requestId: String!

  """The hash of the batch flush transaction."""
  transactionHash: String
}

"""The result of the activate wallet deposit mutation."""
type ActivateWalletDepositResult {
  """The wallet deposit address status"""
  status: WalletDepositAddressStatus!
}

"""Represents the encrypted data structure that holds the wallet key."""
type CipherBlobObject {
  """
  The algorithm used to encrypt the private key. Currently supports only AES with a 256-bit key in CBC mode.
  """
  cipher: String!

  """
  The method used to derive a cryptographic key from a password. Currently only supports Password-Based Key Derivation Function 2 (PBKDF2).
  """
  keyDerivation: String!

  """The cryptographic hash function used. Currently supports only SHA-256."""
  keyHasher: String!

  """
  The number of iterations for the key derivation function. Typically, a higher number means stronger security at the cost of longer computation time.
  """
  iter: Int!

  """
  The salt value used in the key derivation function. Helps in preventing rainbow table attacks.
  """
  salt: String!

  """
  Initialization Vector (IV) used for the encryption process in CBC mode. Ensures that the encryption is unique even with the same data and key.
  """
  iv: String!

  """The encrypted version of the private key."""
  cipherText: String!

  """
  Hash value of the encrypted data, ensuring its integrity and authenticity.
  """
  hash: String!
}

"""Holds information related to the encrypted wallet key password."""
type Password {
  """The system-generated unique ID of the wallet key password."""
  walletAccessId: ID

  """The system-generated unique ID of the wallet key password."""
  walletKeyPasswordId: ID!

  """The system-generated unique ID of the associated wallet key."""
  walletKeyId: ID!

  """
  The encrypted private key of the wallet. The private key is encrypted using a password generated on the client-side. Therefore, Levain will never have access to the raw private key.
  """
  cipherBlob: CipherBlobObject! @deprecated(reason: "Use `encryptedPrivateKey` instead.")

  """
  The encrypted private key of the wallet. The private key is encrypted using a password generated on the client-side. Therefore, Levain will never have access to the raw private key.
  """
  encryptedPrivateKey: JSON!

  """
  Unique identifier for the password recovery key. Can be null if no recovery key is set.
  """
  passwordRecoveryKeyId: ID

  """The status of the wallet key password."""
  status: WalletKeyPasswordStatus!

  """
  Required for wallet password recovery. This resolver retrieves the asymmetric private key and is used to decrypt the encrypted wallet password found on the Key Card.
  """
  recoveryKeyPrivateKey: String
}

"""
The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).
"""
scalar JSON

"""The status of the wallet key password."""
enum WalletKeyPasswordStatus {
  """The password is pending further encryption."""
  PENDING_ENCRYPTION

  """The password is active and can be used to sign transactions."""
  ACTIVE
}

"""A 2-of-3 multi-sig wallet."""
type Wallet {
  """The ID of the OrganizationNetwork on which the wallet was created."""
  organizationNetworkId: ID!

  """The system-generated unique ID of the wallet."""
  walletId: ID!

  """The wallet's type."""
  type: WalletType!

  """The human-readable name of the wallet."""
  name: String!

  """A description of the wallet."""
  description: String

  """The wallet's on-chain address."""
  mainAddress: String!

  """The CAIP-10 identifier of the wallet."""
  caip10: ID!

  """
  The status of the wallet, indicating whether or not it is ready for use.
  """
  status: OrganizationNetworkWalletStatus!

  """The hash of the wallet contract deployment transaction."""
  txHash: String

  """A unique 12-digit identifier of an organization."""
  orgId: ID!

  """
  (EVM chains only) The ID of the associated gas tank that will execute transactions for the wallet.
  """
  gasTankId: ID

  """
  The timestamp of when the wallet was soft-deleted. Will be null if the wallet has not been soft-deleted, or if it has been recovered.
  """
  deletedAt: DateTime

  """CAIP-2 identifier of the network the wallet belongs to."""
  caip2: ID!

  """List all the transactions for the given wallet."""
  transactions(
    """The requested page number. Defaults to 1."""
    page: Int = 1

    "\n      Limit a rows to be queried.\n      Optional value, default value will be used when required and not specified.\n      Value could be omitted when pagination is not supported.\n    "
    limit: Int

    """Previous page query response `cursor` value."""
    cursor: String
  ): TransactionListResult!

  """
  Retrieve information about the OrganizationNetwork the wallet belongs to.
  """
  organizationNetwork: OrganizationNetwork!

  """List all the WalletAccess entries for the given wallet."""
  accesses(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String
  ): PaginatedWalletAccess!

  """Get the WalletAccess entry for the current viewer."""
  viewerAccess: WalletAccess

  """List all the approvers of the given wallet."""
  approvers(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String
  ): PaginatedWalletAccess!

  """The details of the signing key for the wallet."""
  signingKey: WalletKey!

  """Get the details of a Key that is a signatory of the given wallet."""
  walletKey(
    """The system-generated unique ID of the key."""
    keyId: ID!
  ): WalletKey!

  """Get the details of a transaction request for the given wallet."""
  transactionRequest(
    """The system-generated unique ID of the transaction request."""
    requestId: ID

    """The client-specified unique ID of the transaction request."""
    clientRequestId: ID
  ): TransactionRequest

  """List all the transaction requests for the given wallet."""
  transactionRequests(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String

    """
    Returns transaction requests after a certain date. It is a UNIX number-based date (in milliseconds) that defaults to 0.
    """
    startDate: Float = 0

    """
    Returns transaction requests before a certain date. It is a UNIX number-based date (in milliseconds) that defaults to 99999999999999.
    """
    endDate: Float = 99999999999999

    """
    Returns transaction requests for a given status. If not provided, all transaction requests will be returned.
    """
    status: TransactionRequestStatus
  ): PaginatedTransactionRequest!

  """List the asset balances of the wallet."""
  balances: TokenBalanceResponse!

  """Get the policy of the wallet."""
  policy: WalletPolicy!

  """Get the wallet keys for the given wallet."""
  walletKeys: [WalletKey!]!

  """Get the deployment status of the wallet."""
  deployment(
    """If `true`, returns the deployment status for inactive wallets only."""
    filterActiveWallet: Boolean
  ): ContractDeploymentInfo

  """Get the details of a single transaction for the parent wallet."""
  transaction(
    """The blockchain hash of the transaction."""
    transactionHash: String!
  ): Transaction!

  """The list of deposit addresses for the wallet."""
  depositAddresses(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String
  ): PaginatedWalletDepositAddress!

  """Retrieve the details of a deposit address."""
  depositAddress(
    """The system-generated unique ID of the created deposit address."""
    walletDepositAddressId: ID!
  ): WalletDepositAddress!

  """Retrieve the detail of a main address."""
  mainAddressDetail: AddressDetail!

  """Build a transaction for the given wallet."""
  buildTransaction(
    """Parameters required to build a transaction."""
    input: BuildTransactionInput!
  ): JSON!

  """
  (EVM chains only) Retrieve the details of the associated gas tank for the given wallet.
  """
  gasTank: GasTank

  """
  Indicates whether the wallet requires the organization gas tank to execute transactions. For EVM chains, this is always true, given that the organization gas tank acts as a co-signer and pay-master for the contract-based wallet. For Tron, this is true since the gas tank can activate deposit addresses on chain.For UTXO chains, this is false, given that the wallet pays for its own transactions.
  """
  requiresGasTankExecution: Boolean!

  """
  Retrieve information about the organization that the wallet belongs to.
  """
  organization: Organization!
}

"""
The status of the wallet, indicating whether or not it is ready for use. Every newly created Wallet will have a `status` of `INACTIVE` until it is activated. Smart contract wallets can only be activated if their deployment transaction has met a sufficient number of confirmations on the network, e.g. `12` on Ethereum mainnet. Wallets can be deactivated and reactivated at any time.
"""
enum OrganizationNetworkWalletStatus {
  """The wallet is active and ready for use."""
  ACTIVE

  """The wallet is inactive."""
  INACTIVE

  """The wallet failed to activate."""
  FAILED
  PENDING_DEPLOYMENT
  DISABLED
}

"""
Parameters to build a transaction for a wallet. The returned data can be used with the `createTransactionRequest` mutation.
"""
input BuildTransactionInput {
  """Recipient address."""
  to: String!

  """
  Amount of asset to be sent, denominated in canonical units. For example, `1` ETH instead of `10^18` wei, `1` BTC instead of `10^8` sats, `1` TRX  instead of `10^6` sun. 
  """
  amount: BigNumber!

  """CAIP-19 URI of the asset to be sent."""
  asset: String!

  """The network fee level for the transaction. Defaults to `Standard`."""
  feeLevel: NetworkFeeLevel = Standard
}

"""Custom BigNumber scalar type for GraphQL use."""
scalar BigNumber

"""
The network fee level for a transaction request. For most chains, the higher the level, the faster the transaction speed.
"""
enum NetworkFeeLevel {
  High
  Low
  Standard
}

"""A transaction on the wallet."""
type WalletTransaction {
  """The hash of the transaction."""
  hash: String!

  """The type of transaction."""
  type: TransactionType!

  """The timestamp of the transaction."""
  timestamp: String!

  """The initator of the transaction."""
  from: String!

  """The recipient of the transaction."""
  to: String!

  """
  The amount of the transaction in wei / the smallest unit of the network's currency.
  """
  amount: String!

  """The status of the transaction."""
  status: TransactionStatus!
}

"""Specifies the kind of activity performed in a transaction."""
enum TransactionType {
  """Outbound token transfer."""
  SEND

  """Inbound token transfer."""
  RECEIVE

  """
  The transaction is a smart contract interaction. A smart contract interaction is a transaction that invokes a smart contract method, which may or may not result in a token transfer (or other methods). For example, a smart contract interaction may be a transaction that invokes a smart contract method to approve a token transfer, which is then followed by a token transfer transaction.
  """
  CONTRACT_CALL

  """
  The transaction type is unknown. This occurs when the decoded transaction data does contain enough information to determine its objective.
  """
  UNKNOWN
}

"""The status of transaction."""
enum TransactionStatus {
  """
  The transaction failed due to an error or being rejected by the blockchain network.
  """
  FAILED

  """
  The transaction is deemed `CONFIRMED` once it has been added and validated on the blockchain, and subsequently followed by `N` additional blocks; where `N` represents the minimum number of block confirmations specified by the Levain Configuration (`network.minConfirmations`).
  """
  CONFIRMED

  """
  The transaction is marked as `UNCONFIRMED` when it has been broadcast to the network but hasn't been added to the blockchain yet or is awaiting the required `N` block confirmations as set by the Levain Configuration (`network.minConfirmations`).
  """
  UNCONFIRMED
}

"""List of transactions."""
type TransactionListResult {
  """The list of transactions."""
  rows: [WalletTransaction!]!

  """Limit of rows of current query."""
  limit: Float

  """
  Cursor value to query for next page. This value will be null after the last page, when `rows` is empty.
  """
  cursor: String

  """The error code, if any."""
  errorCode: String

  """The error message, if any."""
  errorMessage: String
}

type PaginatedWallet {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [WalletEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type WalletEdge {
  """The item at the end of the edge in the connection."""
  node: Wallet!

  """A cursor for use in pagination."""
  cursor: String!
}

"""Optional metadata."""
type TokenBalanceMetadata {
  """URL to the token logo, if available."""
  logoUrl: String
}

"""Price change in percentage, if available."""
type AssetPricePercentChange {
  """Price change in percentage over the last 24 hours."""
  percent24h: Float
}

"""Token balance with price data."""
type TokenBalanceWithPrice {
  """
  The balance of the token in the smallest denomination of the respective token. Also known as balance in Base Units.
  """
  balanceBase: String!

  """
  The number of decimal places of the token. 
  To obtain the logical amount of the token, divide the smallest denomination (balance in Base Units) by 10 raised to the power of decimals. 
  For instance, if the balance is 1,000,000 and decimals is 6, the Token Value or Logical Balance is calculated as 1,000,000 / (10^6) = 1.0.
  """
  decimals: Float!

  """
  The unique identifier of the token, formatted as a [CAIP-19](https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-19.md) compliant chain-agnostic URI.
  """
  caip19Id: String!

  """
  The token contract address. Will be null for assets that have no contract address.
  """
  contractAddress: String

  """The human-readable name of the token."""
  name: String

  """The abbreviated representation of the token (e.g. ETH, USDT)."""
  symbol: String

  """Optional metadata."""
  metadata: TokenBalanceMetadata

  """The fiat currency representation (e.g. USD)."""
  currency: String

  """The fiat currency price of the token."""
  price: Float

  """Price change in percentage."""
  percentChange: AssetPricePercentChange
}

"""Error response."""
type ReportingError {
  """The error code."""
  code: String

  """The error name."""
  name: String

  """The error message."""
  message: String
}

"""Token balance response. Includes price data."""
type TokenBalanceResponse {
  """The token balances."""
  items: [TokenBalanceWithPrice!]!

  """Error response, if any."""
  error: ReportingError
}

"""Details of the address."""
type AddressDetail {
  """
  The type of account identified by the address. E.g. "EvmContractSimpleMultiSig", "TronNativeMultiSig", etc.
  """
  type: String!

  """
  The state of the account. E.g. `PENDING_DEPLOYMENT`, `ACTIVATING`, `ACTIVATED`, or `FAILED`.
  """
  state: String!

  """The CAIP-2 URI of the network the account is associated with."""
  caip2Uri: String!

  """The CAIP-10 URI of the account."""
  caip10Uri: String!

  """
  The hash of the deployment transaction. Only applicable if the account requires on-chain deployment.
  """
  deploymentTxHash: String
}

type OrganizationPlan {
  """The system-generated unique ID of the organization plan."""
  planId: ID!

  """The unique 12-digit identifier of an organization."""
  orgId: ID!
  type: OrganizationPlanType!

  """The datetime of the organization plan starts."""
  startAt: DateTime!

  """The datetime of the organization plan ends."""
  endAt: DateTime!

  """Indicates whether the organization plan is currently active."""
  isActive: Boolean!

  """The datetime the organization plan was created."""
  createdAt: DateTime!

  """The datetime the organization plan was last updated."""
  updatedAt: DateTime!
}

enum OrganizationPlanType {
  PERSONAL_FREE
  PRO
  TEAM_FREE
  TEAM_PRO
  ENTERPRISE
}

type OrganizationWebhook {
  """The system-generated unique ID of the webhook."""
  webhookId: ID!

  """The unique ID of the LWS client webhook"""
  lwsClientWebhookId: ID!

  """The unique 12-digit identifier of an organization."""
  orgId: ID!

  """
  The system-generated unique ID of the organization member who created the webhook.
  """
  createdById: ID!

  """The URL of the clients webhook endpoint."""
  webhookUrl: String!

  """The CAIP2URI of networks which the webhook is subscribed to."""
  subscribedNetworks: [String!]!

  """The status of the client webhook."""
  status: String!

  """The datetime the key was created."""
  createdAt: DateTime!

  """The datetime the key was last updated."""
  updatedAt: DateTime!

  """The organization member who created the webhook."""
  createdBy: OrganizationMember!
}

type PaginatedOrganizationWebhook {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [OrganizationWebhookEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type OrganizationWebhookEdge {
  """The item at the end of the edge in the connection."""
  node: OrganizationWebhook!

  """A cursor for use in pagination."""
  cursor: String!
}

type Key {
  """The system-generated unique ID of the key."""
  keyId: ID!

  """The unique 12-digit identifier of an organization."""
  orgId: ID!

  """
  The system-generated unique ID of the organization member who created the key.
  """
  createdById: ID!

  """The type of key. Refer to [`KeyType`](../reference/enums#keytype)"""
  type: KeyType!

  """Public key of an asymmetrical key pair."""
  publicKey: String!

  """The human-readable name of the key."""
  name: String

  """
  Whether the key has been used for a particular reason. For example, if the key has been used as a signatory for a wallet, or used to encrypt a wallet password.
  """
  consumed: Boolean!

  """The datetime the key was created."""
  createdAt: DateTime!

  """The datetime the key was last updated."""
  updatedAt: DateTime!

  """The organization member who created the key."""
  createdBy: OrganizationMember!

  """
  The type of wallet key. Refer to [`WalletKeyType`](../reference/enums#walletkeytype)
  """
  keyType: WalletKeyType

  """The wallets that the key is a signatory of."""
  wallets(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String
  ): PaginatedWalletKey!
}

"""The type of Key."""
enum KeyType {
  """Key material stored as a scalar."""
  SCALAR

  """Key material stored as scalar with private key omitted (aka neutered)."""
  SCALAR_NEUTERED

  """Key material stored with private and public key in PEM format."""
  RSA

  """
  Key material stored as scalar (private key), point (public key), chain code (extra 32 bytes entropy) and a relative BIP32 path.
  """
  BIP32_HARDENED
}

"""The type of WalletKey."""
enum WalletKeyType {
  """
  The `Main` key is only held by the client, and is used to sign transactions such as transferring funds out of the wallet.
  """
  MAIN

  """
  The `Backup` key is meant for you to backup safely, and only used in situations when you need to perform wallet recovery. Levain never keeps this key at all, except for the public key.
  """
  BACKUP

  """
  The `Levain` key is held by Levain, and it is used to co-sign transactions with you.
  """
  LEVAIN
}

type PaginatedKey {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [KeyEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type KeyEdge {
  """The item at the end of the edge in the connection."""
  node: Key!

  """A cursor for use in pagination."""
  cursor: String!
}

"""A gas tank key."""
type GasTankKey {
  """The system-generated unique ID of the gas tank."""
  gasTankId: ID!

  """
  The system-generated unique ID of the key associated with the gas tank.
  """
  keyId: ID!

  """The details of the Gas Tank's underlying Key"""
  key: Key!
}

"""
A Gas Tank is a [hot wallet](https://www.investopedia.com/terms/h/hot-wallet.asp) that is used to fund the execution of transactions (i.e. pays for network fees) on the blockchain, including:
- Creating wallets
- Executing smart contract wallet transactions
- Funding other automations for speed and user experience

Since the [hot wallet](https://www.investopedia.com/terms/h/hot-wallet.asp) is controlled by a single key that is managed by Levain, it's advisable to keep only a minimal operational balance in it at all times.
"""
type GasTank {
  """
  The ID of the OrganizationNetwork on which the gas tank has been deployed.
  """
  orgId: ID

  """
  The ID of the OrganizationNetwork that the gas tank is confined to operate on. This is only set for single-chain gas tanks.
  """
  organizationNetworkId: ID @deprecated(reason: "Gas tanks are no longer confined to a single chain, and this can be null for newer gas tanks. Use `orgId` instead to identify which org the gas tank belongs to. Will be removed soon.")

  """The system-generated unique ID of the gas tank."""
  gasTankId: ID!

  """The address of the gas tank on the blockchain."""
  address(
    """
    The different ways to format a gas tank address. Defaults to formatting address in an EVM format.
    """
    input: GasTankAddressInput! = {format: EVM_HEX}
  ): String!

  """The creation date of the gas tank in ISO 8601 format."""
  createdAt: DateTime!

  """
  The flag indicating whether the gas tank is the primary one for the organization.
  """
  isPrimary: Boolean!

  """Retrieve details of the key associated with the gas tank."""
  gasTankKey: GasTankKey!

  """
  Retrieve the native crypto balance of the gas tank for a specified network.
  """
  balanceNative(network: String!): Balance

  """Retrieve details of the key associated with the gas tank."""
  createEvmGasTank: String!
}

"""Parameters to pass in when retrieving the gas tank address."""
input GasTankAddressInput {
  """The format of the gas tank address."""
  format: AddressFormat = EVM_HEX

  """
  The CAIP-2 identifier or system-generated UUID of the network on which the gas tank is deployed.
  """
  formatForNetwork: String
}

"""The different ways to format a gas tank address."""
enum AddressFormat {
  """Formats the address in hex for the EVM."""
  EVM_HEX

  """Formats the address in hex for Tron."""
  TRON_HEX

  """Formats the address in base58. Only for Tron."""
  TRON_BASE58
}

type WalletKey {
  """The system-generated unique ID of the WalletKey entity."""
  walletKeyId: ID!

  """The system-generated unique ID of the wallet."""
  walletId: ID!

  """The system-generated unique ID of the key."""
  keyId: ID!

  """
  The type of wallet key. Refer to [`WalletKeyType`](../reference/enums#walletkeytype)
  """
  type: WalletKeyType!

  """The datetime the key was created."""
  createdAt: DateTime!

  """The wallet associated with the given wallet ID."""
  wallet: Wallet

  """The key associated with the given key ID."""
  key: Key!

  """
  The encrypted private key associated with the viewer. If not found, the first wallet key password is returned.
  """
  viewerPassword: Password

  """Returns the primary password associated with the wallet key."""
  password: Password
}

type PaginatedWalletKey {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [WalletKeyEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type WalletKeyEdge {
  """The item at the end of the edge in the connection."""
  node: WalletKey!

  """A cursor for use in pagination."""
  cursor: String!
}

"""Details of a transaction request."""
type TransactionRequest {
  """The system-generated unique ID of the transaction request."""
  requestId: ID!

  """
  The client-specified unique ID of the transaction request, if provided at request time.
  """
  clientRequestId: ID

  """The system-generated unique ID of the wallet initiating the request."""
  walletId: ID!

  """
  The system-generated unique ID of the NetworkAsset associated with the transaction request, or `null` if not associated with a specific asset.
  """
  networkAssetId: ID

  """
  The system-generated unique ID of the member initiating the transaction.
  """
  initiatorMemberId: ID!

  """Current status of the transaction request."""
  status: TransactionRequestStatus!

  """The blockchain hash of the processed transaction."""
  transactionHash: String

  """
  The raw transaction data to be processed on chain. The value is `null` if the actual data has not been generated yet (from the `intent`).
  """
  transactionData: JSON

  """The signed version of the transaction data."""
  transactionSigned: String

  """Signature of the transaction request."""
  transactionSignature: String

  """Remarks of the transaction request."""
  remarks: String

  """The timestamp of when the transaction request was created."""
  createdAt: DateTime!

  """The timestamp of the last update to the transaction request."""
  updatedAt: DateTime!

  """The wallet that this transaction request belongs to."""
  wallet: Wallet!

  """The summary of the transaction request data (for EVM)."""
  summaryEvm: TransactionRequestDataSummaryEvm! @deprecated(reason: "Use `summary` instead.")

  """The summary of the transaction request data."""
  summary: TransactionIntentSummary!

  """The digests of the transaction request."""
  digests(
    """
    If true, it will prefix the digest with 0x. If false (default), it will just return the digest as is.
    """
    withHexPrefix: Boolean! = false
  ): [Digest!]!

  """The asset / token associated with the transaction request."""
  asset: NetworkAsset

  """Perform gas estimation for a transaction request."""
  estimateFees: Float

  """The detailed approvals of the transaction request."""
  approvals(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String
  ): PaginatedTransactionRequestApproval!

  """
  Retrieve the cryptographic signature for the transaction request. This signature from the final approver confirms consent to broadcast the transaction to the network.
  """
  signature: TransactionRequestSignature @deprecated(reason: "Replaced with `signatures`")

  """The member who initiated the transaction request."""
  initiator: OrganizationMember!

  """
  An array of warnings for the given transaction request. A warning contains details describing a potential issue with the transaction request when it is executed on-chain. For example, the account `nonce` is out-dated, or the balance of the wallet is insufficient for performing a transfer.
  """
  warnings: [TransactionRequestWarning!]!
}

"""An object describing a potential issue with the transaction request."""
type TransactionRequestWarning {
  """A short phrase summarizing the warning."""
  type: TransactionRequestWarningType!

  """The description of the warning."""
  description: String!

  """
  Whether the transaction request will fail on-chain if executed. If `null`, it is unknown if it will fail.
  """
  willFail: Boolean
}

"""A short phrase describing the warning for a given transaction request."""
enum TransactionRequestWarningType {
  """The transaction request nonce has expired."""
  NonceExpired

  """The wallet has insufficient funds to execute the transaction request."""
  InsufficientFunds
}

type PaginatedOrganizationTransactionRequest {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [OrganizationTransactionRequestEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type OrganizationTransactionRequestEdge {
  """The item at the end of the edge in the connection."""
  node: TransactionRequest!

  """A cursor for use in pagination."""
  cursor: String!
}

"""Describes an organization member's access to an organization wallet."""
type WalletAccess {
  """The system-generated unique ID of the wallet."""
  walletId: ID!

  """
  The system-generated unique ID of the organization member's wallet access.
  """
  walletAccessId: ID!

  """The system-generated unique ID of the organization member."""
  memberId: ID!

  """The wallet role of the organization member."""
  role: WalletMemberRole!

  """The datetime the organization member's wallet access was created."""
  createdAt: DateTime!

  """The datetime the organization member's wallet access was last updated."""
  updatedAt: DateTime!

  """The wallet the member has access to."""
  wallet: Wallet!

  """Details of an organization member."""
  organizationMember: OrganizationMember!
}

"""The role of an organization member access to an organization wallet."""
enum WalletMemberRole {
  """
  A wallet approver is able to manage the wallet's approval quorum, whitelist addresses, and initiate and approve transactions. They can also be the final approver for signing of transactions.
  """
  APPROVER

  """
  A wallet initiator can initiate transactions that wallet approvers must first approve. After sufficient approvals have been given, the transaction can be signed and broadcast. A wallet initiator can also view the transaction history of a wallet.
  """
  INITIATOR

  """A wallet viewer can only view the transaction history of a wallet."""
  VIEWER
}

"""The wallet policy."""
type WalletPolicy {
  """The system-generated unique ID of the wallet policy."""
  policyId: ID!

  """The system-generated unique ID of the wallet."""
  walletId: ID!

  """Minimum number of approvals required to approve a transaction."""
  approvalThreshold: Int!

  """The datetime the wallet policy was created."""
  createdAt: DateTime!

  """The datetime the wallet policy was last updated."""
  updatedAt: DateTime!

  """Details of the whitelist policies of a wallet."""
  whitelist(
    """The whitelisted wallet address to be from the wallet policy"""
    address: String!
  ): PolicyWhitelist!

  """Details of the whitelist policies of a wallet."""
  whitelists(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String
  ): PaginatedWalletPolicyWhitelist!

  """Details of the final approvers of a wallet."""
  finalApprovers(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String
  ): PaginatedWalletFinalApprover!
}

"""A transaction on the blockchain."""
type Transaction {
  """The unique hash identifier of the transaction on the blockchain."""
  hash: String!

  """The timestamp of when the transaction was mined."""
  timestamp: String

  """The block height of when the transaction was mined."""
  blockHeight: Int

  """Specifies the kind of activity performed in a transaction."""
  type: TransactionType!

  """The blockchain address from which the transaction originated."""
  from: String!

  """The blockchain address targeted by the transaction."""
  to: String!

  """
  The value of the transaction expressed in the smallest denomination of the respective token. Also known as amount in Base Units.
  """
  amount: String!

  """
  The number of decimal places of the token. 
  To obtain the logical amount of the token, divide the smallest denomination (amount in Base Units) by 10 raised to the power of decimals. 
  For instance, if an amount is 1,000,000 and decimals is 6, the Token Value / Logical Amount is calculated as 1,000,000 / (10^6) = 1.0.
  """
  decimals: Int!

  """The abbreviated representation of the token (e.g. ETH, USDT)."""
  symbol: String!

  """The status of transaction."""
  status: TransactionStatus!

  """
  The cost per unit of gas, indicating how much the sender is willing to pay for each unit of work. Typically denominated in wei for EVM-based chains.
  """
  gasPrice: String @deprecated(reason: "We no longer use gasFee, use `networkFee` instead.")

  """
  The total amount of gas units consumed by the transaction. It represents the computational work required for the transaction or contract execution.
  """
  gasUsed: String @deprecated(reason: "We no longer use gasUsed, use `networkFeeUsed` instead.")

  """
  The network cost, indicating how much the sender is willing to pay for each unit of work. Typically denominated in wei for EVM-based chains.
  """
  networkFee: String!

  """
  The total fee consumed by the transaction. It represents the computational work required for the transaction or contract execution.
  """
  networkFeeUsed: String!

  """
  An array of one or multiple token transfer information of the transaction.
  """
  tokenTransferData: [TokenTransferInfo!]!

  """The transaction request associated with this transaction."""
  transactionRequest: TransactionRequest
}

"""Token transfer information of a transaction."""
type TokenTransferInfo {
  """The blockchain address from which the token transfer originated."""
  from: String!

  """The blockchain address targeted by the token transfer."""
  to: String!

  """
  The value of the token transfer expressed in the smallest denomination of the respective token. Also known as amount in Base Units.
  """
  amount: String!

  """The blockchain address of the token contract."""
  tokenAddress: String!

  """
  The abbreviated representation of the token (e.g. ETH, USDT). This is optional as some tokens might not have a defined symbol.
  """
  tokenSymbol: String

  """
  The number of decimal places of the token. 
  To obtain the logical amount of the token, divide the smallest denomination (amount in Base Units) by 10 raised to the power of decimals. 
  For example, if an amount is 1,000,000 and decimals is 6, the Token Value or Logical Amount is calculated as 1,000,000 / (10^6) = 1.0.
  """
  tokenDecimals: Int
}

type ContractDeploymentInfo {
  """
  The number of confirmations that the contract deployment transaction has received.
  """
  confirmations: Float!

  """
  The minimum number of confirmations for a deployment transaction to be regarded as "safe" for the network.
  """
  minConfirmations: Float
}

type PaginatedWalletAccess {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [WalletAccessEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type WalletAccessEdge {
  """The item at the end of the edge in the connection."""
  node: WalletAccess!

  """A cursor for use in pagination."""
  cursor: String!
}

type PaginatedTransactionRequest {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [TransactionRequestEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type TransactionRequestEdge {
  """The item at the end of the edge in the connection."""
  node: TransactionRequest!

  """A cursor for use in pagination."""
  cursor: String!
}

"""The wallet final approver."""
type WalletFinalApprover {
  """The system-generated unique ID of the wallet's final approver."""
  finalApproverId: ID!

  """
  The system-generated unique ID of the organization member's wallet access.
  """
  walletAccessId: ID!

  """
  The status of the wallet signer to indicate if the signer is active or disabled.
  """
  walletSignerStatus: WalletSignerStatus!

  """The datetime the wallet's final approver was created."""
  createdAt: DateTime!

  """The datetime the wallet's final approver was last updated."""
  updatedAt: DateTime!

  """Details of an organization member's access to an organization wallet."""
  access: WalletAccess!
}

"""
The status of the wallet signer to indicate if the signer is active or disabled.
"""
enum WalletSignerStatus {
  """The wallet signer is currently a signer of the wallet."""
  ACTIVE

  """
  The wallet signer has been disabled and is no longer a signer of the wallet.
  """
  DISABLED
}

type PaginatedWalletFinalApprover {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [WalletFinalApproverEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type WalletFinalApproverEdge {
  """The item at the end of the edge in the connection."""
  node: WalletFinalApprover!

  """A cursor for use in pagination."""
  cursor: String!
}

"""The whitelist policy."""
type PolicyWhitelist {
  """The system-generated unique ID of the whitelist policy."""
  policyId: ID!

  """The blockchain address to be whitelisted."""
  address: String!

  """The system-generated unique ID of the wallet."""
  walletId: ID!

  """The label of the policy whitelist."""
  label: String!

  """The datetime the whitelist policy was created."""
  createdAt: DateTime!

  """The datetime the whitelist policy was last updated."""
  updatedAt: DateTime!
}

type PaginatedWalletPolicyWhitelist {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [WalletPolicyWhitelistEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type WalletPolicyWhitelistEdge {
  """The item at the end of the edge in the connection."""
  node: PolicyWhitelist!

  """A cursor for use in pagination."""
  cursor: String!
}

"""The transaction request approval."""
type TransactionRequestApproval {
  """The system-generated unique ID of the transaction request approval."""
  walletTransactionRequestId: ID!

  """The system-generated unique ID of the approver."""
  approverId: ID!

  """The type of approval action."""
  actionType: ApprovalActionType!

  """The date and time when the transaction request approval was created."""
  createdAt: DateTime!

  """
  The date and time when the transaction request approval was last updated.
  """
  updatedAt: DateTime!

  """The approver of the transaction request."""
  actor: OrganizationMember!
}

"""The type of approval action."""
enum ApprovalActionType {
  """Approve the transaction request."""
  APPROVE

  """Reject the transaction request."""
  REJECT
}

"""The transaction request approval with latest status"""
type ApproveTransactionRequestResult {
  """The system-generated unique ID of the transaction request approval."""
  walletTransactionRequestId: ID!

  """The system-generated unique ID of the approver."""
  approverId: ID!

  """The type of approval action."""
  actionType: ApprovalActionType!

  """The date and time when the transaction request approval was created."""
  createdAt: DateTime!

  """
  The date and time when the transaction request approval was last updated.
  """
  updatedAt: DateTime!

  """The approver of the transaction request."""
  actor: OrganizationMember!

  """Status of approved transaction."""
  status: TransactionRequestStatus!
}

"""The paginated transaction request approval."""
type PaginatedTransactionRequestApproval {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [TransactionRequestApprovalEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type TransactionRequestApprovalEdge {
  """The item at the end of the edge in the connection."""
  node: TransactionRequestApproval!

  """A cursor for use in pagination."""
  cursor: String!
}

"""
A wallet-agnostic interpretation of a given Transaction Request on EVM blockchains. This object aims to provide a common interface for representing the data of a given Transaction Request, for the client's convenience. A good use-case for this object is for "list" operations.
"""
type TransactionRequestDataSummaryEvm {
  """The address of the recipient of the transaction."""
  to: String!

  """The (smart contract call) data of the transaction."""
  data: String!

  """The value to be transferred to the recipient of the transaction."""
  value: String!
}

"""
A wallet-agnostic interpretation of a given Transaction Request. This object aims to provide a common interface for representing the data of a given Transaction Request, for the client's convenience. 
"""
type TransactionIntentSummary {
  """The request ID that is summarized"""
  requestId: String!

  """The transaction intention"""
  type: String!

  """Source of the involved fund if applicable"""
  from: String!

  """Destination of involved fund if applicable"""
  to: String!

  """Involved fund amount"""
  amount: String!

  """Contract call data"""
  data: String

  """The identifier of the asset associated with the transaction."""
  assetCaip19: String

  """The Asset associated with the transaction."""
  asset: NetworkAsset
  toDetails: AddressDetails
}

"""Additional details of an address on the blockchain."""
type AddressDetails {
  """The address on the blockchain."""
  address: String!

  """
  The label of the address, if available. Otherwise, the value will be null.
  """
  label: String
}

"""
Stores the relations between the digest, the key, and the transaction request.
"""
type Digest {
  """The system-generated unique ID of the digest."""
  kvsDigestId: ID! @deprecated(reason: "Use `digestId` instead.")

  """The system-generated unique ID of the digest."""
  digestId: ID!

  """The system-generated unique ID of the wallet key."""
  walletKeyId: ID!

  """The system-generated unique ID of the transaction request."""
  requestId: ID!

  """The message digest to sign that generates the corresponding signature."""
  digest: String!

  """
  Signature of the digest. A signature on a digest is produced by a [Key](../docs/wallet-security-model#keys) in Levain's Key Vault Service(KVS).A signature is undefined if the state is PENDING.
  """
  signature: String

  """The state of the digest."""
  state: DigestState!
}

"""The state of the digest."""
enum DigestState {
  """
  Represents a digest awaiting signature. It is the sole state indicating ongoing processing. Digests related to remote private keys not stored in Levain KVS will always initiate in this state.
  """
  PENDING

  """**Successful** completion of the signing process."""
  SIGNED

  """
  **Unsuccessful** signing process. It was manually cancelled by the user.
  """
  CANCELLED

  """**Unsuccessful** signing process. It was cancelled by the system."""
  EXPIRED

  """
  **Unsuccessful** signing process. It was cancelled by the system, often because while this specific KeyDigest was not signed, other associated KeyDigests received signatures from a valid key.
  """
  COMPLETED
}

"""A signature request."""
type TransactionRequestSignature {
  """The system-generated unique ID of the transaction request."""
  walletTransactionRequestId: ID!

  """The system-generated unique ID of the signer."""
  signerId: ID!

  """The type of signature action."""
  actionType: SignatureActionType!

  """The date and time the signature request was created."""
  createdAt: DateTime!

  """The wallet access that signed the transaction request."""
  signer: WalletAccess!
}

"""The type of signature action."""
enum SignatureActionType {
  """Approve the transaction request."""
  APPROVE

  """Reject the transaction request."""
  REJECT
}

"""The result of creating a signature request."""
type CreateSignatureRequestResult {
  """The system-generated unique ID of the signature request."""
  signatureRequestId: ID!

  """The system-generated unique ID of the wallet."""
  walletId: ID!

  """The date and time the signature request was created."""
  createdAt: DateTime!

  """The state of the signature request."""
  state: String!
}

"""The result of approving a signature request."""
type ApproveSignatureRequestResult {
  """The system-generated unique ID of the signature request."""
  signatureRequestId: ID!
}

"""The result of resolving an EIP1271 signature."""
type ResolveEIP1271SignatureResult {
  """The system-generated unique ID of the signature request."""
  signatureRequestId: ID!

  """The system-generated unique ID of the wallet."""
  walletId: ID!

  """The state of the signature request."""
  state: String!

  """The date and time the signature request was created."""
  createdAt: DateTime!

  """The digest."""
  digest: String!

  """The signature."""
  signature: String!
}

"""The result of requesting owner signatures."""
type RequestOwnerSignaturesResult {
  """The system-generated unique ID of the signature request."""
  signatureRequestId: ID!

  """The system-generated unique ID of the wallet."""
  walletId: ID!

  """The date and time the signature request was created."""
  createdAt: DateTime!

  """The digest."""
  digest: String!
}

"""A user preference."""
type UserPreference {
  """The system-generated unique ID of the user preference."""
  preferenceId: ID!

  """
  The key of the preference. A user can have only one preference per key.
  """
  key: String!

  """The value of the preference."""
  value: String!

  """The datetime the preference was created."""
  createdAt: DateTime!

  """The datetime the preference was last updated."""
  updatedAt: DateTime!
}

"""A paginated list of user preferences."""
type PaginatedUserPreference {
  """Identifies the total count of items in the connection."""
  totalCount: Int!

  """A list of edges."""
  edges: [UserPreferenceEdge!]!

  """Information to aid in pagination."""
  pageInfo: PageInfo!
}

type UserPreferenceEdge {
  """The item at the end of the edge in the connection."""
  node: UserPreference!

  """A cursor for use in pagination."""
  cursor: String!
}

"""Parameters required to define or modify a cipher blob."""
input CipherBlobInput {
  """
  The algorithm used to encrypt the private key. Currently supports only AES with a 256-bit key in CBC mode.
  """
  cipher: String!

  """
  The method used to derive a cryptographic key from a password. Currently only supports Password-Based Key Derivation Function 2 (PBKDF2).
  """
  keyDerivation: String!

  """The cryptographic hash function used. Currently supports only SHA-256."""
  keyHasher: String!

  """
  The number of iterations for the key derivation function. Typically, a higher number means stronger security at the cost of longer computation time.
  """
  iter: Int!

  """
  The salt value used in the key derivation function. Helps in preventing rainbow table attacks.
  """
  salt: String!

  """
  Initialization Vector (IV) used for the encryption process in CBC mode. Ensures that the encryption is unique even with the same data and key.
  """
  iv: String!

  """The encrypted version of the private key."""
  cipherText: String!

  """
  Hash value of the encrypted data, ensuring its integrity and authenticity.
  """
  hash: String!
}

type Query {
  """
  Fetches the currently authenticated user, often referred to as the viewer.
  Initiates the retrieval of a user's membership to an organization, which can be further resolved via the `organizations` field.
  Serves as the primary entry point for all user-related queries.
  """
  viewer: User!

  """Lookup a network's details."""
  network(
    """The network identifier, a UUID string."""
    networkId: ID

    """The CAIP-2 identifier of the network."""
    caip2: ID
  ): Network

  """Paginate through all networks supported by the levain platform."""
  networks(
    """The number of items to return per page."""
    first: Int = 25

    """The forward cursor to start returning items from. `|->|->|->`"""
    after: String

    """The backward cursor to start returning items from. `<-|<-|<-|`"""
    before: String

    """Optionally filter by the protocol type of the network."""
    protocolTypes: [ProtocolType!]

    """Optionally filter by the network family of the network."""
    networkFamilies: [NetworkFamily!]
  ): PaginatedNetwork!

  """Retrieves the details of an asset."""
  asset(
    """The CAIP-19 asset identifier."""
    caip19: ID

    """The CAIP-19 asset identifier. An alias for `caip19`."""
    identifier: ID

    """The system-generated ID of the network asset."""
    networkAssetId: ID
  ): NetworkAsset

  """
  Lookup an organization by its `orgId`.
  All organization sub-queries are protected by a role-based authorization logic with different filter applied to different roles dependent of the user's role in the organization.
  This is the root query for all organization-driven functionality with all other queries nested under this one.
  """
  organization(
    """A unique 12-digit identifier of an organization."""
    orgId: ID!
  ): Organization!

  """Lookup a WalletDepositAddress by its `walletDepositAddressId`."""
  walletDepositAddress(
    """The system-generated unique ID of the wallet deposit address."""
    walletDepositAddressId: ID!
  ): WalletDepositAddress!

  """Lookup a wallet by its `walletId`."""
  wallet(
    """The system-generated unique ID of the wallet."""
    walletId: ID!
  ): Wallet!
}

type Mutation {
  """Creates a new user."""
  createUser(
    """Parameters required to create a new user."""
    input: CreateUserInput!
  ): User!

  """Update profile details of a user."""
  updateUser(
    """Parameters required to update user details."""
    input: UpdateUserInput!
  ): Boolean!

  """Update notification preferences of a user."""
  updateUserNotifications(
    """Parameters required to update user notification preferences."""
    input: UpdateNotificationsInput!
  ): Boolean!

  """Set a user preference, creating it if it does not exist."""
  setViewerPreference(
    """Parameters of the user preference to set."""
    input: SetUserPreferenceInput!
  ): UserPreference!

  """Delete a user preference."""
  deleteViewerPreference(
    """Parameters of the user preference to delete."""
    input: DeleteUserPreferenceInput!
  ): UserPreference!

  """Creates a free personal organization for the authenticated user."""
  createPersonalFreeOrganization: Organization!

  """
  Activates a wallet after checking if the wallet contract deployment has sufficient confirmations on the blockchain.
  """
  activateWallet(
    """Parameters required to activate a wallet."""
    input: ActivateWalletInput!
  ): Wallet!

  """Join as a member of an organization."""
  joinOrganization(
    """Parameters required to join an organization."""
    input: JoinOrganizationInput!
  ): OrganizationMember!

  """Update data of a member in an organization."""
  updateOrganizationMember(
    """Parameters required to update an organization member."""
    input: UpdateOrganizationMemberInput!
  ): Boolean!

  """Disables an organization member."""
  disableOrganizationMember(
    """Parameters required to disable an organization member."""
    input: DisableOrganizationMemberInput!
  ): Boolean!

  """Enables an organization member who is currently disabled."""
  enableOrganizationMember(
    """Parameters required to enable an organization member."""
    input: EnableOrganizationMemberInput!
  ): Boolean!

  """Sends an organization invitation."""
  sendOrganizationMemberInvitation(
    """Parameters to send an organization invite."""
    input: SendOrganizationMemberInvitationInput!
  ): OrganizationInvitation!

  """Resends an organization invitation."""
  resendOrganizationMemberInvitation(
    """Parameters to resend an organization invitation."""
    input: ResendOrganizationMemberInvitationInput!
  ): OrganizationInvitation!

  """Revokes an existing organization invitation."""
  revokeOrganizationMemberInvitation(
    """Parameters to revoke an organization invitation."""
    input: RevokeOrganizationMemberInvitationInput!
  ): Boolean!

  """
  Create a new gas tank. By default, gas tanks are usable across multiple EVM chains. A gas tank can be confined to a single chain if so desired by specifying the OrganizationNetwork ID. If the gas tank already exists, it will be returned.
  """
  createGasTank(
    """Parameters required to create a new gas tank."""
    input: CreateGasTankInput!
  ): GasTank!
  fundGasTankViaLevainFaucet(
    """Parameters required to create a new gas tank."""
    input: FundGasTankViaLevainFaucetInput!
  ): Boolean!
  addOrganizationNetwork(input: AddOrganizationNetworkInput!): OrganizationNetwork!

  """Update a wallet."""
  updateWallet(
    """Parameters required to update a wallet."""
    input: UpdateWalletInput!
  ): Boolean!

  """Create a new wallet on the specified network."""
  createWallet(
    """Parameters required to create a new wallet."""
    input: CreateWalletInput!
  ): Wallet!

  """
  Executes a funding transaction from the gas tank that the wallet belongs to. Only for the network's native token.
  """
  fundFromGasTank(
    """Parameters to fund an address from the wallet's Gas Tank"""
    input: FundFromGasTankInput!
  ): String!

  """Creates a new wallet access for a member of an organization."""
  addWalletAccess(
    """
    Parameters required to create a new wallet access for an organization member.
    """
    input: AddWalletAccessInput!
  ): WalletAccess!

  """Removes the wallet access of an organization member."""
  revokeWalletAccess(
    """
    Parameters required to remove the wallet access of an organization member.
    """
    input: RevokeWalletAccessInput!
  ): Boolean!

  """Updates the wallet access role of an organization member."""
  updateWalletAccess(
    """
    Parameters required to update the wallet access role of an organization member.
    """
    input: UpdateWalletAccessInput!
  ): Boolean!

  """
  Updates the minimum number of approvals needed for a transaction to be approved.
  """
  setWalletPolicyApprovalThreshold(
    """Parameters required to update the policy approval threshold."""
    input: SetWalletPolicyApprovalThresholdInput!
  ): WalletPolicy!

  """Creates a new whitelist policy for a wallet."""
  createPolicyWhitelist(
    """Parameters required to create a policy whitelist."""
    input: CreatePolicyWhitelistInput!
  ): PolicyWhitelist!

  """Updates a whitelist policy of a wallet."""
  updatePolicyWhitelist(
    """Parameters required to update a whitelist policy."""
    input: UpdatePolicyWhitelistInput!
  ): Boolean!

  """Disables a policy whitelist of a wallet."""
  disablePolicyWhitelist(
    """Parameters required to disable a policy whitelist."""
    input: DisablePolicyWhitelistInput!
  ): Boolean!

  """Refresh the status of a transaction request."""
  refreshTransactionRequestStatus(
    """Parameters required to refresh the transaction request status."""
    input: RefreshTransactionRequestStatusInput!
  ): TransactionRequestStatus!

  """Create a new transaction request."""
  createTransactionRequest(
    """Parameters to initiate a new transaction request for a wallet."""
    input: CreateTransactionRequestInput!
  ): TransactionRequest!

  """Create transaction request (v2)"""
  createRequest(
    """Parameters to initiate a new transaction request for a wallet."""
    input: CreateRequestInput!
  ): TransactionRequest!

  """Withdraw transaction request"""
  withdrawTransactionRequest(
    """Parameters to withdraw a transaction request for a wallet."""
    input: WithdrawTransactionRequestInput!
  ): Boolean!

  """Create a SEND asset transaction request."""
  send(
    """Parameters to initiate a new transaction request for a wallet."""
    input: SendTransactionRequestInput!
  ): TransactionRequest!

  """
  Submit signatures for a transaction request. For EVM transactions, the amount of gas required for execution can be estimated after this step.
  """
  submitSignature(
    """Parameters to submit signatures for a transaction request."""
    input: SubmitSignatureInput!
  ): TransactionRequest! @deprecated(reason: "Use [`submitSignatures`](`#submitSignatures`) instead.")

  """
  Submit signatures for a transaction request. For EVM transactions, the amount of gas required for execution can be estimated after this step.
  """
  submitSignatures(
    """Parameters to submit signatures for a transaction request."""
    input: SubmitSignaturesInput!
  ): TransactionRequest!

  """
  Executes the specified transaction request on chain if it's ready. For EVM smart contract wallets, this entails calling the smart contract's execution function with the Gas Tank.
  """
  executeTransaction(
    """Parameters to execute a signed transaction request for a wallet."""
    input: ExecuteTransactionInput!
  ): TransactionRequest!

  """
  Generates cryptographic digests for a transaction request. Digests are used for verifying the transaction data and ensuring that no unauthorized changes have been made to the transaction.
  """
  createTransactionDigests(
    """Parameters to create digests for transaction validation."""
    input: CreateTransactionDigestsInput!
  ): TransactionRequest!

  """Delete a request."""
  deleteRequest(
    """Parameters required to delete a transaction / signature request."""
    input: DeleteRequestInput!
  ): Boolean!

  """Create a new deposit address."""
  createWalletDepositAddress(
    """Parameters required to create a deposit address."""
    input: CreateWalletDepositAddressInput!
  ): CreateWalletDepositAddressResult!

  """Update a deposit address."""
  updateWalletDepositAddress(
    """Parameters required to update a deposit address."""
    input: UpdateWalletDepositAddressInput!
  ): Boolean!

  """Deploy a wallet deposit address."""
  deployWalletDepositAddress(
    """Parameters required to deploy a deposit address."""
    input: DeployWalletDepositAddressInput!
  ): DeployWalletDepositAddressResult!

  """Flush a wallet deposit address."""
  flushWalletDepositAddress(
    """Parameters required to flush a deposit address."""
    input: FlushWalletDepositAddressInput!
  ): FlushWalletDepositAddressResult!

  """
  Batch flush wallet multiple deposit addresses for multiple ERC20 tokens
  """
  batchFlushWalletDepositAddresses(
    """
    Parameters required to batch flush multiple deposit addresses for multiple ERC20 tokens
    """
    input: BatchFlushWalletDepositAddressesInput!
  ): BatchFlushWalletDepositAddressesResult!

  """
  Activate a wallet deposit address when it has met the necessary number of block confirmations.
  """
  activateWalletDeposit(
    """The parameters required to activate a wallet deposit address"""
    input: ActivateWalletDepositInput!
  ): ActivateWalletDepositResult!

  """Approve a transaction request."""
  approveTransactionRequest(
    """The data required to approve a transaction request."""
    input: ApproveTransactionRequestInput!
  ): ApproveTransactionRequestResult!

  """Reject a transaction request."""
  rejectTransactionRequest(
    """The data required to reject a transaction request."""
    input: RejectTransactionRequestInput!
  ): TransactionRequestApproval!

  """Creates a signature request for a transaction request."""
  createSignatureRequest(
    """Parameters to create the signature request."""
    input: CreateSignatureRequestInput!
  ): CreateSignatureRequestResult!

  """Approves a signature request."""
  approveSignatureRequest(
    """Parameters to approve the signature request."""
    input: ApproveSignatureRequestInput!
  ): ApproveSignatureRequestResult!

  """Requests owner signatures for a transaction request."""
  requestOwnerSignatures(
    """Parameters to request owner signatures."""
    input: RequestOwnerSignaturesInput!
  ): RequestOwnerSignaturesResult!

  """Resolves an EIP-1271 signature."""
  resolveEIP1271Signature(
    """Parameters to resolve an EIP-1271 signature."""
    input: ResolveEIP1271SignatureInput!
  ): ResolveEIP1271SignatureResult!

  """Rejects a signature request."""
  rejectTransactionRequestSignature(
    """Parameters to reject the signature request."""
    input: RejectTransactionRequestSignatureInput!
  ): Boolean!

  """Sets the final approver for signing of transactions in a wallet."""
  setWalletFinalApprover(
    """Parameters required to set the final approver in a wallet."""
    input: SetWalletFinalApproverInput!
  ): Boolean!

  """Disables the signer from signing of transactions in a wallet."""
  disableWalletSigner(
    """Parameters required to disable the signer of a wallet."""
    input: DisableWalletSignerInput!
  ): Boolean!

  """
  Share a wallet key with a wallet member. The wallet member must fetch the key and decrypt it client-side. If there's an existing password, it will be replaced with the new one. The wallet member must have the approver role.
  """
  shareWalletKey(input: ShareWalletKeyInput!): Password!
  registerWalletPassword(
    """Parameters required to register a wallet member's password."""
    input: RegisterWalletPasswordInput!
  ): Password!

  """Creates a new key in an organization."""
  createKey(
    """Parameters required to create a new key."""
    input: CreateKeyInput!
  ): Key!

  """Update a key."""
  updateKey(
    """Parameters required to update a key."""
    input: UpdateKeyInput!
  ): Boolean!

  """Creates a new webhook in an organization."""
  createWebhook(
    """Parameters required to create a new webhook."""
    input: CreateWebhookInput!
  ): OrganizationWebhook!

  """Delete a webhook."""
  deleteWebhook(
    """Parameters required to delete a webhook."""
    input: DeleteWebhookInput!
  ): Boolean!
}

input CreateUserInput {
  """User's first name."""
  firstName: String!

  """User's last name."""
  lastName: String!

  """User's marketing opt-in."""
  marketingOptIn: Boolean

  """User's product updates opt-in."""
  productUpdatesOptIn: Boolean
}

input UpdateUserInput {
  """User's first name."""
  firstName: String!

  """User's last name."""
  lastName: String!
}

input UpdateNotificationsInput {
  """User's marketing opt-in."""
  marketingOptIn: Boolean

  """User's product updates opt-in."""
  productUpdatesOptIn: Boolean
}

input SetUserPreferenceInput {
  """Key of the preference. A user can have only one preference per key."""
  key: String!

  """Value of the preference."""
  value: String!
}

input DeleteUserPreferenceInput {
  """Key of the preference. A user can have only one preference per key."""
  key: String!
}

input ActivateWalletInput {
  """
  A unique 12-digit identifier of an organization. This field is deprecated. You do not need to provide it anymore, it will be inferred from the walletId.
  """
  orgId: ID

  """The system-generated unique ID of the wallet."""
  walletId: ID!

  """
  The minimum number of block confirmations required for the network. This field is deprecated. You do not need to provide it anymore, it will be inferred from the walletId.
  """
  minConfirmations: Int
}

input JoinOrganizationInput {
  """The user's invitation code to join an organization."""
  invitationCode: String!
}

input UpdateOrganizationMemberInput {
  """
  The system-generated unique ID of the organization member to be updated.
  """
  memberId: ID!

  """The new role of the organization member."""
  role: OrganizationMemberRole!

  """The unique 12-digit identifier of the organization."""
  orgId: ID!
}

input DisableOrganizationMemberInput {
  """The system-generated unique ID of the organization member."""
  memberId: ID!

  """The unique 12-digit identifier of the organization."""
  orgId: ID!
}

input EnableOrganizationMemberInput {
  """The system-generated unique ID of the organization member."""
  memberId: ID!

  """The unique 12-digit identifier of the organization."""
  orgId: ID!
}

input SendOrganizationMemberInvitationInput {
  """The email address of the user."""
  email: String

  """The role of the member in the organization."""
  role: OrganizationMemberRole!

  """The unique 12-digit identifier of an organization."""
  orgId: ID!
}

input ResendOrganizationMemberInvitationInput {
  """The system-generated unique ID of the organization invitation."""
  invitationId: ID!

  """The unique 12-digit identifier of an organization."""
  orgId: ID!
}

input RevokeOrganizationMemberInvitationInput {
  """The system-generated unique ID of the organization invitation."""
  invitationId: ID!

  """The unique 12-digit identifier of an organization."""
  orgId: ID!
}

input CreateGasTankInput {
  """The id of the organization."""
  orgId: ID!

  """
  The identifier of the network within the organization where the gas tank has been deployed. Specifying this field creates a single-chain Gas Tank, confining it operate on a single EVM network.This field is no longer necessary since gas tanks are no longer confined to a single chain.
  """
  organizationNetworkId: ID
}

input FundGasTankViaLevainFaucetInput {
  """The id of the organization."""
  orgId: ID!

  """The id of the gas tank."""
  gasTankId: ID!

  """The id of the network."""
  networkId: String!
}

input AddOrganizationNetworkInput {
  """
  The networkId of the network to be added to an organization. It must belong to an allowed network family and must also be available.
  """
  networkId: ID!

  """The unique 12-digit identifier of the organization."""
  orgId: ID!
}

input UpdateWalletInput {
  """The system-generated unique ID of the wallet."""
  walletId: ID!

  """The new name of the wallet."""
  name: String

  """The new description of the wallet."""
  description: String
}

input CreateWalletInput {
  """A unique 12-digit identifier of an organization."""
  orgId: ID!

  """
  The ID of the OrganizationNetwork to create the wallet on. This is no longer required, please use `network` instead.
  """
  organizationNetworkId: ID

  """
  The CAIP-2 URI / ID of the OrganizationNetwork to create the wallet on.
  """
  network: String

  """
  The type of wallet to create. Wallets have different capabilities, security characteristics and costs depending on the underlying implementation. For example, Levain's fork of SimpleMultiSig is simple and immutable by design, while Safe is more complex but comes with a greater feature-set such as extensibility and on-chain policy controls. Ultimately, the choice between different Wallet types boils down to use-case.
  """
  type: WalletType!

  """The human-readable name of the wallet."""
  name: String!

  """
  A description of the wallet. Use this field to provide additional context about the wallet, e.g. its purpose.
  """
  description: String

  """
  The main key that will be part of the 2-of-3 multi-sig wallet. Levain will not have access to this key.
  """
  mainKey: MainKey!

  """
  The backup key that will be part of the 2-of-3 multi-sig wallet, to be used in the event the first key is lost and unrecoverable. Levain will not have access to this key.
  """
  backupKey: BackupKey!

  """
  Indicates if the Wallet should be deployed using the EIP-1167 proxy pattern. If true, the wallet will be deployed using the EIP-1167 proxy pattern. If false, the wallet will be deployed using the standard contract deployment pattern. 
  """
  use1167Proxy: Boolean = true

  """
  (EVM only) When using the EIP-1167 Proxy Pattern, we can specify a salt to be used for the deployment. This will ensure the address will be deterministic and will have the same address across all chains. If not specified, a random salt will be used. Expected to be a hexadecimal format string of length 66 (0x + 32 bytes). For example: `0x1111111111111111111111111111111111111111111111111111111111111111`. 
  """
  salt: String
}

input MainKey {
  """
  The encrypted private key of the wallet. The private key is encrypted by a password generated on the client. Hence, the raw private key will never be readable by Levain.
  """
  encryptedPrivateKey: CipherBlobInput!

  """Key ID of an existing unconsumed SCALAR_NEUTERED key."""
  keyId: ID!

  """
  The ID of the password recovery key used to encrypt the wallet password (which is used to encrypt the Main private key). The encryption of the wallet password is for recovering the wallet password in the event it is lost or forgotten.
  """
  passwordRecoveryKeyId: ID!
}

input BackupKey {
  """Key ID of an existing unconsumed SCALAR_NEUTERED key."""
  keyId: ID!
}

"""Parameters to fund an address from the wallet's Gas Tank"""
input FundFromGasTankInput {
  """
  The ID of the wallet to fund the address from. The funding Gas Tank will be inferred from this wallet ID.
  """
  walletId: ID!

  """
  The address to fund. The network the address is on will be inferred from the parent wallet.
  """
  address: String!

  """
  The amount to send, in canonical units. E.g. if the input amount is `1`, and the wallet is an Ethereum wallet, the amount funded will be 1 ETH.
  """
  amount: BigNumber!
}

input AddWalletAccessInput {
  """The wallet role of the organization member."""
  role: WalletMemberRole!

  """The system-generated unique ID of the organization member."""
  memberId: ID!

  """The system-generated unique ID of the wallet."""
  walletId: ID!

  """
  The unique 12-digit identifier of an organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID
}

input RevokeWalletAccessInput {
  """
  The system-generated unique ID of the organization member's wallet access.
  """
  walletAccessId: ID!

  """
  The unique 12-digit identifier of an organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID
}

input UpdateWalletAccessInput {
  """The new wallet role of the organization member."""
  role: WalletMemberRole!

  """
  The system-generated unique ID of the organization member's wallet access.
  """
  walletAccessId: ID!

  """
  The unique 12-digit identifier of an organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID
}

input SetWalletPolicyApprovalThresholdInput {
  """
  A unique 12-digit identifier of an organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID

  """The system-generated unique ID of the wallet policy to be updated."""
  policyId: ID!

  """Minimum number of approvals required to approve a transaction."""
  approvalThreshold: Int!
}

input CreatePolicyWhitelistInput {
  """The address of the policy whitelist."""
  address: String!

  """The system-generated unique ID of the wallet."""
  walletId: ID!

  """The label of the policy whitelist."""
  label: String!
}

input UpdatePolicyWhitelistInput {
  """The ID of the whitelist policy that is to be updated."""
  policyId: ID!

  """The label of the whitelist policy that is to be updated."""
  label: String!

  """
  The system-generated unique ID of the wallet. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  walletId: ID
}

input DisablePolicyWhitelistInput {
  """The ID of the whitelist policy that is to be disabled."""
  policyId: ID!

  """
  The system-generated unique ID of the wallet. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  walletId: ID
}

"""Parameters to refresh a transaction request status."""
input RefreshTransactionRequestStatusInput {
  """The system-generated unique ID of the transaction request."""
  requestId: ID

  """
  The system-generated unique ID of the transaction request. This field is deprecated, use `requestId` instead. Will be removed soon.
  """
  transactionRequestId: ID
}

"""Parameters to initiate a new transaction request for a wallet."""
input CreateTransactionRequestInput {
  """The system-generated unique ID of the wallet."""
  walletId: ID!

  """
  The system-generated unique ID of the NetworkAsset associated with the transaction request, or `null` if not associated with a specific asset.
  """
  networkAssetId: ID

  """The detailed transaction request data."""
  transactionData: NewTransactionRequestData

  """Transaction inputs when sending an ERC20 or TRC20 token."""
  tokenTransactionInput: BuildTransactionInput

  """
  Data related to the transaction fee. This field is deprecated, the fee values are specified at signing time instead. Will be removed soon.
  """
  feeData: NewTransactionRequestFeeData

  """Type or category of the transaction."""
  type: String

  """
  A unique 12-digit identifier of an organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID

  """
  A unique string to identify the request. This string serves as an idempotency key; providing this value guarantees that the request will only be created once, mitigating the risks of accidental double-spends.
  """
  clientRequestId: String

  """Remarks of the transaction request."""
  remarks: String
}

"""Wrapper for the transaction request data for different wallet types."""
input NewTransactionRequestData {
  """
  Transaction request data for a [Safe](https://docs.safe.global/getting-started/readme) smart contract wallet.
  """
  safe: NewSafeTransactionRequestData

  """Transaction request data for a simple multi-signature wallet."""
  simpleMultiSig: NewSimpleMultiSigTransactionRequestData

  """Transaction request data for a Tron multi-signature wallet."""
  tron: NewTronTransactionRequestData
}

"""
Parameters for initiating a new transaction request on a [Safe](https://docs.safe.global/getting-started/readme) smart contract wallet.
"""
input NewSafeTransactionRequestData {
  """The recipient address of the transaction."""
  to: String!

  """
  The amount of cryptocurrency to be transferred. If the transaction is for token transfer or contract interaction, this value might be 0.
  """
  value: String!

  """
  Encoded data payload. For simple transfers, it’s an empty string. For contract interactions, it contains the method call and its arguments.
  """
  data: String!

  """Indicates the type of operation: 0 for calls, 1 for delegate calls."""
  operation: Int!

  """
  The minimum amount of gas units that should be used for the transaction.
  """
  baseGas: String!

  """
  The cost per unit of gas (e.g. in wei). A higher value will make the transaction execute faster but is also more expensive.
  """
  gasPrice: String!

  """Address of the token in which transaction fees will be paid."""
  gasToken: String!

  """
  Address that receives leftover gas (e.g. in wei) from the executed transaction. If set to 0x000...000, it defaults to the sender of the transaction.
  """
  refundReceiver: String!

  """
  A unique number to prevent replay attacks. Incremented with each transaction sent from [Safe](https://docs.safe.global/getting-started/readme).
  """
  nonce: Int!

  """
  Estimation of how much gas the transaction will consume, allowing to define the refund for the executor.
  """
  safeTxGas: String!
}

"""
Parameters for creating a new simple multi-signature transaction request.
"""
input NewSimpleMultiSigTransactionRequestData {
  """The address of the destination of the transaction."""
  destination: String!

  """The amount of the transaction."""
  value: String!

  """
  This field is not necessary since the `nonce` should not be provided at transaction request initiation time. Will be removed soon.
  """
  nonce: Int

  """The data of the transaction."""
  data: String!

  """
  The maximum amount of gas to consume for the transaction. This field is not necessary since the `gasLimit` can be estimated server-side, however, the client can still set a gas limit.
  """
  gasLimit: String
}

input NewTronTransactionRequestData {
  """
  The JSON serialized string of the Tron transaction. Build the transaction with a suitable tron SDK. This field is deprecated, use the `json` field instead. Will be removed soon.
  """
  raw: String

  """
  The JSON representation of the Tron transaction. Build the transaction with a suitable tron SDK, or with the `buildTransaction` resolved field.
  """
  json: JSON
}

"""
Parameters for defining a new fee structure associated with a transaction request. This field is deprecated and should not be used.
"""
input NewTransactionRequestFeeData {
  """
  The estimated total fees. Typically denominated in wei for EVM-based chains.
  """
  estimatedTotalFees: String!

  """*Deprecated and will be removed soon.*"""
  maxPriorityFeePerGas: String!

  """*Deprecated and will be removed soon.*"""
  maxFeePerGas: String!
}

"""Parameters to initiate a intent based transaction request."""
input CreateRequestInput {
  """The system-generated unique ID of the wallet."""
  walletId: ID!
  intent: TransactionIntent!

  """
  A unique string to identify the request. This string serves as an idempotency key; providing this value guarantees that the request will only be created once, mitigating the risks of accidental double-spends.
  """
  clientRequestId: String

  """Remarks of the transaction request."""
  remarks: String
}

input TransactionIntent {
  SEND: SendTransactionInput
  SEND_TO_MANY: SendToManyTransactionInput
  CONSOLIDATE: ConsolidateTransactionInput
  UTXO_TO_ACCOUNT: UtxoToAccountTransactionInput
  ACCOUNT_TO_UTXO: AccountToUtxoTransactionInput
}

input SendTransactionInput {
  type: String!

  """Sender address."""
  from: String!

  """Recipient address."""
  to: String!

  """Asset being sent."""
  asset: String!

  """Amount to send"""
  amount: BigNumber!
}

input SendToManyTransactionInput {
  type: String!

  """Sender addresses."""
  from: [String!]!
  to: [SendToManyToInput!]!
}

input SendToManyToInput {
  """Recipient address."""
  destination: String!

  """Asset being sent."""
  asset: String!

  """Amount to send"""
  amount: BigNumber!
}

input ConsolidateTransactionInput {
  type: String!
  from: [ConsolidateFromInput!]!

  """Recipient address."""
  to: String!
}

input ConsolidateFromInput {
  from: String!
  asset: String!
}

input UtxoToAccountTransactionInput {
  type: String!
  from: [String!]!
  to: String!
  amount: BigNumber!
}

input AccountToUtxoTransactionInput {
  type: String!
  from: String!
  amount: BigNumber!
}

"""Parameters to withdraw a transaction request."""
input WithdrawTransactionRequestInput {
  """The system-generated unique ID of the transaction"""
  requestId: ID!
}

"""Parameters to initiate a SEND transaction request for a wallet."""
input SendTransactionRequestInput {
  """The system-generated unique ID of the wallet."""
  walletId: ID!

  """
  The system-generated unique ID of the NetworkAsset associated with the transaction request, or `null` if not associated with a specific asset.
  """
  networkAssetId: ID

  """
  A unique string to identify the request. This string serves as an idempotency key; providing this value guarantees that the request will only be created once, mitigating the risks of accidental double-spends.
  """
  clientRequestId: String

  """Remarks of the transaction request."""
  remarks: String

  """
  A unique 12-digit identifier of an organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID

  """The detailed transaction request data."""
  data: SendRequestData!
}

input SendRequestData {
  """Recipient address."""
  to: String!

  """
  Amount of asset to be sent, denominated in canonical units. For example, `1` ETH instead of `10^18` wei, `1` BTC instead of `10^8` sats, `1` TRX  instead of `10^6` sun. 
  """
  amount: BigNumber!

  """CAIP-19 URI of the asset to be sent."""
  asset: String!

  """The network fee level for the transaction. Defaults to `Standard`."""
  feeLevel: NetworkFeeLevel = Standard
}

"""Parameters to submit a signature for a multi-sig wallet."""
input SubmitSignatureInput {
  """The system-generated unique ID of the transaction request."""
  requestId: ID!

  """
  Signature of one of the wallet owners, authorizing the transaction request to be executed on chain.
  """
  signature: ID!

  """
  A unique 12-digit identifier of an organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID

  """
  The system-generated unique ID of the wallet. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  walletId: ID
}

"""Parameters to submit a signature for a multi-sig wallet."""
input SubmitSignaturesInput {
  """The system-generated unique ID of the transaction request."""
  requestId: ID!

  """
  Signatures of one of the wallet owners, authorizing the transaction request to be executed on chain.
  """
  signatures: [SignatureDigestInput!]!
}

"""Digest for the corresponding signature"""
input SignatureDigestInput {
  """Digest of the signature"""
  digestId: String!

  """Signature of the digest"""
  signature: String!
}

"""
Parameters to execute a signed transaction on-chain for a multi-sig wallet.
"""
input ExecuteTransactionInput {
  """The system-generated unique ID of the transaction request."""
  requestId: ID!

  """
  Signature of one of the wallet owners, authorizing the transaction request to be executed on chain. This field is deprecated, use `signatures` instead. Will be removed soon.
  """
  signature: String

  """
  Signature of one of the wallet owners, authorizing the transaction request to be executed on chain.
  """
  signatures: [SignatureDigestInput!]

  """The network fee level for the transaction. Defaults to `Standard`."""
  feeLevel: NetworkFeeLevel = Standard

  """
  The [BlockTag](https://docs.ethers.org/v5/api/providers/types/#providers-BlockTag) from which to source the nonce for the on-chain transaction. Defaults to `pending`. Only applicable for EVM chains.
  """
  nonceFrom: String = "pending"

  """
  A unique 12-digit identifier of an organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID

  """
  The system-generated unique ID of the wallet. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  walletId: ID
}

"""Parameters to create digests for transaction validation."""
input CreateTransactionDigestsInput {
  """The system-generated unique ID of the transaction request."""
  requestId: ID!

  """Optional nonce for the transaction."""
  nonce: Int

  """
  A unique 12-digit identifier of an organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID

  """
  The system-generated unique ID of the wallet. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  walletId: ID
}

"""Parameters required to delete a transaction / signature request."""
input DeleteRequestInput {
  """The system-generated unique ID of the request."""
  requestId: ID!
}

"""Parameters to pass in when creating a new wallet deposit address."""
input CreateWalletDepositAddressInput {
  """The system-generated unique ID of the wallet."""
  walletId: ID!

  """The label of the deposit address."""
  label: String!

  """
  Indicates if the client wants their deposit address auto deployed. If not specified, this defaults to false.
  """
  toAutoDeploy: Boolean = false

  """
  (EVM only) The salt to use for deterministic address generation. Expected to be a hexadecimal format string of length 66 (0x + 32 bytes). For example: `0x1111111111111111111111111111111111111111111111111111111111111111`. 
  """
  salt: String

  """
  A unique 12-digit identifier of an organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID
}

"""
Parameters to pass in when updating the label of a wallet deposit address.
"""
input UpdateWalletDepositAddressInput {
  """The system-generated unique ID of the created deposit address."""
  walletDepositAddressId: ID!

  """The label of the deposit address."""
  label: String!

  """
  The system-generated unique ID of the wallet. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  walletId: ID

  """
  A unique 12-digit identifier of an organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID
}

"""Parameters to pass when deploying a new wallet deposit address"""
input DeployWalletDepositAddressInput {
  """The system-generated unique ID of the created deposit address."""
  walletDepositAddressId: ID!

  """
  The system-generated unique ID of the wallet. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  walletId: ID

  """
  The unique 12-digit identifier of the organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID

  """
  The ID of the OrganizationNetwork to create the wallet on. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  organizationNetworkId: ID
}

"""Parameters to pass when flushing a wallet deposit address."""
input FlushWalletDepositAddressInput {
  """The system-generated unique ID of the created deposit address."""
  walletDepositAddressId: ID!

  "\n      An optional field that signifies the on-chain address of a ERC/TRC-20 asset contract.\n      If this field and the networkAssetId field is not specified, an attempt will be made to flush the native asset on chain.\n      \n      For EVM based chains, leaving this field empty essentially does nothing since native assets are automatically flushed for EVM chains.\n      This field is deprecated - use the networkAssetId field instead.\n    "
  erc20Address: String

  "\n      An optional field that signifies the network asset which is being flushed.\n      If this field and the erc20Address field is not specified, an attempt will be made to flush the native asset on chain.\n      \n      For EVM based chains, leaving this field empty essentially does nothing since native assets are automatically flushed for EVM chains.\n    "
  networkAssetId: ID

  """
  The unique 12-digit identifier of the organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID

  """
  The system-generated unique ID of the wallet. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  walletId: ID

  """
  The system-generated unique ID of the organization network. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  organizationNetworkId: ID
}

"""
Parameters to pass when batch flushing wallet deposit addresses with multiple ERC20 tokens
"""
input BatchFlushWalletDepositAddressesInput {
  """List of system-generated unique IDs for the created deposit addresses"""
  walletDepositAddressIds: [ID!]!

  """List of ERC20 addresses to flush. Use `tokenCaip19Uris` instead"""
  erc20Addresses: [String!]

  """List of assets to flush"""
  tokenCaip19Uris: [String!]

  """
  The network fee level for the transaction. Defaults to `Standard`, only applicable for EVM wallet
  """
  feeLevel: NetworkFeeLevel = Standard

  """
  The system-generated unique ID of the wallet. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  walletId: ID

  """
  The unique 12-digit identifier of the organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID

  """
  The system-generated unique ID of the organization network. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  organizationNetworkId: ID
}

"""Parameters to pass when activating a wallet deposit address."""
input ActivateWalletDepositInput {
  """The system-generated unique ID of the created deposit address."""
  walletDepositAddressId: ID!

  """
  The unique 12-digit identifier of the organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID

  """
  The system-generated unique ID of the wallet. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  walletId: ID
}

"""The parameters to approve a transaction request."""
input ApproveTransactionRequestInput {
  """The system-generated unique ID of the transaction request."""
  transactionRequestId: ID!
}

"""The parameters to reject a transaction request."""
input RejectTransactionRequestInput {
  """The system-generated unique ID of the transaction request."""
  transactionRequestId: ID!
}

"""Params for creating a transaction request signature."""
input CreateSignatureRequestInput {
  """
  The unique 12-digit identifier of the organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID

  """The system-generated unique ID of the wallet."""
  walletId: ID!

  """Context for custom message signing."""
  messageSigningContext: NewMessageSigningContext!
}

"""
Parameters to provide signature-related details for a new transaction request.
"""
input NewMessageSigningContext {
  Eip191PersonalSign: Eip191SigningData
  Eip712SignTypedDataV4: Eip712SigningData
}

input Eip191SigningData {
  """URL of the dApp that is requesting the signature."""
  url: String!

  """Name of the dApp that is requesting the signature."""
  requester: String!

  """Icon URL of dApp that is requesting the signature"""
  iconUrl: String

  """Message that the dApp is requesting to sign (EIP1271)"""
  message: String!
}

input Eip712SigningData {
  """URL of the dApp that is requesting the signature."""
  url: String!

  """Name of the dApp that is requesting the signature."""
  requester: String!

  """Icon URL of dApp that is requesting the signature"""
  iconUrl: String

  """TypedData that the dApp is requesting to sign (EIP712)"""
  typedDataV4Payload: Eip712TypedDataV4!
}

input Eip712TypedDataV4 {
  types: JSON!
  primaryType: String!
  domain: JSON!
  message: JSON!
}

"""Params for approving a transaction signature request."""
input ApproveSignatureRequestInput {
  """
  The unique 12-digit identifier of the organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID

  """
  The system-generated unique ID of the wallet. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  walletId: ID

  """The system-generated unique ID of the signature request."""
  signatureRequestId: ID!
}

"""Params for requesting owner signatures."""
input RequestOwnerSignaturesInput {
  """
  The unique 12-digit identifier of the organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID

  """The digest."""
  digest: String

  """
  The system-generated unique ID of the wallet. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  walletId: ID

  """The system-generated unique ID of the signature request."""
  signatureRequestId: ID!

  """The signature."""
  signature: String!
}

"""Parameters for resolving an EIP-1271 signature."""
input ResolveEIP1271SignatureInput {
  """
  The unique 12-digit identifier of the organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID

  """
  The system-generated unique ID of the wallet. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  walletId: ID

  """The system-generated unique ID of the signature request."""
  signatureRequestId: ID!
}

"""Params for rejecting a transaction signature request."""
input RejectTransactionRequestSignatureInput {
  """
  The unique 12-digit identifier of the organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID

  """The system-generated unique ID of the transaction request."""
  transactionRequestId: ID!

  """
  The system-generated unique ID of the wallet. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  walletId: ID
}

input SetWalletFinalApproverInput {
  """The system-generated unique ID of the wallet policy to be updated."""
  policyId: ID!

  """The final approver's wallet access ID."""
  walletMemberAccessId: ID!

  """
  The system-generated unique ID of the wallet. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  walletId: ID
}

input DisableWalletSignerInput {
  """The system-generated unique ID of the wallet policy to be updated."""
  policyId: ID!

  """The signer's wallet access ID."""
  walletMemberAccessId: ID!
}

input ShareWalletKeyInput {
  """"""
  walletKeyId: ID!

  """"""
  walletAccessId: ID!

  """
  The encrypted private key of the wallet, encrypted with a secret generated client-side. This encrypted private key is transient, and will be deleted after the new wallet member has successfully decrypted it and created their own encrypted private key. 
  """
  transientEncryptedPrivKey: CipherBlobInput!
}

"""The input parameters to register a wallet key password."""
input RegisterWalletPasswordInput {
  walletKeyPasswordId: ID!

  """The symmetrically encrypted private key."""
  encrypted: CipherBlobInput!

  """
  The password recovery key ID, enabling the wallet member to recover their password if lost.
  """
  passwordRecoveryKeyId: ID
}

input CreateKeyInput {
  """A unique 12-digit identifier of an organization."""
  orgId: ID!

  """The human-readable name of the key."""
  name: String

  """The type of key. Refer to [`KeyType`](../reference/enums#keytype)"""
  type: KeyType!

  """If `true`, retrieves an existing key instead of creating a new one."""
  retrieveIfExists: Boolean!

  """
  Public key of an asymmetrical key pair, applicable when importing material for a neutered key type.
  """
  publicKey: String
}

input UpdateKeyInput {
  """
  A unique 12-digit identifier of an organization. No longer required and will be ignored as it will be automatically inferred. Will be removed soon.
  """
  orgId: ID

  """The new name of the key."""
  name: String!

  """The system-generated unique ID of the key to be updated."""
  keyId: ID!
}

input CreateWebhookInput {
  """A unique 12-digit identifier of an organization."""
  orgId: ID!

  """URL of client webhook endpoint"""
  webhookUrl: String!

  """Array of CAIP2 identifiers"""
  subscribedNetworks: [String!]
}

input DeleteWebhookInput {
  """Unique identifier of the webhook"""
  webhookId: ID!

  """A unique 12-digit identifier of an organization."""
  orgId: ID!
}