schema.graphql

type Account {
  """
  GPS coordinates for the account that can be used to place the related business on a map
  """
  coordinates: Coordinates
  createdAt: Timestamp!
  id: ID!
  level: AccountLevel!
  owner: User!
  status: AccountStatus!
  title: String
  username: Username
}

type AccountDetailPayload {
  accountDetails: Account
  errors: [Error!]!
}

enum AccountLevel {
  ONE
  TWO
}

enum AccountStatus {
  ACTIVE
  LOCKED
}

input AccountUpdateLevelInput {
  level: AccountLevel!
  uid: ID!
}

input AccountUpdateStatusInput {
  status: AccountStatus!
  uid: ID!
}

"""
An authentication code valid for a single use
"""
scalar AuthToken

type AuthTokenPayload {
  authToken: AuthToken
  errors: [Error!]!
}

input BusinessUpdateMapInfoInput {
  latitude: Float!
  longitude: Float!
  title: String!
  username: Username!
}

input ColdStorageRebalanceToHotWalletInput {
  amount: SatAmount!
  targetConfirmations: TargetConfirmations = 1
  walletName: String!
}

type Coordinates {
  latitude: Float!
  longitude: Float!
}

interface Error {
  message: String!
  path: [String]
}

enum ExchangeCurrencyUnit {
  BTCSAT
  USDCENT
}

union InitiationVia = InitiationViaIntraLedger | InitiationViaLn | InitiationViaOnChain

type InitiationViaIntraLedger {
  counterPartyUsername: Username
  counterPartyWalletId: WalletId
}

type InitiationViaLn {
  paymentHash: PaymentHash!
}

type InitiationViaOnChain {
  address: OnChainAddress!
}

type InputError implements Error {
  code: InputErrorCode!
  message: String!
  path: [String]
}

enum InputErrorCode {
  INVALID_INPUT
  VALUE_NOT_ALLOWED
  VALUE_TOO_LONG
  VALUE_TOO_SHORT
}

scalar Language

type LightningInvoice {
  confirmedAt: Timestamp
  createdAt: Timestamp!
  description: String!
  expiresAt: Timestamp
  isSettled: Boolean!
  received: SatAmount!
  request: LnPaymentRequest
  secretPreImage: LnPaymentPreImage!
}

type LightningPayment {
  amount: SatAmount
  confirmedAt: Timestamp
  createdAt: Timestamp
  destination: LnPubkey
  request: LnPaymentRequest
  revealedPreImage: LnPaymentPreImage
  roundedUpFee: SatAmount
  status: LnPaymentStatus
}

scalar LnPaymentPreImage

"""
BOLT11 lightning invoice payment request with the amount included
"""
scalar LnPaymentRequest

scalar LnPaymentSecret

enum LnPaymentStatus {
  FAILED
  PENDING
  SETTLED
}

scalar LnPubkey

"""
Text field in a lightning payment transaction
"""
scalar Memo

type Mutation {
  accountUpdateLevel(input: AccountUpdateLevelInput!): AccountDetailPayload!
  accountUpdateStatus(input: AccountUpdateStatusInput!): AccountDetailPayload!
  businessUpdateMapInfo(input: BusinessUpdateMapInfoInput!): AccountDetailPayload!
  coldStorageRebalanceToHotWallet(
    input: ColdStorageRebalanceToHotWalletInput!
  ): PsbtDetailPayload!
  userLogin(input: UserLoginInput!): AuthTokenPayload!
  userRequestAuthCode(input: UserRequestAuthCodeInput!): SuccessPayload!
}

"""
An address for an on-chain bitcoin destination
"""
scalar OnChainAddress

scalar OnChainTxHash

"""
An authentication code valid for a single use
"""
scalar OneTimeAuthCode

scalar PaymentHash

"""
Phone number which includes country code
"""
scalar Phone

"""
Price amount expressed in base/offset. To calculate, use: `base / 10^offset`
"""
type Price {
  base: SafeInt!
  currencyUnit: ExchangeCurrencyUnit!
  formattedAmount: String!
  offset: Int!
}

type PsbtDetail {
  fee: SatAmount!
  transaction: String!
}

type PsbtDetailPayload {
  errors: [Error!]!
  psbtDetail: PsbtDetail
}

type Query {
  accountDetailsByUserPhone(phone: Phone!): Account!
  accountDetailsByUsername(username: Username!): Account!
  allLevels: [AccountLevel!]!
  lightningInvoice(hash: PaymentHash!): LightningInvoice!
  lightningPayment(hash: PaymentHash!): LightningPayment!
  transactionById(id: ID!): Transaction
  transactionsByHash(hash: PaymentHash!): [Transaction]
}

"""
Non-fractional signed whole numeric value between -(2^53) + 1 and 2^53 - 1
"""
scalar SafeInt

"""
(Positive) Satoshi amount
"""
scalar SatAmount

union SettlementVia = SettlementViaIntraLedger | SettlementViaLn | SettlementViaOnChain

type SettlementViaIntraLedger {
  """
  Settlement destination: Could be null if the payee does not have a username
  """
  counterPartyUsername: Username
  counterPartyWalletId: WalletId
}

type SettlementViaLn {
  paymentSecret: LnPaymentSecret
    @deprecated(
      reason: "Shifting property to 'preImage' to improve granularity of the LnPaymentSecret type"
    )
  preImage: LnPaymentPreImage
}

type SettlementViaOnChain {
  transactionHash: OnChainTxHash!
}

type SuccessPayload {
  errors: [Error!]!
  success: Boolean
}

"""
(Positive) Number of blocks in which the transaction is expected to be confirmed
"""
scalar TargetConfirmations

"""
Timestamp field, serialized as Unix time (the number of seconds since the Unix epoch)
"""
scalar Timestamp

"""
Give details about an individual transaction.
Galoy have a smart routing system which is automatically
settling intraledger when both the payer and payee use the same wallet
therefore it's possible the transactions is being initiated onchain
or with lightning but settled intraledger.
"""
type Transaction {
  createdAt: Timestamp!
  direction: TxDirection!
  id: ID!

  """
  From which protocol the payment has been initiated.
  """
  initiationVia: InitiationVia!
  memo: Memo

  """
  Amount of sats sent or received.
  """
  settlementAmount: SatAmount!
  settlementFee: SatAmount!

  """
  Price in USDCENT/SATS at time of settlement.
  """
  settlementPrice: Price!

  """
  To which protocol the payment has settled on.
  """
  settlementVia: SettlementVia!
  status: TxStatus!
}

enum TxDirection {
  RECEIVE
  SEND
}

enum TxStatus {
  FAILURE
  PENDING
  SUCCESS
}

type User {
  createdAt: Timestamp!
  defaultAccount: Account!
  id: ID!
  language: Language!
  phone: Phone!
}

input UserLoginInput {
  code: OneTimeAuthCode!
  phone: Phone!
}

input UserRequestAuthCodeInput {
  phone: Phone!
}

"""
Unique identifier of a user
"""
scalar Username

"""
Unique identifier of a wallet
"""
scalar WalletId