openapi: 3.0.0
info:
  title: Unstoppable Partner API
  description: 'The Partner API requires you to be authorized to access them. To access the Partner API and integrate it into your application, check our [Set up Partner API Access](https://docs.unstoppabledomains.com/partner/) guide.'
  contact:
    email: partnerengineering@unstoppabledomains.com
  version: 2.0.0
externalDocs:
  description: Unstoppable Domains Developer Documentation Portal
  url: https://docs.unstoppabledomains.com
servers:
  - url: https://unstoppabledomains.com/api/v2/resellers/{resellerId}
    description: 'Production Server'
    variables:
      resellerId:
        default: 'udtesting'
        description: 'Partner ID given by Unstoppable Domains'
  - url: https://api.ud-sandbox.com/api/v2/resellers/{resellerId}
    description: 'Sandbox Server'
    variables:
      resellerId:
        default: 'udtesting'
        description: 'Partner ID given by Unstoppable Domains'
tags:
  - name: orders
    description: Create an order and get the status of orders
  - name: domains
    description: Check domain availability and suggestions for purchase or claim
  - name: security
    description: Prepare security parameters for domain orders
  - name: actions (blockchain)
    description: Create, sign and check status of blockchain actions
paths:
  /domains:
    parameters:
      - $ref: '#/components/parameters/DomainNamesParameter'
    get:
      operationId: GetDomains
      security:
        - ApiSecret: []
      tags:
        - domains
      summary: Check multiple domain names availability
      description: Check multiple domain names availability
      responses:
        '200':
          description: Successful
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DomainsAvailabilityResponse'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/PartnerNotFound'
  /domains/{domainName}:
    parameters:
      - $ref: '#/components/parameters/DomainNameParameter'
    get:
      operationId: GetDomain
      tags:
        - domains
      summary: Check domain name availability
      description: Check domain name availability
      responses:
        '200':
          description: Successful
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DomainAvailabilityResponse'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/PartnerNotFound'
  /domains/suggestions:
    parameters:
      - $ref: '#/components/parameters/SearchDomainParameter'
      - $ref: '#/components/parameters/TldsDomainParameter'
    get:
      operationId: GetDomainsSuggestions
      tags:
        - domains
      summary: Get domains suggestions
      description:
        This endpoint is used to provide domains variants based on provided domains and label. Method will provide domains similar to domains provided in domains parameter.
      responses:
        '200':
          description: Valid
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DomainSuggestions'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/PartnerNotFound'
  /domains/suggestions/free:
    parameters:
      - $ref: '#/components/parameters/SearchDomainParameter'
      - $ref: '#/components/parameters/TldsDomainParameter'
    get:
      operationId: GetDomainsSuggestionsFree
      tags:
        - domains
      summary: Get free domains suggestions
      description:
        This endpoint is used to provide free domains suggestions if a partner is eligible for free domains. If partner isn't eligible for free domains suggestions - endpoint will return error.
      responses:
        '200':
          description: Valid
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DomainSuggestions'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/PartnerNotFound'
  /domains/{domainName}/reserve:
    post:
      operationId: PostDomainReserve
      summary: Reserve free domain name for period of time
      description: Reserve free domain name for external user identifier. Usually it's a user identifier or email in a partner's system. Domain name becomes unavailable for selling and claiming to anyone except identity that reserved the domain. Only one domain could be reserved per resellerIdentityKey. Reserve time is 168 hours.
      security:
        - ApiSecret: []
      parameters:
        - $ref: '#/components/parameters/DomainNameParameter'
      tags:
        - domains
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/DomainReverseRequest'
      responses:
        '200':
          description: Valid
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/PartnerNotFound'
  /orders:
    post:
      operationId: PostOrders
      security:
        - {}
        - ApiSecret: []
      tags:
        - orders
      summary: Buy a domain or claim for free
      description:
        This API endpoint is used for buying domains from UD. The blockchain needs time before a transaction is mined. In rare cases, it is possible for someone to front run your purchase, which would result in an order being cancelled. We expect this to happen in less than 1 out of 10000 cases. Please make sure you are using the 'Order Status' endpoint and wait until the transaction is mined.

        Endpoint requires either email or owner address. If email is provided - domain will be linked to Unstoppable website account. If owner address is provided - domain will be minted right into crypto wallet. Optionally user can specify domain records that will be added to the domain once it's minted (i.e. if owner address is provided)
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/DomainOrderRequest'
      responses:
        '200':
          description: Successful
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DomainOrderResponse'
        '400':
          $ref: '#/components/responses/BadRequest'
        '401':
          $ref: '#/components/responses/PartnerNotFound'
  /orders/{orderNumber}:
    parameters:
      - name: orderNumber
        in: path
        description: ID of the order
        required: true
        schema:
          type: string
          example: -Lm9wiYytgrpf4YCWYv6
    get:
      operationId: GetOrder
      description: Use this endpoint to pull the status of the order
      summary: Get order status by order number
      tags:
        - orders
      responses:
        '200':
          description: Successful
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DomainOrderResponse'
        '401':
          $ref: '#/components/responses/PartnerNotFound'
        '404':
          description: Order Not Found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GeneralNotFoundError'
  /security/fingerprintjs/keys:
    post:
      operationId: PostSecurityFingerprintjsKeys
      description: Use this endpoint to fetch Fingerprint public keys
      summary: Get Fingerprint Public Key
      tags:
        - security
      responses:
        '200':
          description: Successful
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/FingerprintKeyResponse'
  /actions:
    get:
      operationId: GetActions
      summary: Searches for domain actions made
      tags:
        - actions (blockchain)
      description: |
        Search for domain actions by user, domain or owner address.
      parameters:
        - name: status
          in: query
          required: false
          description: Blockchain Action Status
          schema:
            type: string
            enum:
              - InProgress
              - Completed
              - Failed
        - name: userId
          in: query
          required: false
          description: User ID
          schema:
            type: number
        - name: domain
          in: query
          required: false
          description: Domain Name
          schema:
            type: string
            example: bogdangusiev.crypto
        - name: ownerAddress
          in: query
          required: false
          description: Domain Owner Address
          schema:
            type: string
        - name: page
          in: query
          required: false
          description: Page Number
          schema:
            type: number
            example: 1
        - name: perPage
          in: query
          required: false
          description: Number of actions per page
          schema:
            type: number
            example: 10

      responses:
        '200':
          description: Successful
          content:
            application/json:
              schema:
                type: 'object'
                properties:
                  count:
                    type: number
                    example: 1
                  actions:
                    type: array
                    items:
                      $ref: '#/components/schemas/BlockchainActionResponse'

    post:
      operationId: PostActions
      summary: Creates a user request to perform certain action on chain
      description: |
        Receives domain name, operation and parameters that needs to be performed on the blockchain.
        Example - set 'crypto.ETH.address' record for 'example.crypto'  domain to '0xffff' value

        Returns the list of transactions that need to be signed by the user in order to perform that operation and optionally a payment invoice in case user wants UD to compensate gas free for those transactions.
      tags:
        - actions (blockchain)
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/BlockchainActionRequest'
      responses:
        '200':
          description: Successful
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BlockchainActionResponse'
        '401':
          $ref: '#/components/responses/PartnerNotFound'
        '404':
          description: Domain Not Found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/GeneralNotFoundError'
  /actions/{actionId}:
    parameters:
      - $ref: '#/components/parameters/BlockchainActionIdParameter'
    get:
      operationId: GetAction
      summary: Returns domain action status
      description: |
        Receives domain action id.
        Returns the list of transactions that need to be signed by the user in order to perform that operation and optionally a payment invoice in case user wants UD to compensate gas free for those transactions.
      tags:
        - actions (blockchain)
      responses:
        '200':
          description: Successful
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/BlockchainActionResponse'
        '401':
          $ref: '#/components/responses/PartnerNotFound'
        '404':
          $ref: '#/components/responses/ActionNotFound'
  /actions/{actionId}/sign:
    parameters:
      - $ref: '#/components/parameters/BlockchainActionIdParameter'
    post:
      operationId: PostActionSign
      summary: Submits required signatures for a blockchain action
      description: |
        A domain action requires the following to be performed:

        * every transaction with `signatureStatus: Required` expects
          * a `signature` for the case of `Meta` transaction and
          * `txHash` for the case of meta transaction
        * Paid stripe intent if present

        This endpoint is designed to let user submit the required data for an action to be executed.
      tags:
        - actions (blockchain)
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/BlockchainActionSignRequest'
      responses:
        '200':
          description: Successful
        '401':
          $ref: '#/components/responses/PartnerNotFound'
        '404':
          $ref: '#/components/responses/ActionNotFound'
components:
  parameters:
    DomainNameParameter:
      name: domainName
      in: path
      required: true
      schema:
        type: string
        example: beresnev.crypto
    DomainNamesParameter:
      name: search
      in: query
      description: Keywords that will be used to check domain(s) availability. Can be domain name(s) with or without TLD.
      required: true
      style: form
      explode: true
      schema:
        type: array
        example:
          - 'fancyfox123.crypto'
          - 'firstname'
          - 'domainsforfree1.888'
        items:
          type: string
          example: 'ryan.crypto'
    BlockchainActionIdParameter:
      name: actionId
      in: path
      description: Action ID obtained from `POST /actions` endpoint
      required: true
      schema:
        type: number
        example: 85530
    SearchDomainParameter:
      name: search
      in: query
      description: Keywords that will be used to build FREE domain suggestions. Can be TLD or domain name.
      required: false
      style: form
      explode: true
      schema:
        type: array
        example:
          - 'fancyfox123.crypto'
          - 'firstname'
          - 'domainsforfree1.888'
        items:
          type: string
          example: 'ryan.crypto'
    TldsDomainParameter:
      name: tlds
      in: query
      description: Limit suggestions output by specific TLDs (crypto, dao, etc.)
      required: false
      style: form
      explode: true
      schema:
        type: array
        example:
          - 'crypto'
          - 'nft'
          - '888'
        items:
          type: string
          example: 'dao'
  responses:
    PartnerNotFound:
      description: Partner Not Found
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/GeneralResellerNotFound'
    BadRequest:
      description: Bad Request
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/GeneralError'
    ActionNotFound:
      description: Action Not Found
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/GeneralNotFoundError'
  schemas:
    FingerprintKeyResponse:
      properties:
        key:
          type: string
          description: Fingerprint public key
          example: TSveZYwtMdTcHjY9MEPa
    DomainReverseRequest:
      properties:
        resellerIdentityKey:
          type: string
          example: 'example@user.com'
          description: 'Unique external identifier of user. Could by ANY string value. Unstoppable will try to match internal and external user id.'
    OrderSecurity:
      description: Additional security parameters. Required if the payment method is 'free'.
      required:
        -  type
        -  identifier
      properties:
        type:
          type: string
          description: Security method providers
          enum:
            - 'fingerprintjs'
          example: 'fingerprintjs'
        identifier:
          type: string
          description: The device identifier. In FingerprintJS, it would be the Visitor ID.
          example: 'i2udKSvRFcN1wOqGLk3J'
    OrderPayment:
      description: Payment type and parameters
      properties:
        method:
          type: string
          enum:
            - 'free'
            - 'stripe'
        properties:
          description: Additional payment method properties
          anyOf:
            - $ref: '#/components/schemas/FreePaymentProperties'
            - $ref: '#/components/schemas/StripePaymentProperties'
      example:
        method: stripe
        properties:
          tokenId: tok_1FAeVFG8PQyZCUJhJp7emswP
    FreePaymentProperties:
      type: object
      description: Properties for the free payment method
    StripePaymentProperties:
      type: object
      description: Properties for the stripe payment method
      example:
        tokenId: tok_1FAeVFG8PQyZCUJhJp7emswP
    DomainOrderRequest:
      properties:
        payment:
          $ref: '#/components/schemas/OrderPayment'
        security:
          type: array
          items:
            $ref: '#/components/schemas/OrderSecurity'
        domains:
          type: array
          items:
            required:
              - 'name'
            properties:
              name:
                type: string
                example: matt.dao
                description: Domain name
              ownerAddress:
                type: string
                example: '0x6EC0DEeD30605Bcd19342f3c30201DB263291589'
                description: Domain recipient wallet address. Email or owner should be provided in order to detect domain receiver. If owner is provided - domain will be minted to the owner address.
                nullable: true
              email:
                type: string
                example: matt@unstoppabledomains.com
                description: Domain recipient email. Email is identifier of Unstoppalbe website account. Email or owner should be provided in order to detect domain received. If email is provided - domain will be linked to email address and could be claimed on chain later.
                nullable: true
              resolution:
                $ref: '#/components/schemas/DomainRecords'
              resellerIdentityKey:
                type: string
                nullable: true
                description: Field is required if domain was reserved. Value should be the same as it was when domain was reserved.
    DomainOrderResponse:
      properties:
        orderNumber:
          type: string
          description: orderID used for later status check
          example: -Lm9wiYytgrpf4YCWYv6
        payment:
          $ref: '#/components/schemas/OrderPayment'
        total:
          type: integer
          description: Total price in USD Cents. For example $10 = 1000.
          example: 0
        items:
          type: array
          items:
            properties:
              domain:
                $ref: '#/components/schemas/Domain'
              mintingTransaction:
                properties:
                  id:
                    $ref: '#/components/schemas/TransactionId'
                  blockchain:
                    $ref: '#/components/schemas/Blockchain'
                  networkId:
                    $ref: '#/components/schemas/NetworkId'
                  hash:
                    $ref: '#/components/schemas/TransactionHash'
                  blockExplorerUrl:
                    type: string
                    description: A link to track transaction status
                    example: 'https://etherscan.io/tx/0x5698544cecaa05f7d155ff59fea48ef28cbd72068c7c3817987a19816d74fb9b'
                  statusGroup:
                    type: string
                    description: Transaction status
                    example: Pending
                    enum:
                      - Pending
                      - Failed
                      - Completed
    DomainSuggestions:
      type: array
      example:
        - name: thetest.crypto
          price: 20000
        - name: hellos.crypto
          price: 20000
        - name: thedomains.888
          price: 200000
      items:
        properties:
          name:
            type: string
            description: Domain name
            example: matt.crypto
            nullable: false
          price:
            description: 'Domain price in USD cents. For example 20000 cents = 200 USD'
            type: integer
            example: 20000
            nullable: false
    Domain:
      properties:
        id:
          type: number
          example: 1001
          description: Id of entity
        name:
          type: string
          example: matt.dao
          description: Domain name
        ownerAddress:
          type: string
          description: Recipient address
          example: '0x6EC0DEeD30605Bcd19342f3c30201DB263291589'
          nullable: true
        resolver:
          type: string
          nullable: true
          description: Resolver address
          example: '0x049aba7510f45BA5b64ea9E658E342F904DB358D'
        registryAddress:
          type: string
          description: Registry address
          example: '0x049aba7510f45BA5b64ea9E658E342F904DB358D'
          nullable: true
        networkId:
          $ref: '#/components/schemas/NetworkId'
        resolution:
          $ref: '#/components/schemas/DomainRecords'
        blockchain:
          $ref: '#/components/schemas/Blockchain'
        freeToClaim:
          type: boolean
          example: true
          default: true
          description: 'Whether domain claiming fee will be paid by Unstoppable Domains'
        node:
          type: string
          description: 'Domain name hash'
          example: '0x756e4e998dbffd803c21d23b06cd855cdc7a4b57706c95964a37e24b47c10fc9'
          externalDocs:
            description: 'Namehashing essentials'
            url: https://docs.unstoppabledomains.com/domain-registry-essentials/namehashing
    Availability:
      properties:
        registered:
          type: boolean
          description: Information if a domain is registered or not
          example: false
        protected:
          type: boolean
          description: Information if a domain is protected or not
          example: false
        price:
          description: Domain price in USD Cents. For example $10 = 1000. Might be null if domain is not available for sale.
          type: integer
          example: 1000
          nullable: true
        availableForFree:
          description: Whether domain is available for free for the partner
          type: boolean
          example: false
        test:
          description: Whether domain is in test namespace
          type: boolean
          example: true
    DomainAvailabilityResponse:
      properties:
        domain:
          $ref: '#/components/schemas/Domain'
        availability:
          $ref: '#/components/schemas/Availability'
    DomainsAvailabilityResponse:
      properties:
        domains:
          type: array
          items:
            $ref: '#/components/schemas/DomainAvailabilityResponse'
    Blockchain:
      type: string
      description: Which chain is being used to mint a domain
      example: 'MATIC'
      enum:
        - 'MATIC'
        - 'ETH'
        - 'ZIL'
    TransactionId:
      type: number
      example: 2883
      description: Transaction ID in UD database
    TransactionHash:
      type: string
      description: Transaction Hash
      example: '0x5588e089b59458b4b34716c3299418e4ea449efbff35c8810f7c189160b1ed57'
    NetworkId:
      type: number
      example: 1
      description: Id of blockchain network (mainnet or testnet)
    DomainRecords:
      description: Domain crypto records
      externalDocs:
        description: Domain records reference
        url: https://docs.unstoppabledomains.com/domain-registry-essentials/records-reference
      type: object
      additionalProperties:
        type: string
      example:
        crypto.ETH.address: '0x6EC0DEeD30605Bcd19342f3c30201DB263291589'
        crypto.BTC.address: 'bc1qxy2kgdygjrsqtzq2n0yrf2493p83kkfjhx0wlh'

    GeneralError:
      required:
        - error
      properties:
        error:
          $ref: '#/components/schemas/BasicError'
        constraints:
          nullable: true
          type: array
          items:
            $ref: '#/components/schemas/BasicError'
    GeneralResellerNotFound:
      properties:
        error:
          $ref: '#/components/schemas/ResellerNotFoundError'
    GeneralNotFoundError:
      properties:
        error:
          $ref: '#/components/schemas/NotFoundError'
    BasicError:
      properties:
        code:
          type: string
          description: Error code
          example: 'ERROR_CODE'
        message:
          type: string
          description: User friendly description of above code
          example: 'Error code explanation'
        field:
          type: string
          description: Estimate error field
          example: 'some field'
        value:
          description: Value of error field
          example: 'some value'
        status:
          type: number
          description: Status code of the response
          example: 400
    NotFoundError:
      properties:
        code:
          type: string
          example: 'NOT_FOUND'
        message:
          type: string
          example: 'Not Found'
        field:
          type: string
          nullable: true
          description: Estimate error field
          example: null
        value:
          description: Value of error field
          example: null
        status:
          type: number
          example: 404
    ResellerNotFoundError:
      properties:
        code:
          type: string
          description: Error code
          example: 'RESELLER_NOT_FOUND'
        message:
          type: string
          description: User friendly description of above code
          example: 'Reseller ID not found'
        field:
          type: string
          nullable: true
          description: Estimate error field
          example: null
        value:
          description: Value of error field
          example: null
        status:
          type: number
          description: Status code of the response
          example: 401
    BlockchainActionRequest:
      properties:
        domain:
          type: string
          nullable: true
          example: bogdangusiev.crypto
          description: Domain name
        gasCompensationPolicy:
          type: string
          description: |
            Gas Compensation Policy
            There are three gas compensation policies that clients can choose, depending on how they want make users send and pay for them.

            * `AlwaysCompensate` - It always assumes using meta transactions. User pays for transactions in USD via stripe payment intent that UD doesn't execute for free (i.e. ETH).
            * `CompensateFree` - backend will use meta-transactions only for the those transactions that UD executes for free (i.e. MATIC).
            * `NeverCompensate` - If a client wants to both make users send and pay for the transactions themselves, it’ll use this policy. Guarantees maximum privacy
          example: CompensateFree
          enum:
            - AlwaysCompensate
            - CompensateFree
            - NeverCompensate
      anyOf:
        - description: |
            `UpdateRecords` action that updates domain crypto records
          properties:
            action:
              type: string
              enum: [UpdateRecords]
            parameters:
              properties:
                records:
                  $ref: '#/components/schemas/DomainRecords'
        - description: |
            `Return` domain action to Unstoppable Domains to receive the refund
          properties:
            action:
              type: string
              enum: [Return]
        - description: |
            `SetReverseResolution` sets transaction message signer address as
            a reverse address for the domain by default or
            removes reverse resolution if `remove: true` parameter is passed.
          properties:
            action:
              type: string
              enum: [SetReverseResolution]
            parameters:
              properties:
                remove:
                  type: boolean
                  nullable: true
                  default: false
        - description: |
            `Transfer` domain action transfers domain from one wallet address to another
          properties:
            action:
              type: string
              enum: [Transfer]
            parameters:
              properties:
                to:
                  type: string
                resetRecords:
                  type: boolean
                  nullable: true
                  default: true
        - description: |
            Actions related to domain bridging between Ethereum and Polygon via Proof of Stake bridge

            * `Withdraw` - move domain from Polygon to Ethereum
            * `Deposit` - move domain from Ethereum to Polygon
          properties:
            action:
              type: string
              enum: [Deposit, Withdraw]
            parameters:
              properties:
                resetRecords:
                  type: boolean
                  nullable: true
                  default: false
                resetReverse:
                  type: boolean
                  nullable: true
                  default: false
    BlockchainActionResponse:
      properties:
        id:
          type: number
          description: Assigned id. Can be used to submit signature or check status later
          example: 12882
        status:
          type: string
          description: Blockchain Action Status
          enum:
            - Draft
            - InProgress
            - Completed
            - Failed
        domain:
          $ref: '#/components/schemas/Domain'
        txs:
          type: array
          items:
            properties:
              id:
                $ref: '#/components/schemas/TransactionId'
              blockchain:
                $ref: '#/components/schemas/Blockchain'
              status:
                type: string
                description: Blockchain Action Transaction Status
                enum:
                  - Draft
                  - Pending
                  - Completed
                  - Failed
              signatureStatus:
                type: string
                description: |
                  A state of transactions signature
                  * NotRequired - the server doesn't require the client to sign this transaction
                  * Signed - the client has already signed a transaction
                  * Required - the server is awaiting for the client to sign a transaction
                  * WillBeRequired - the server is awaiting for certain operation to be complete. The signature status is expected to go into Required status afterwards, so the client has to wait for signature submission to be ready.
                enum:
                  - NotRequired
                  - Signed
                  - Required
                  - WillBeRequired
                example: Required
            anyOf:
              - description: |
                  `Regular` transaction type. Formed by UD backend, signed by the user wallet and sent to blockchain by user wallet.
                properties:
                  type:
                    type: string
                    enum: [Regular]
                  to:
                    type: string
                    nullable: true
                    description: Contract address to send the transaction to (only for Regular type)
                    example: "0x801452cFAC27e79a11c6b185986fdE09e8637589"
                  data:
                    type: string
                    nullable: true
                    description: Encoded transaction body to be sent (only for Regular type)
                    example: "0xb88d4fde00000000000000000000000087348226e747df4cff2b1b1e38a528df405ccd5c000000000000000000000000070e83fced225184e67c86302493fffcdb953f7153b27892177c7f5b476966a119b206227e8155dc86269f932655df96e76d8803000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000001"
              - description: |
                  `Meta` transaction type. The user receives `messageToSign` that is expected to be signed using EIP-712.
                externalDocs:
                  description: EIP-712
                  url: https://eips.ethereum.org/EIPS/eip-712#specification
                properties:
                  type:
                    type: string
                    enum: [Meta]
                  messageToSign:
                    type: string
                    nullable: true
                    description: Message that needs to be signed (only for Meta type).
                    example: "0xd08e50a6c19462a60cf783f72deb80212708a9a45841db9fe2e49e3647f997cb"
              - description: |
                  `System` and `Internal` transaction types do not expect any action from the user.
                  They are signed by 3rd party and are displayed to the user for information and tracking purposes.

                  * `System` - transactions originated to Polygon Proof of Stake bridge, signed and sent by Polygon miners
                  * `Internal` - transacitons that do not require any special permission to be executed, made and signed by Unstoppable Domains
                properties:
                  type:
                    type: string
                    enum: [System, Internal]
        paymentInfo:
          type: 'object'
          nullable: true
          description: Stripe Intent to be paid for transaction
          properties:
            id:
              type: 'string'
              description: 'Stripe Intent Id'
              example: '3882828'
            stripeSecret:
              type: string
              description: Stripe Intent Secret
            totalAmount:
              type: number
              example: 424
              description: Total Amount to be paid in USD
    BlockchainActionSignRequest:
      type: array
      items:
        properties:
          id:
            $ref: '#/components/schemas/TransactionId'
        anyOf:
          - description: "`Regular` transaction type required attributes"
            properties:
              type:
                type: string
                enum: ["Regular"]
              txHash:
                $ref: '#/components/schemas/TransactionHash'
          - description: "`Meta` transaction type required attributes"
            properties:
              type:
                type: string
                enum: ["Meta"]
              signature:
                type: string
                description: Transaction Signature (only for Meta type)
                example: "0x3883828428482472472847284724728472847284728472847247287"
          - description: "`Zilliqa` transaction type required attributes"
            properties:
              type:
                type: string
                enum: ["Zilliqa"]
                example: Zilliqa
              txParams:
                # TODO clarify zilliqa transaction parameters
                type: object
                description: Transaction Paramters (only for Zilliqa type)
  securitySchemes:
    ApiSecret:
      type: http
      scheme: bearer
      bearerFormat: JWT
    HttpBasic:
      type: http
      scheme: basic