[ RFC Index | RFC Search | Usenet FAQs | Web FAQs | Documents | Cities ]
Alternate Formats: rfc3867.txt | rfc3867.txt.pdf
RFC 3867 - Payment Application Programmers Interface (API) for v1.0 Internet Open Trading Protocol (IOTP)
|
 |
RFC3867 - Payment Application Programmers Interface (API) for v
Network Working Group Y. Kawatsura
Request for Comments: 3867 Hitachi
Category: Informational M. Hiroya
Technoinfo Service
H. Beykirch
Atos Origin
November 2004
Payment Application Programmers Interface (API) for v1.0
Internet Open Trading Protocol (IOTP)
Status of this Memo
This memo provides information for the Internet community. It does
not specify an Internet standard of any kind. Distribution of this
memo is unlimited.
Copyright Notice
Copyright (C) The Internet Society (2004).
Abstract
The Internet Open Trading Protocol (IOTP) provides a data exchange
format for trading purposes while integrating existing pure payment
protocols seamlessly. This motivates the multiple layered system
architecture which consists of at least some generic IOTP application
core and multiple specific payment modules.
This document addresses a common interface between the IOTP
application core and the payment modules, enabling the
interoperability between these kinds of modules. Furthermore, such
an interface provides the foundations for a plug-in-mechanism in
actual implementations of IOTP application cores.
Such interfaces exist at the Consumers', the Merchants' and the
Payment Handlers' installations connecting the IOTP application core
and the payment software components/legacy systems.
Table of Contents
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1. General payment phases . . . . . . . . . . . . . . . . . 5
1.2. Assumptions. . . . . . . . . . . . . . . . . . . . . . . 6
2. Message Flow . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.1. Authentication Documentation Exchange. . . . . . . . . . 15
2.2. Brand Compilation. . . . . . . . . . . . . . . . . . . . 17
2.3. Brand Selection. . . . . . . . . . . . . . . . . . . . . 21
2.4. Successful Payment . . . . . . . . . . . . . . . . . . . 24
2.5. Payment Inquiry. . . . . . . . . . . . . . . . . . . . . 29
2.6. Abnormal Transaction Processing. . . . . . . . . . . . . 30
2.6.1. Failures and Cancellations . . . . . . . . . . . 30
2.6.2. Resumption . . . . . . . . . . . . . . . . . . . 32
2.7. IOTP Wallet Initialization . . . . . . . . . . . . . . . 33
2.8. Payment Software Management. . . . . . . . . . . . . . . 34
3. Mutuality. . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.1. Error Codes. . . . . . . . . . . . . . . . . . . . . . . 38
3.2. Attributes and Elements. . . . . . . . . . . . . . . . . 48
3.3. Process States . . . . . . . . . . . . . . . . . . . . . 61
3.3.1. Merchant . . . . . . . . . . . . . . . . . . . . 61
3.3.2. Consumer . . . . . . . . . . . . . . . . . . . . 63
3.3.3. Payment Handler. . . . . . . . . . . . . . . . . 65
4. Payment API Calls. . . . . . . . . . . . . . . . . . . . . . . 66
4.1. Brand Compilation Related API Calls. . . . . . . . . . . 66
4.1.1. Find Accepted Payment Brand. . . . . . . . . . . 66
4.1.2. Find Accepted Payment Protocol . . . . . . . . . 68
4.1.3. Get Payment Initialization Data. . . . . . . . . 70
4.1.4. Inquire Authentication Challenge . . . . . . . . 72
4.1.5. Authenticate . . . . . . . . . . . . . . . . . . 73
4.1.6. Check Authentication Response. . . . . . . . . . 74
4.2. Brand Selection Related API Calls. . . . . . . . . . . . 76
4.2.1. Find Payment Instrument. . . . . . . . . . . . . 76
4.2.2. Check Payment Possibility. . . . . . . . . . . . 78
4.3. Payment Transaction Related API calls. . . . . . . . . . 80
4.3.1. Start Payment Consumer . . . . . . . . . . . . . 80
4.3.2. Start Payment Payment Handler. . . . . . . . . . 82
4.3.3. Resume Payment Consumer. . . . . . . . . . . . . 84
4.3.4. Resume Payment Payment Handler . . . . . . . . . 85
4.3.5. Continue Process . . . . . . . . . . . . . . . . 86
4.3.6. Change Process State . . . . . . . . . . . . . . 88
4.4. General Inquiry API Calls. . . . . . . . . . . . . . . . 89
4.4.1. Remove Payment Log . . . . . . . . . . . . . . . 90
4.4.2. Payment Instrument Inquiry . . . . . . . . . . . 90
4.4.3. Inquire Pending Payment. . . . . . . . . . . . . 92
4.5. Payment Related Inquiry API Calls. . . . . . . . . . . . 93
4.5.1. Check Payment Receipt. . . . . . . . . . . . . . 93
4.5.2. Expand Payment Receipt . . . . . . . . . . . . . 94
4.5.3. Inquire Process State. . . . . . . . . . . . . . 96
4.5.4. Start Payment Inquiry. . . . . . . . . . . . . . 97
4.5.5. Inquire Payment Status . . . . . . . . . . . . . 98
4.6. Other API Calls. . . . . . . . . . . . . . . . . . . . . 99
4.6.1. Manage Payment Software. . . . . . . . . . . . . 99
5. Call Back Function . . . . . . . . . . . . . . . . . . . . . .101
6. Security Considerations. . . . . . . . . . . . . . . . . . . .103
7. References . . . . . . . . . . . . . . . . . . . . . . . . . .103
7.1. Normative References . . . . . . . . . . . . . . . . . .103
7.2. Informative References . . . . . . . . . . . . . . . . .104
Acknowledgement. . . . . . . . . . . . . . . . . . . . . . . . . .105
Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . . .105
Full Copyright Statement . . . . . . . . . . . . . . . . . . . . .106
1. Introduction
Common network technologies are based on standardized and established
Internet technologies. The Internet technologies provide mechanisms
and tools for presentation, application development, network
infrastructure, security, and basic data exchange.
Due to the presence of already installed trading roles' systems with
their own interfaces (Internet shop, order management, payment,
billing, and delivery management systems, or financial institute's
legacy systems), IOTP has been limited to the common external
interface over the Internet. However, some of these internal
interfaces might be also standardized for better integration of IOTP
aware components with of the existing infrastructure and its cost
effective reuse. For more information on IOTP, see [IOTP] and
[IOTPBOOK].
The typical Payment Handlers (i.e., financial institutes or near-bank
organizations) as well as Merchants require an IOTP aware application
that easily fits into their existing financial infrastructure. The
Payment Handler might even insist on the reuse of special in-house
solutions for some subtasks of the IOTP aware application, e.g.,
reflecting their cryptography modules, gateway interfaces, or
physical environment. Therefore, their IOTP aware implementation
really requires such clear internal interfaces.
More important, consumers demand modularization and clear internal
interfaces: Their IOTP application aims at the support of multiple
payment methods. Consumers prefer the flexible use of different
seamless integrating payment methods within one trading application
with nearly identical behavior and user interface. The existence of
a well-defined interface enables payment software developers to bolt
on their components to other developer's general IOTP Application
Core.
Initially, this consideration leads to the two-level layered view of
the IOTP software for each role, consisting of:
o some generic IOTP system component, the so-called IOTP application
core - providing IOTP based gateway services and generic business
logic and
o the trading roles' specific back-end systems implementing the
specific trading transaction types' functionality.
In order to isolate the changes on the infrastructure, the IOTP
trading application has been three-layered:
o the IOTP Application Core processes the generic parts of the IOTP
transaction and holds the connection to the Internet,
o the Existing Legacy System or Existing Payment Software which
processes the actual transaction type, and particular payment
transaction, and
o the IOTP Middle-ware or IOTP Payment Bridge which glues the other
two possibly incompatible components. It brokers between the
specific interface of the Existing Legacy System and the
standardized interfaces of the IOTP Application Core.
As IOTP extends payment schemes to a trading scheme, primarily, this
document focuses on payment modules, i.e., the interface between the
IOTP Payment Bridge and the IOTP Application Core. It provides a
standard method for exchanging payment protocol messages between the
parties involved in a payment. But, it does not specify any
interface for order or delivery processing.
Such a Payment Application Programmers Interface (API) must suit for
a broad range of payment methods: (1) software based like Credit Card
SET or CyberCoin, (2) chip card based like Mondex or GeldKarte, and
(3) mimicries of typical and traditional payment methods like money
transfer, direct debit, deposit, withdrawal, money exchange and value
points. It should support both payments with explicit consumer
acknowledge and automatic repeated payments, which have been consumer
approved in advance. For more information on SET, see [SET].
The following discussion focuses on the Consumer's point of view and
uses the associated terminology. When switching to Merchants' or
Delivery Handlers' IOTP aware applications, the payment related
components should be implicitly renamed by Existing Legacy Systems to
the IOTP Middle-ware.
The next two sub-sections describe the general payment scenario and
several assumptions about the coarsely sketched software components.
Section 2 illustrates the payment transaction progress and message
flow of different kinds of transaction behavior. Sections 3 to 4
provide the details of the API functions and Section 5 elaborates the
call back interface.
1.1. General payment phases
The following table sketches the four logical steps of many payment
schemes. The preceding agreements about the goods, payment method,
purchase amount, or delivery rules are omitted.
Payment State Party Example Behavior
------------- ----- ----------------
Mutual Payment Handler Generation of identification
Authentication request, solvency request, or
and some nonce
Initialization Consumer Responses to the requests and
generation of own nonce
Authorization Payment Handler Generation of the authorization
request (for consumer)
Consumer Agreement to payment (by
reservation of the Consumer's
e-money)
Payment Handler Acceptance or rejection of the
agreement (consumer's
authorization response),
generation of the authorization
request (for issuer/acquirer),
and processing of its response
Capture Generation of the capture
request (for issuer/acquirer)
Consumer Is charged
Payment Handler Acceptance or rejection of the
e-money, close of the payment
transaction
Reversal On rejection (online/delayed):
generation of the reversal data
Consumer Receipt of the refund
However, some payment schemes:
o limit themselves to one-sided authentication,
o perform off-line authorization without any referral to any
issuer/acquirer,
o apply capture processing in batch mode, or
o do not distinguish between authorization and capture,
o lack an inbound mechanism for reversals or implement a limited
variant.
This model applies not only to payments at the typical points of
sales but extends to refunds, deposits, withdrawals, electronic
cheques, direct debits, and money transfers.
1.2. Assumptions
In outline, the IOTP Payment Bridge processes some input sequence of
payment protocol messages being forwarded by the IOTP Application
Core. It (1) disassembles the messages, (2) maps them onto the
formats of the Existing Payment Software, (3) assembles its
responses, and (4) returns another sequence of payment protocol
messages that is mostly intended for transparent transmission by the
IOTP Application Core to some IOTP aware remote party. Normally,
this process continues between the two parties until the Payment
Handler's Payment API signals the payment termination.
Exceptionally, each system component may signal failures.
The relationship between the aforementioned components is illustrated
in the following figure. These components might be related to each
other in a flexible n-to-m-manner:
o One IOTP Application Core may manage multiple IOTP Payment Bridges
and the latter might be shared between multiple IOTP Application
Cores.
o Each Payment Bridge may manage multiple Existing Payment Software
modules and the latter might be shared between multiple Payment
Bridges.
o Each Existing Payment Software may manage multiple payment schemes
(e.g., SET) and the latter might be supported by multiple Existing
Payment Software modules. For more information on SET see [SET].
o Each payment scheme may support multiple payment instruments
(e.g., particular card) or methods (e.g., Visa via SET) and the
latter might be shared by multiple Existing Payment Software
Components.
*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
IOTP client (consumer) <---------------> IOTP server (merchant)
( contains Internet ( contains
IOTP Application Core) IOTP Application Core)
^ ^
| IOTP Payment | IOTP Payment
| API | API
v v
IOTP Payment Bridge IOTP Payment Bridge
^ ^
| Existing Payment APIs, e.g., |
| SET, Mondex, etc. |
v v
Existing Payment Software Existing Payment Software
*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
Figure 1: Relationship of the Components
The Payment API considers the following transaction types of Baseline
IOTP:
o Baseline Purchase,
o Baseline Refund,
o Baseline Value Exchange,
o Baseline Withdrawal, and
o Baseline (Payment) Inquiry.
For more information on Baseline IOTP, see [IOTP] and [IOTPBOOK].
First, the authors' vision of the IOTP aware application's and its
main components' capabilities are clarified: On the one hand, the
Payment API should be quite powerful and flexible for sufficient
connection of the generic and specific components. On the other
hand, the Payment API should not be overloaded with nice-to-haves
being unsupported by Existing Payment Software.
Despite the strong similarities on the processing of successful
payments, failure resolution and inquiry capabilities differ
extremely among different payment schemes. These aspects may even
vary between different payment instrument using the same payment
schemes. Additionally, the specific requirements of Consumers,
Merchants and Payment Handlers add variance and complexity.
Therefore, it is envisioned that the IOTP Application Core provides
only very basic inquiry mechanisms while complex and payment scheme
specific inquiries, failure analysis, and failure resolution are
fully deferred to the actual Existing Payment Software - including
the user interface.
The IOTP Application Core processes payments transparently, i.e., it
forwards the wrapped payment scheme specific messages to the
associated IOTP Payment Bridge/Existing Payment Software. The
Existing Payment Software might even use these messages for inbound
failure resolution. It reports only the final payment status to the
IOTP Application Core or some intermediate - might be also final -
status on abnormal interruption.
The IOTP Application Core implements the generic and payment scheme
independent part of the IOTP transaction processing and provides the
suitable user interface. Focusing on payment related tasks, it
o manages the registered IOTP Payment Bridges and provides a
mechanism for their registration - the latter is omitted by this
document.
o assumes that any IOTP Payment Bridge is a passive component, i.e.,
it strictly awaits input data and generates one response to each
request,
o supports the payment negotiation (Consumer: selection of the
actual payment instrument or method; Merchant: selection of the
payment methods being offered to the Consumer) preceding the
payment request,
o requests additional payment specific support from the Existing
Payment Software via the selected and registered the IOTP Payment
Bridge,
o initializes and terminates the Existing Payment Software via the
IOTP Payment Bridge,
o inquires authentication data (for subsequent request or response)
from the Existing Payment Software, specific authentication
component - omitted in this document - or Consumer (by a suitable
user interface),
o supervises the online transaction process and traces its progress,
o stores the transaction data being exchanged over the IOTP wire -
payment scheme specific data is handled transparently,
o relates each payment transaction with multiple payment parameters
(IOTP Transaction Identifier, Trading Protocol Options, Payment
Instrument/Method, Offer Response, IOTP Payment Bridge, and Wallet
Identifier, associated remote Parties). The relation might be
lowered to the party's Payment Identifier, IOTP Payment Bridge,
Wallet Identifier, and the remote parties when the actual payment
transaction has been successfully started.
o implements a payment transaction progress indicator,
o enables the inquiry of pending and completed payment transactions,
o implements generic dialogs, e.g., brand selection, payment
acknowledge, payment suspension / cancellation, receipt
visualization, basic transaction inquiry, balance inquiry, or
receipt validation,
o defers payment specific processing, supervision, validation, and
error resolution to the Existing Payment Software. It is
expected, that the Existing Payment Software will try to resolve
many errors first by the extended exchange of Payment Exchange
messages. The most significant and visible failures arise from
sudden unavailability or lapses of the local or opposing payment
component.
o supports the invocation of any Existing Payment Software in an
interactive mode, which might be used (1) for the payment scheme
specific post-processing of a (set of) payment transactions, (2)
for the analysis of a payment instrument, (3) for the registration
of a new payment instrument/scheme, or (4) re-configuration of a
payment instrument/scheme.
o exports call back functions for use by the IOTP Payment Bridge or
Existing Payment Software for progress indication.
In addition, the IOTP Application Core
o manages the IOTP message components and IOTP message blocks
exchanged during the transaction which may be referenced and
accessed during the processing of subsequent messages, e.g., for
signature verification. In particular, it stores named Packaged
Content elements exchanged during payments.
o manages several kinds of identifiers, i.e., transaction, message,
component, and block identifiers,
o implements a message caching mechanism,
o detects time-outs at the protocol and API level reflecting the
communication with both the IOTP aware remote party and the
Payment API aware local periphery, e.g., chip card (reader) may
raise time-outs.
However, the IOTP Payment Bridge and Existing Payment Software do not
have to rely on all of these IOTP Application Core's capabilities.
E.g., some Consumer's Existing Payment Software may refuse the
disclosure of specific payment instruments at brand selection time
and may delay this selection to the "Check Payment Possibility"
invocation using its own user interface.
The IOTP Payment Bridge's capabilities do not only deal with actual
payments between the Consumer and the Payment Handler but extend to
the following:
o translation and (dis)assemblage of messages between the formats of
the IOTP Payment API and those of the Existing Payment Software.
Payment API requests and response are strictly 1-to-1 related.
o Consumer's payment instrument selection by the means of an
unsecured/public export of the relationship of payment brands,
payment protocols, and payment instruments (identifiers).
Generally, this includes not just the brand (Mondex, GeldKarte,
etc.) but also which specific instance of the instrument and
currency to use (e.g., which specific Mondex card and which
currency of all those available).
However, some Existing Payment Software may defer the selection of
the payment instrument to the actual payment carrying-out or it may
even lack any management of payment instruments. E.g., chip card
based payment methods may offer - Point of Sale like - implicit
selection of the payment instrument by simple insertion of the chip
card into the chip card reader or it interrogates the inserted card
and requests an acknowledge (or selection) of the detected payment
instrument(s).
o payment progress checks, e.g., is there enough funds available to
carry out the purchase, or enough funds left for the refund,
o IOTP Payment Receipt checks which might be performed over its
Packaged Content or by other means.
o recoding of payment scheme specific receipts into a format which
can be displayed to the user or printed,
o cancellation of payment, even though it is not complete,
o suspension and resumption of payment transactions. Two kinds of
failures the Existing Payment Software might deal with are (1) the
time-out of the network connection and (2) lack of funds. For
resolution, the IOTP Application Core may try the suspension with
a view to later possible resumption.
o recording the payment progress and status on a database. E.g.,
information about pending payments might be used to assist their
continuation when the next payment protocol message is received.
o payment transaction status inquiry, so that the inquirer - IOTP
Application Core or User - can determine the appropriate next
step.
o balance inquiry or transaction history, e.g., consumers may
interrogate their chip card based payment instrument or remotely
administer some account in advance of a payment transaction
acknowledge,
o inquiry on abnormal interrupted payment transactions, which might
be used by the IOTP Application Core to resolve these pending
transactions at startup (after power failure).
o payment progress indication. This could be used to inform the end
user of details on what is happening with the payment.
o payment method specific authentication methods.
Existing Payment Software may not provide full support of these
capabilities. E.g., some payment schemes may not support or may even
prevent the explicit transaction cancellation at arbitrary phases of
the payment process. In this case, the IOTP Payment Bridge has to
implement at least skeletons that signal such lack of support by the
use of specific error codes (see below).
The Existing Payment Software's capabilities vary extremely. It
o supports payment scheme specific processing, supervision,
validation, and error resolution. It is expected, that many
errors are tried to be resolved first by the extended exchange of
Payment Exchange messages.
o provides hints for out-of-band failure resolution on failed
inbound resolution - inbound resolution is invisible to the IOTP
Application Core.
o may implement arbitrary transaction data management and inquiry
mechanisms ranging from no transaction recording, last transaction
recording, chip card deferred transaction recording, simple
transaction history to sophisticated persistent data management
with flexible user inquiry capabilities. The latter is required
by Payment Handlers for easy and cost effective failure
resolution.
o implements the payment scheme specific dialog boxes.
Even the generic dialog boxes of the IOTP Application Core might be
unsuitable: Particular (business or scheme) rules may require some
dedicated appearance / structure / content or the dialog boxes, may
prohibit the unsecured export of payment instruments, or may
prescribe the pass phrase input under its own control.
2. Message Flow
The following lists all functions of the IOTP Payment API:
o Brand Compilation Related API Functions
"Find Accepted Payment Brand" identifies the accepted payment brands
for any indicated currency amount.
"Find Accepted Payment Protocol" identifies the accepted payment
protocols for any indicated currency amount (and brand) and returns
payment scheme specific packaged content for brand selection
purposes.
This function might be used in conjunction with the aforementioned
function or called without any brand identifier.
"Get Payment Initialization Data" returns additional payment scheme
specific packaged content for payment processing by the payment
handler.
"Inquire Authentication Challenge" returns the payment scheme
specific authentication challenge value.
"Check Authentication Response" verifies the returned payment scheme
specific authentication response value.
"Change Process State" is used (here only) for abnormal termination.
(cf. Payment Processing Related API Functions).
o Brand Selection Related API Functions
"Find Payment Instrument" identifies which instances of a payment
instrument of a particular payment brand are available for use in a
payment.
"Check Payment Possibility" checks whether a specific payment
instrument is able to perform a payment.
"Authenticate" forwards any payment scheme specific authentication
data to the IOTP Payment Bridge for processing.
"Change Process State" is used (here only) for abnormal termination.
(cf. Payment Processing Related API Functions).
o Payment Processing Related API Functions
"Start or Resume Payment Consumer/Payment Handler" initiate or resume
a payment transaction. There exist specific API functions for the
two trading roles Consumer and Payment Handler.
"Continue Process" forwards payment scheme specific data to the
Existing Payment Software and returns more payment scheme specific
data for transmission to the counter party.
"Change Process State" changes the current status of payment
transactions. Typically, this call is used for termination or
suspension without success.
o General Inquiry API Functions
"Remove Payment Log" notifies the IOTP Payment Bridge that a
particular entry has been removed from the Payment Log of the IOTP
Application Core.
"Payment Instrument Inquiry" retrieves the properties of Payment
Instruments.
"Inquire Pending Payment" reports any abnormal interrupted payment
transaction known by the IOTP Payment Bridge.
Payment Processing Related Inquiry API Functions
"Check Payment Receipt" checks the consistency and validity of IOTP
Payment Receipts, received from the Payment Handler or returned by
"Inquire Process State" API calls. Typically, this function is
called by the Consumer during the final processing of payment
transactions. Nevertheless, this check might be advantageous both
for Consumers and Payment Handlers on failure resolution.
"Expand Payment Receipt" expands the Packaged Content of IOTP Payment
Receipts as well as payment scheme specific payment receipts into a
form which can be used for display or printing purposes.
"Inquire Process State" responds with the payment state and the IOTP
Payment Receipt Component. Normally, this function is called by the
Payment Handler for final processing of the payment transaction.
"Start Payment Inquiry" prepares the remote inquiry of the payment
transaction status and responds with payment scheme specific data
that might be needed by the Payment Handler for the Consumer
initiated inquiry processing.
"Inquire Payment Status" is called by the Payment Handler on Consumer
initiated inquiry requests. This function returns the payment scheme
specific content of the Inquiry Response Block.
"Continue Process" and "Change Process State" (cf. Payment Processing
Related API Calls)
o Other API Functions
"Manage Payment Software" enables the immediate activation of the
Existing Payment Software. Further user input is under control of
the Existing Payment Software.
"Call Back" provides a general interface for the visualization of
transaction progress by the IOTP Application Core.
The following table shows which API functions must (+), should (#),
or might (?) be implemented by which Trading Roles.
API function Consumer Payment Handler Merchant
------------ -------- --------------- --------
Find Accepted Payment Brand +
Find Accepted Payment Protocol #
Find Payment Instrument +
Get Payment Initialization Data +
Check Payment Possibility +
Start Payment Consumer +
Start Payment Payment Handler +
Resume Payment Consumer #
Resume Payment Payment Handler #
Continue Process + +
Inquire Process State + + ?
Change Process State + + ?
Check Payment Receipt + ?
Expand Payment Receipt # ?
Remove Payment Log ? ? ?
Inquire Authentication Challenge ?
Authenticate +
Check Authentication Response ?
Payment Instrument Inquiry ?
Inquire Pending Payment # #
Start Payment Inquiry ?
Inquire Payment Status ?
Manage Payment Software # ? ?
Call Back #
Table 1: Requirements on API Functions by the Trading Roles
The next sections sketch the relationships and the dependencies
between the API functions. They provide the informal description of
the progress alternatives and depict the communication and
synchronization between the general IOTP Application Core and the
payment scheme specific modules.
2.1. Authentication Documentation Exchange
This section describes how the functions in this document are used
together to process authentication.
*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
Authenticator Inquire Authentication Challenge(Alg1*) -> IPB
Inq. Auth. Challenge Response(Alg1,Ch1) <- IPB
. . .
Inquire Authentication Challenge(Algn*) -> IPB
Inq. Auth. Challenge Response(Algn,Chn) <- IPB
Create and transmit Authentication Request Block
Authenticatee Authenticate(Alg1, Ch1) -> IPB
AuthenticateResponse(...) <- IPB
. . .
Authenticate(Algm, Chm) -> IPB
AuthenticateResponse(Res) <- IPB
Create and transmit Authentication Response Block
Authenticator Check Authentication Response(Algm,Chm,Res)->IPB
Check Auth. Response() <-IPB
Create and transmit Authentication Status Block
*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
Figure 2. Authentication Message Flows
1. (Authenticator Process) None, one or multiple IOTP Payment Bridges
(IPB) are requested for one or multiple authentication challenge
values ("Inquire Authentication Challenge"). Each value is
encapsulated in an IOTP Authentication Request Component. In
addition, the IOTP Application Core may add payment scheme
independent authentication methods. All of them form the final
IOTP Authentication Request Block, which describes the set of
authentication methods being supported by the authenticator and
from which the Authenticatee has to choose one method.
Note that the interface of the API function is limited to the
response of exactly one algorithm per call. If the IOTP
Application Core provides a choice of algorithms for input, this
choice should be reduced successively by the returned algorithm
({Alg(i+1)*} is subset of {Algi*}).
During the registration of new Payment Instruments, the IOTP
Payment Bridge notifies the IOTP Application Core about the
supported authentication algorithms.
2. On the presence of an IOTP Authentication Block within the
received IOTP message, the Authenticatee's IOTP Application Core
checks whether the IOTP transaction type in the current phase
actually supports the authentication process.
For each provided Authentication Request Component, the IOTP
Application Core analyzes the algorithms' names, the transaction
context, and optionally user preferences in order to determine the
system components which are capable to process the authentication
request items. Such system components might be the IOTP
Application Core itself or any of the registered IOTP Payment
Bridges.
Subsequently, the IOTP Application Core requests the responses to
the supplied challenges from the determined system components in
any order. The authentication trials stop with the first
successful response, which is included in the IOTP Authentication
Response Block.
Alternatively, the IOTP Application might ask for a user
selection. This might be appropriate, if two or more
authentication algorithms are received that require explicit user
interaction, like PIN or chip card insertion.
The Authenticatee's organizational data is requested by an IOTP
Authentication Request Block without any content element. On
failure, the authentication (sequence) might be retried, or the
whole transaction might be suspended or cancelled.
3. (Authenticator Process) The IOTP Application Core checks the
presence of the IOTP Authentication Response Component in the
Authentication Response Block and forwards its content to the
generator of the associated authentication challenge for
verification ("Check Authentication Response").
On sole organizational data request, its presence is checked.
Any verification must succeed in order to proceed with the
transaction.
2.2. Brand Compilation
The following shows how the API functions are used together so that
the Merchant can (1) compile the Brand List Component, (2) generate
the Payment Component, and (3) adjust the Order Component with
payment scheme specific packaged content.
*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
Merchant For each registered IOTP Payment Bridge
| Find Accepted Payment Brand() -> IPB
| Find Accepted Payment Brand Response (B*) <- IPB
| Find Accepted Payment Protocol(B1) -> IPB
| Find Accepted Payment Protocol Res.(P1*) <- IPB
| . . .
| Find Accepted Payment Protocol(Bn) -> IPB
| Find Accepted Payment Protocol Res.(Pn*) <- IPB
Create one Brand List Component, ideally sharing
common Brand, Protocol Amount, Currency Amount,
and Pay Protocol Elements
Create Trading Protocol Options Block
On brand independent transactions
| Create Brand Selection Component, implicitly
| Get Payment Initialization Data(B1,P1) -> IPB
| Get Payment Initialization Data Res.() <- IPB
| Optionally
| | Inquire Process State() -> IPB
| | Inquire Process State Response(State) <- IPB
| Create Offer Response Block
Transmit newly created Block(s)
Consumer Consumer selects Brand (Bi)/Currency/Protocol (Pj)
from those that will work and generates Brand
Selection Component - at least logically
On brand dependent transaction
| Transmit Brand Selection Component
Merchant On brand dependent transaction
| Get Payment Initialization Data(Bi,Pj) -> IPB
| Get Payment Initialization Data Res.() <- IPB
| Optionally
| | Inquire Process State() -> IPB
| | Inquire Process State Response(State) <- IPB
| Create Offer Response Block
| Transmit newly created Block
*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
Figure 3. Brand Compilation Message Flows
1. The Merchant's commerce server controls the shopping dialog with
its own mechanisms until the Consumer checks out the shopping
cart and indicates the payment intention. The notion shopping
subsumes any non-IOTP based visit of the Merchant Trading Role's
(which subsumes Financial Institutes) web site in order to
negotiate the content of the IOTP Order Component. The
subsequent processing switches to the IOTP based form by the
activation of the Merchant's IOTP aware application.
2. The IOTP Application Core inquires for the IOTP level trading
parameters (Consumer's shopping identifier, payment direction,
initial currency amounts, discount rates, Merchant's and Delivery
Handler's Net Locations, Non-Payment Handler's Organizational
Data, initial order information, ....).
3. The registered IOTP Payment Bridges are inquired by the IOTP
Application Core about the accepted payment brands ("Find
Accepted Payment Brand"). Their responses provide most of the
attribute values for the compilation of the Brand List
Component's Brand Elements. The IOTP Application Core might
optionally match the returned payment brands with Merchant's
general preferences.
The IOTP Application Core must provide any wallet identifiers, if
they are required by the IOTP Payment Bridges which signal their
need by specific error codes (see below). Any signaled error
that could not be immediately solved by the IOTP Application Core
should be logged - this applies also to the subsequent API calls
of this section. In this case, the IOTP Application Core creates
an IOTP Error Block (hard error), transmits it to the Consumer,
and terminates the current transaction.
4. The IOTP Application Core interrogates the IOTP Payment Bridges
for each accepted payment brand about the supported payment
protocols ("Find Accepted Payment Protocol"). These responses
provide the remaining attribute values of the Brand Elements as
well as all attribute values for the compilation of the Brand
List Component's Protocol Amount and Pay Protocol Elements.
Furthermore, the organisational data about the Payment Handler is
returned. The IOTP Application Core might optionally match the
returned payment brands with Merchant's general preferences.
Alternatively, the IOTP Application Core might skip the calls of
"Find Accepted Payment Brands" (cf. Step 3) and issue the "Find
Accepted Payment Protocol" call without any Brand given on the
input parameter list. In this case, the IOTP Payment Bridge
responds to the latter call with the whole set of payment schemes
supported w.r.t. the other input parameters.
5. The steps 3 and 4 are repeated during IOTP Value Exchange
transactions - these steps are omitted in the previous figure.
6. The IOTP Application Core compiles the Brand List Component(s)
and the IOTP Trading Protocol Options Block. It is recommended
that the "equal" items returned by IOTP Payment Bridge function
calls are shared due to the extensive linking capabilities within
the Brand List Component. However, the compilation must consider
several aspects in order to prevent conflicts - sharing detection
might be textual matching (after normalization):
o Packaged Content Elements contained in the Brand List Component
(and subsequently generated Payment and Order Components) might
be payment scheme specific and might depend on each other.
o Currently, IOTP lacks precise rules for the content of the
Packaged Content Element. Therefore, transaction / brand /
protocol / currency amount (in)dependent data might share the
same Packaged Content Element or might spread across multiple
Packaged Content Elements.
o The Consumer's IOTP Application Core transparently passes the
Packaged Content Elements to the IOTP Payment Bridges which
might not be able to handle payment scheme data of other
payment schemes, accurately.
The rules and mechanisms of how this could be accomplished are
out of the scope of this document. Furthermore, this document
does not define any further restriction to the IOTP
specification.
7. The IOTP Application Core determines whether the IOTP message can
be enriched with an Offer Response Block. This is valid under
the following conditions:
o All payment alternatives share the attribute values and
Packaged Content Elements of the subsequently generated IOTP
Payment and Order Components.
o The subsequently generated data does not depend on any IOTP
BrandSelInfo Elements that might be reported by the consumer
within the TPO Selection Block in the brand dependent variant.
If both conditions are fulfilled, the IOTP Application Core might
request the remaining payment scheme specific payment
initialization data from the IOTP Payment Bridge ("Get Payment
Initialization Data") and compile the IOTP Offer Response Block.
Optionally, the IOTP Application Core might request the current
process state from the IOTP Payment Bridge and add the inferred
order status to the IOTP Offer Response Block. Alternatively,
IOTP Application might determine the order status on its own.
As in step 6, the rules and mechanisms of how this could be
accomplished are out of the scope of this document.
8. The IOTP Application Core compiles the IOTP TPO Message including
all compiled IOTP Blocks and transmits the message to the
Consumer. The IOTP Application Core terminates if an IOTP Offer
Response Block has been created.
9. The Consumer performs the Brand Selection Steps (cf. Section 2.3)
and responds with a TPO Selection Block if no IOTP Offer Response
Block has been received. Otherwise, the following step is
skipped.
10. On brand dependent transactions, the IOTP Application Core
requests the remaining payment scheme specific payment
initialization data from the IOTP Payment Bridge ("Get Payment
Initialization Data"), compiles the IOTP Offer Response Block,
transmits it to the Consumer, and terminates. Like Step 7, the
IOTP Application Core might access the current process state of
the IOTP Payment Bridge for the compilation of the order status.
Any error during this process raises an IOTP Error Block.
2.3. Brand Selection
This section describes the steps that happen mainly after the
Merchant's Brand Compilation (in a brand independent transaction).
However, these steps might partially interlace the previous process
(in a brand dependent transaction).
*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
Merchant Merchant generates Brand List(s) containing
Brands, Payment Protocols and Currency Amounts
On brand independent transactions
| Merchant generates Offer Response Block
Consumer Compile set(s) of Brands B/Protocols P
for each set
| Find Payment Instrument(B, P, C) -> IPB
| Find Payment Instrument Response (PI*) <- IPB
Consumer selects Brand/Currency/Payment Instrument
from those that will work and generates Brand
Selection Component
For the Selection
| Get Payment Initialization Data(B,C,PI,P) -> IPB
| Get Payment Initialization Data Response()<- IPB
On brand dependent transaction
| Generate and transmit TPO Selection Block
Merchant On brand dependent transaction
| Merchant checks Brand Selection and generates
| and transmits Offer Response Block
*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
Figure 4. Brand Selection Message Flows
1. The Merchant's commerce server controls the shopping dialog with
its own mechanisms until the Consumer checks out the shopping cart
and indicates his payment intention. The subsequent processing
switches to the IOTP based form by the activation of the
Merchant's IOTP aware application.
2. The IOTP Application Core compiles the IOTP Trading Protocol
Options Block which contains the IOTP Brand List Component(s)
enumerating Merchant's accepted payment brands and payment
protocols and initiates the Brand Selection process.
3. This first IOTP message activates the Consumer's IOTP aware
application, e.g., the Web browser invokes a helper application
(e.g., Java applet or external application). Its IOTP Application
Core
o infers the accepted payment brands, payment protocols, payment
direction, currencies, payment amounts, any descriptions etc.,
and their relationships from the IOTP message,
o determines the registered IOTP Payment Bridges,
o compiles one or multiple sets of brand and protocol such that
the join of all sets describes exactly the payment alternatives
being offered by the Merchant.
o inquires payment (protocol) support and the known payment
instruments from each registered IOTP Payment Bridge for each
compiled set ("Find Payment Instrument"). However, some IOTP
Payment Bridges may refuse payment instrument distinction.
The payment protocol support may differ between payment
instruments if the IOTP Payment Bridge supports payment instrument
distinction.
These API calls are used to infer the payment alternatives at the
startup of any payment transaction (without user unfriendly
explicit user interaction).
The IOTP Application Core must provide wallet identifiers, if they
are requested by the IOTP Payment Bridges which signal their need
by specific error codes (see below).
It is recommended that the IOTP Application Core manages wallet
identifiers. But for security reasons, it should store pass
phrases in plain text only in runtime memory. Developers of IOTP
Payment Bridges and payment software modules should provide a thin
and fast implementation - without lengthy initialization processes
- for this initial inquiry step.
4. The IOTP Application Core verifies the Consumer's payment
capabilities with the Merchant's accepted payment brands and
currencies,
o displays the valid payment instruments and payment instrument
independent payment brands (brand and protocol) together with
their purchase parameters (payment direction, currency,
amount), and
o requests the Consumer's choice or derives it automatically from
any configured preferences. Any selection ties one IOTP
Payment Bridge with the following payment transaction.
The handling and resolution of unavailable IOTP Payment Bridges
during the inquiry in Step 3 is up to the IOTP Application Core.
It may skip these IOTP Payment Bridges or may allow user supported
resolution.
Furthermore, it may offer the registration of new payment
instruments when the Consumer is asked for payment instrument
selection.
5. The IOTP Application Core interrogates the fixed IOTP Payment
Bridge whether the payment might complete with success ("Check
Payment Possibility"). At this step, the IOTP Payment Bridge may
issue several signals, e.g.,
o payment can proceed immediately,
o required peripheral inclusive of some required physical payment
instrument (chip card) is unavailable,
o (non-IOTP) remote party (e.g., issuer, server wallet) is not
available,
o wallet identifier or pass phrase is required,
o expired payment instrument (or certificate), insufficient
funds, or
o physical payment instrument unreadable.
In any erroneous case, the user should be notified and offered
accurate alternatives. Most probably, the user might be offered
o to resolve the problem, e.g., to insert another payment
instrument or to verify the periphery,
o to proceed (assuming its success),
o to cancel the whole transaction, or
o to suspend the transaction, e.g., initiating a nested
transaction for uploading an electronic purse.
If the payment software implements payment instrument selection on
its own, it may request the Consumer's choice at this step.
If the check succeeds, it returns several IOTP Brand Selection
Info Elements.
6. The Steps 2 to 5 are repeated and possibly interlaced for the
selection of the second payment instrument during IOTP Value
Exchange transactions - this is omitted in the figure above.
7. The IOTP Brand Selection Component is generated and enriched with
the Brand Selection Info elements. This component is transmitted
to the Merchant inside a TPO Selection Block if the received IOTP
message lacks the IOTP Offer Response Block. The Merchant will
then respond with an IOTP Offer Response Block (following the
aforementioned compilation rules).
2.4. Successful Payment
An example of how the functions in this document are used together to
effect a successful payment is illustrated in the Figure 5. In the
figure 5, PS0, PS1, ..., and PSn indicate the nth PayScheme Packaged
Content data, and [ ] indicates optional.
(Technically, two payments happen during IOTP Value Exchange
transactions.)
*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
Consumer Start Payment Consumer(Amount,[PS0]...) -> IPB
Start Payment Cons. Res.([PS1], CS=Cont.) <- IPB
Create and transmit Payment Request Block
Payment Handler Start Payment Pay. Handler(Amount, [PS1]) -> IPB
Start Payment PH Response(PS2, CS=Cont.) <- IPB
Create and transmit Payment Exchange Block
Consumer Continue Process(PS2) -> IPB
Continue Process Response(PS3, CS=Cont.) <- IPB
... CONTINUE SWAPPING PAYMENT EXCHANGES UNTIL ...
Payment Handler Continue Process Response([PSn], CS=End) <- IPB
Request any local payment receipt
| Inquire Process State() -> IPB
| Inquire Proc. State Resp.(State, [Rcp.])<- IPB
Create and transmit Payment Response Block
Terminate transaction, actively
| Change Process State(State) -> IPB
| Change PS Response(State=CompletedOK) <- IPB
Consumer On receipt of final payment scheme data
| Continue Process(PSn) -> IPB
| Continue Process Response(CS=End) <- IPB
Check Payment Receipt(Receipt) -> IPB
Check Payment Receipt Response() <- IPB
Request any local payment receipt
| Inquire Process State() -> IPB
| Inquire Proc. State Resp.(State, [Rcp.])<- IPB
Terminate transaction, actively
| Change Process State(State) -> IPB
| Change PS Response(State=CompletedOk) <- IPB
*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
Figure 5. Example Payment Message Flows
1. After Brand Selection and receipt of the IOTP Offer Response
Block, the Consumer switches from communicating with the Merchant
to communicating with the Payment Handler.
This might be a milestone requiring the renewed Consumer's
agreement about the payment transaction's continuation.
Particularly, this is a good moment for payment suspension (and
even cancellation), which will be most probably supported by all
payment schemes. Simply, because the actual payment legacy
systems have not yet been involved in the current transaction.
Such an agreement might be explicit per transaction or automatic
based on configured preferences, e.g., early acknowledgments for
specific payment limits.
It is assumed, that the transaction proceeds with minimal user
(Consumer and Payment Handler) interaction and that its progress
is controlled by the IOTP Application Core and IOTP Payment
Bridge.
2. In order to open the actual payment transaction, the IOTP
Application Core issues the "Start Payment Consumer" request
towards the IOTP Payment Bridge. This request carries the whole
initialization data of the payment transaction being referred to
by the IOTP Payment Bridge for subsequent consistency checks:
o payment brand and its description from the selected Brand
Element of the IOTP Brand List Component,
o payment instrument from preceding inquiry step,
o further payment parameters (currency, amount, direction,
expiration) from the selected Currency Amount element, Brand
List Component, and Payment Component of the IOTP Offer
Response Block,
o payment protocol from the selected IOTP Pay Protocol Element,
o order details contained in the IOTP Order Component which might
be payment scheme specific,
o payment scheme specific data inclusive of the payment protocol
descriptions from the IOTP Protocol Amount Element, and IOTP
Pay Protocol Element, and
o payment scheme specific data inclusive of the payment protocol
descriptions, in which the name attribute includes the prefix
as "Payment:" from the Trading Role Data Component.
Generally, the called API function re-does most checks of the
"Check Payment Possibility" call due to lack of strong
dependencies between both requests: There might be a significant
delay between both API requests.
The called API function may return further payment scheme specific
data being considered as payment specific initialization data for
the Payment Handler's IOTP Payment Bridge.
If the fixed Existing Payment Software implements payment
instrument selection on its own, it may request the Consumer's
choice at this step.
The IOTP Payment Bridge reports lack of capability quite similarly
to the "Check Payment Possibility" request to the IOTP Application
Core. The Consumer may decide to resolve the problem, to suspend,
or to cancel the transaction, but this function call must succeed
in order to proceed with the transaction.
Developers of payment modules may decide to omit payment
instrument related checks like expiration date or refunds
sufficiency, if such checks are part of the specific payment
protocol.
If the IOTP Payment Bridge requests wallet identifiers or pass
phrases anywhere during the payment process, they should be
requested by this API function, too. It is recommended that the
IOTP Application Core stores plain text pass phrases only in
runtime memory.
Finally, the IOTP Application Core generates the IOTP Payment
Request Block, inserts any returned payment scheme data, and
submits it to the Payment Handler's system.
3. The Payment Handler's IOTP Application Core opens the payment
transaction calling the "Start Payment Payment Handler" API
function. The payment brand, its description, payment protocol,
payment specific data, payment direction, currency and payment
amount are determined quite similar to the Consumer's IOTP
Application Core. Furthermore, the content of the IOTP Payment
Scheme Component and the IOTP Brand Selection Info Elements are
passed to this function.
On success, the Payment Handler's IOTP Payment Bridge responds
with payment scheme specific data. On failures, this non-
interactive server application has to resolve any problems on its
own or to give up aborting the payment transaction. However, the
Consumer may restart the whole payment transaction. Anyway, the
payment log file should reflect any trials of payments.
Eventually, the Payment Handler informs the Consumer about the
current IOTP Process State using the IOTP Payment Response or IOTP
Error Block.
Note that the "Start Payment Payment Handler" call might return
the Continuation Status "End" such that payment processing
proceeds with Step 7.
4. The IOTP Application Core verifies the presence of the Payment
Exchange Block in the IOTP message and passes the contained
payment scheme specific data to the fixed IOTP Payment Bridge
("Continue Process") which returns the next IOTP Payment Scheme
Component.
This Payment Scheme Component is encapsulated in an IOTP Payment
Exchange Block and transmitted to the Payment Handler.
5. The Payment Handler's IOTP Application Core verifies the presence
of the Payment Exchange Block and passes the contained payment
scheme specific data to the fixed IOTP Payment Bridge ("Continue
Process") which returns the next IOTP Payment Scheme Component for
encapsulation and transmission to the Consumer.
6. The payment process continues with IOTP Payment Exchange Block
exchanges, carrying the payment scheme specific data. Each party
(1) submits the embedded payment scheme specific data
transparently to the appropriate IOTP Payment Bridge calling the
"Continue Process" API function, (2) wraps the returned payment
scheme specific data into an IOTP Payment Exchange Block, and (3)
transmits this block to the counter party.
However, the processing of the payment scheme specific data may
fail for several reasons. These are signaled by specific error
codes which are transformed to IOTP Payment Response Blocks
(generated by Payment Handler) or IOTP Error Blocks (both parties
may generate them) and transmitted to the counter party.
7. Eventually, the Payment Handler's IOTP Payment Bridge recognizes
the termination of the payment transaction and reports this by the
continuation status "End" on the output parameter of "Continue
Process" (or "Start Payment Payment Handler"). Then, the IOTP
Application Core issues the "Inquire Process State" API call and
verifies whether an IOTP Payment Receipt Component has been
returned. The IOTP Application Core wraps the payment receipt,
the status response, and the optional payment scheme specific data
in an IOTP Payment Response Block and transmits this block to the
Consumer.
However, any of these API calls may fail or any response might be
incomplete (e.g., lack of payment receipt). Then, the Consumer
has to be notified about the failed processing by an IOTP Error
Block.
Finally, the Payment Handler terminates the payment transaction
with the "Change Process State" API call without awaiting any
further response from the Consumer. Further failures are not
reported to the Consumer.
Note that it might be possible that the Consumer's IOTP Payment
Bridge has returned the previous payment scheme specific data with
the continuation status "End". Even in the absence of this
knowledge - this status is not exchanged between the Consumer and
the Payment Handler - the Payment Handler must not supply any
further payment scheme specific data. Such data will be rejected
by the Consumer's IOTP Payment Bridge.
8. The Consumer passes the optional payment scheme specific data and
the payment receipt to the fixed IOTP Payment Bridge by "Continue
Process" and "Check Payment Receipt" API calls.
Afterwards, the IOTP Application Core issues the "Inquire Process
State" API call and verifies whether extensions to the payment
receipt have been returned.
Finally, the transaction is terminated by calling the "Change
Process State" API function which verifies and synchronizes the
reported payment status with the local one and signals any
inconsistencies. Any Inconsistency and returned status text
should be displayed to the Consumer.
At this point, the payment transaction has already been closed by
the Payment Handler. Therefore, any failure has to be resolved
locally or out-of-band.
2.5. Payment Inquiry
In Baseline IOTP, Payment inquiries are initiated by the Consumer in
order to verify the current payment progress and process state at the
remote Payment Handler. In the figure 6, PS1 and PS2 indicate the
first and second PayScheme Packaged Content data, and [ ] indicates
optional.
*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
Consumer Start Payment Inquiry() -> IPB
Start Payment Inquiry Response([PS1]) <- IPB
Create and transmit Inquiry Request Trading Block
Payment Handler Inquire Payment Status([PS1]) -> IPB
Inquire Payment Status Res.(State, [PS2]) -> IPB
Create and transmit Inquiry Response Trading
Block
Consumer If Payment Scheme Data present
| Continue Process(PS2) -> IPB
| Continue Process Response(CS=End) <- IPB
Change Process State(State) -> IPB
Change Process State Response(State) <- IPB
*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
Figure 6. Remote Process State Inquiry
1. The Consumer might initiate a payment inquiry once the payment
transaction has been opened by the IOTP Application Core, i.e., at
any time after the initial submission of the IOTP Payment Request
Block. The IOTP Application Core requests any additional specific
payment scheme data from the IOTP Payment Bridge which has been
fixed during brand selection (cf. Section 2.3) using the "Start
Payment Inquiry" API request.
Erroneous API responses should be reported to the Consumer and
valid alternatives (typically retry and cancellation) should be
presented by the IOTP Application Core.
This request might perform the complete initialization, e.g.,
availability check of periphery or pass phrase supplement, and the
IOTP Payment Bridge reports lack of capability quite similarly to
the "Check Payment Possibility" request to the IOTP Application
Core.
If the IOTP Payment Bridge requests wallet identifiers or pass
phrases anywhere during the payment process, they should be
requested by this API function, too. It is recommended that the
IOTP Application Core store plain text pass phrases only in
runtime memory.
The IOTP Application Core encapsulates any Payment Scheme
Component in an IOTP Inquiry Request Block and submits the block
to the Payment Handler.
2. The Payment Handler analyses the IOTP Inquire Request Block, maps
the Transaction Identifier to payment related attributes (brand,
consumer and payment identifiers), determines the appropriate IOTP
Payment Bridge, and forwards the request to the this IOTP Payment
Bridge ("Inquire Payment Status"). The IOTP Application Core
transforms the response to an IOTP Inquiry Response Block and
transmits it to the Consumer.
3. On receipt of the respective IOTP Inquiry Response Block the
Consumer's IOTP Application Core submits any encapsulated payment
scheme specific data to the IOTP Payment Bridge for verification
("Continue Process").
4. The IOTP Application Core passes the reported payment status
(except textual descriptions) to the IOTP Payment Bridge ("Change
Process State") for verification purposes and payment status
change. The IOTP Payment Bridge reports any inconsistencies as
well as the final payment status to the IOTP Application Core.
Any additional information that might be of interest to the
Consumer has to be displayed by the IOTP Payment Bridge or
Existing Payment Software on their own.
2.6. Abnormal Transaction Processing
2.6.1. Failures and Cancellations
The IOTP specification distinguishes between several classes of
failures:
o Business and technical errors
o Error depths of transport, message and block level
o Transient errors, warnings, and hard errors.
Any IOTP Payment API has to deal with the receipt of failure
notifications by and failure responses. This proposal has borrowed
the basic mechanisms for error reporting between the IOTP Application
Core and the IOTP Payment Bridge from the actual protocol: Business
errors are reported by Status Components within IOTP Response Blocks
while technical errors are signaled by Error Components within IOTP
Error Blocks.
Cancellations are mimicked as specific business errors which might be
initiated by each trading party.
Preferring slim interfaces, this IOTP Payment API introduces one
additional Error Code value for business error indication - errors
can be raised on every API call. On receipt of this value, the IOTP
Application Core has to infer further details by the issuance of the
API function call "Inquire Process State".
*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
Any Party Issue some API request -> IPB
Error Response(Error Code) <- IPB
On "Business Error" response
| Inquire Process State() -> IPB
| Inquire P.S. Resp.(State, Receipt) <- IPB
Analyze local process state and try to resolve
with optional user interaction
If Process State Change needed
| Change Process State (State) -> IPB
| Change Process State Response(State) <- IPB
If counter party's notification required
| Create Error or Cancel Block (, add to next
| message, ) and transmit it to counter party
*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
Figure 7. Error Response from IPB
The specific Completion Codes "ConsCancelled", "MerchCancelled", and
"PaymCancelled" - returned by "Inquire Process State" - determine
that the IOTP Cancel Block has to be created instead of an IOTP Error
Block.
The rules for determining the required behavior of the IOTP
Application Core are given in the IOTP specification.
Note that any payment (intermediate) termination, i.e., failures,
cancellations, and even successes are always reported to the IOTP
Payment Bridge by the API function "Change Process State". This API
function does both status changes and consistency checking /
synchronization. Any suspicion of inconsistency should be reported
by the IOTP Payment Bridge for display by the IOTP Application Core.
*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
Any Party Error Block or Cancel Block Received
If Change Process State required
| Change Process State (State) -> IPB
| Change Process State Response(State) <- IPB
*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*+*
Figure 8. Error Notification from counter party
Not every failure might be visible at the IOTP layer, e.g., the
processing of payment transactions might temporarily be hampered by
intermediate failures at the payment scheme or protocol transport
layer which might be resolved by the actual components.
However, final failures or cancellations have to be reported at the
IOTP layer. E.g., communication time-outs and heavily faulty
communication channels may disable the transaction.
Any system component may implement time-out recognition and use the
aforementioned API mechanisms for the notification of process state
changes. But, time-outs may happens while communicating with both
the counter party and local system components, like chip card readers
or IOTP Payment Bridges. Anyway, the Consumer's IOTP Application
Core should notify the Consumer about the resolution alternatives,
i.e., retry, suspension, and cancellation.
2.6.2. Resumption
Payment transaction resumption may apply at different steps of a
payment transaction:
o The Consumer's and Payment Handler's view of the transaction might
not be synchronized: Due to different time-out values the payment
transaction may not have been suspended by the counter party.
Any "Resume Payment ..." API function responds with an Error Code
on non-suspended payment transaction that signals a business
error. Afterwards the IOTP Application Core has to issue the
"Inquire Process State" API call for further analysis of the
process state.
o One IOTP message sent by one party might not be processed
successfully or even received by the counter party. This needs to
be handled by the actual payment scheme. It is expected that the
IOTP Application Core will not recognize anything.
o IOTP does not provide any specific signal for payment resumption.
On receipt of every IOTP Payment Exchange Block, the IOTP
Application Core has to decide whether this Block belongs to a
pending transaction or to a suspended transaction that should be
resumed. The IOTP Application Core might call the "Inquire
Process State" API function to update any lack of knowledge.
Any "Resume Payment" API function responds with an Error Code on
non-suspended payment transaction that signals a business error.
Similar, the "Continue Process" API function should report
business errors on non-pending payment transactions.
o The payment transaction may not have been created at the Payment
Handler (early suspension and failed data transmission). In that
case, the IOTP Application Core should respond with a business
error that signals the repetition of the payment transaction (by
the Consumer).
Any "Resume Payment", "Continue Process" or "Inquire Process
State" API function should return with an Error Code
"AttValIllegal" on non-existent payment transaction whereby the
further Error Attribute "Names" denote the payment identifier.
o The IOTP Application Core should always request fresh payment
scheme specific data on resumption - for synchronization purposes
with the Existing Payment Software. Old data in the cache that
has not been sent to the counter party should not be accessed.
If the Consumer does not reconnect within an acceptable amount of
time, the Payment Handler's system may perform local failure
resolution in order to close the transaction and to retain resources
for other transactions ("Change Process State"). If the Consumer
reconnect afterwards, an IOTP Payment Response or IOTP Error Block
could be generated.
2.7. IOTP Wallet Initialization
At startup or on explicit user request the IOTP Application Core
should check its IOTP Payment Bridges' internal status by searching
for pending payment transactions.
1. The IOTP Application Core interrogates the registered IOTP Payment
Bridges about pending payment transactions. The IOTP Application
Core may store indicators for pending transactions and use them
for driving any subsequent inquiry ("Inquire Pending Payment").
2. If one or more IOTP Payment Bridges report the presence of pending
transactions, the IOTP Application Core may try to suspend
("Change Process State") or resume (only Consumer: "Resume Payment
Consumer") the pending transactions (on user request).
The IOTP Payment Bridge may deny the processing of any new payment
transactions until the pending transactions have been processed.
Such denials are signaled by the error code "Business Error".
2.8. Payment Software Management
The IOTP Application Core provides only a simple and generic
interface for the registration of new payment methods / instruments
("Manage Payment Software"). It receives the initial user request
and defers the actual registration to the corresponding IOTP Payment
Bridge.
The IOTP Application Core may also activate the Existing Payment
Software for further payment instrument and wallet administration.
3. Mutuality
The Payment API is formalized using the eXtensible Markup Language
(XML). It defines wrapper elements for both the input parameters and
the API function's response. In particular, the response wrapper
provides common locations for Error Codes and Error Descriptions.
It is anticipated that this description reflects the logical
structure of the API parameter and might be used to derive
implementation language specific API definitions.
XML definition:
<!ELEMENT IotpPaymentApiRequest (
FindAcceptedPaymentBrand |
FindAcceptedPaymentProtocol |
GetPaymentInitializationData |
FindPaymentInstrument |
CheckPaymentPossiblity |
StartPaymentConsumer |
StartPaymentPaymentHandler |
ResumePaymentConsumer |
ResumePaymentPaymentHandler |
ContinueProcess |
InquireProcessState |
ChangeProcessState |
InquireAuthChallenge |
Authenticate |
CheckAuthResponse |
CheckPaymentReceipt |
ExpandPaymentReceipt |
RemovePaymentLog |
PaymentInstrumentInquiry |
InquirePendingPayment |
ManagePaymentSoftware |
StartPaymentInquiry |
InquirePaymentStatus |
CallBack )>
<!ATTLIST IotpPaymentApi
xml:lang NMTOKEN #IMPLIED
ContentSoftwareID CDATA #IMPLIED
xmlns CDATA #FIXED
"http://www.iotp.org/2000/08/PaymentAPI" >
<!ELEMENT IotpPaymentApiResponse (ErrorResponse?, (
FindAcceptedPaymentBrandResponse |
FindAcceptedPaymentProtocolResponse |
GetPaymentInitializationDataResponse |
FindPaymentInstrumentResponse |
CheckPaymentPossiblityResponse |
StartPaymentConsumerResponse |
StartPaymentPaymentHandlerResponse |
ResumePaymentConsumerResponse |
ResumePaymentPaymentHandlerResponse |
ContinueProcessResponse |
InquireProcessStateResponse |
ChangeProcessStateResponse |
InquireAuthChallengeResponse |
AuthenticateResponse |
CheckAuthResponseResponse |
CheckPaymentReceiptResponse |
ExpandPaymentReceiptResponse |
RemovePaymentLogResponse |
PaymentInstrumentInquiryResponse |
InquirePendingPaymentResponse |
ManagePaymentSoftwareResponse |
StartPaymentInquiryResponse |
InquirePaymentStatusResponse |
CallBackResponse )?)>
<!ATTLIST IotpPaymentApiResponse
xml:lang NMTOKEN #IMPLIED
ContentSoftwareID CDATA #IMPLIED
xmlns CDATA #FIXED
"http://www.iotp.org/2000/08/PaymentAPI" >
<!ELEMENT ErrorResponse (ErrorLocation+,PaySchemePackagedContent*) >
<!ATTLIST ErrorResponse
xml:lang NMTOKEN #IMPLIED
ErrorCode NMTOKEN #REQUIRED
ErrorDesc CDATA #REQUIRED
Severity(Warning |
TransientError |
HardError) #REQUIRED
MinRetrySecs CDATA #IMPLIED
SwVendorErrorRef CDATA #IMPLIED >
Most of the attribute items are intended for immediate insertion in
the IOTP Error Block. The attribute values of the Error Location
elements attribute have to enriched and transformed into Error
Location Elements of the Error Component (cf. IOTP Specification).
Attributes (cf. IOTP Specification):
xml:lang Defines the language used by attributes or
child elements within this component, unless
overridden by an xml:lang attribute on a child
element.
ContentSoftwareId Contains information which identifies the
software that generated the content of the
element. Its purpose is to help resolve
interoperability problems that might occur as
a result of incompatibilities between messages
produced by different software. It is a single
text string in the language defined by
"xml:lang". It must contain, as a minimum
problems that might occur as a result of
o the name of the software manufacturer,
o the name of the software,
o the version of the software, and
o the build of the software.
ErrorCode Contains an error code which indicates the
nature of the error in the message in error.
Valid values for the Error Code are given in
the following section. This mnemonic enables
the automatic failure resolution of the IOTP
Application Core which analyzes the error code
value in order to determine the continuation
alternatives.
ErrorDesc Contains a description of the error in the
language defined by xml:lang. The content of
this attribute is defined by the
vendor/developer of the software that
generated the Error Response Element.
It is intended for user display and provides
detailed explanations about the failure and
its (out-of-band) resolution alternatives.
Severity Indicates the severity of the error. Valid
values are:
o Warning. This indicates that although there
is a message in error the IOTP Transaction
can still continue.
o TransientError. This indicates that the
error in the message in error may be
recovered if the message in error that is
referred to by the "Names" attribute is
resent.
o HardError. This indicates that there is an
unrecoverable error in the message in error
and the IOTP Transaction must stop.
MinRetrySecs This attribute should be present if "Severity"
is set to "TransientError". It is the minimum
number of whole seconds which the IOTP aware
application which received the message
reporting the error should wait before
resending the message in error identified by
the "ErrorLocation" attribute.
If Severity is not set to
"TransientError" then the value of this
attribute is ignored.
SwVendorErrorRef This attribute is a reference whose value is
set by the vendor/developer of the software
that generated the Error Element. It should
contain data that enables the vendor to
identify the precise location in their
software and the set of circumstances that
caused the software to generate a message
reporting the error.
Content:
ErrorLocation This identifies, where possible, the
element and attribute in the message
in error that caused the Error
Element to be generated. If the
"Severity" of the error is not
"TransientError", more that one
"ErrorLocation" may be specified as
appropriate depending on the nature
of the error and at the discretion of
the vendor/developer of the IOTP
Payment Bridge.
Its definition coincides with the
IOTP specification whereby the
attributes "IotpMsgRef", "BlkRef" and
"CompRef" are left blank,
intentionally.
PaySchemePackagedContent cf. Table 5
3.1. Error Codes
The following table lists the valid values for the ErrorCode
attribute of the Error Response Element. The first sentence of the
error description contains the default text that can be used to
describe the error when displayed or otherwise reported. Individual
implementations may translate this into alternative languages at
their discretion. However, not every error code may apply to every
API call. An Error Code must not be more than 14 characters long.
The Error Codes have been taken from the IOTP Specification and
extended by some additional codes which are highlighted by a
preceding asterisk.
Generally, if the corrupt values have been user supplied, the IOTP
Application Core might prompt for their correction. If the renewal
fails or if the IOTP Application Core skips any renewals and some
notification has to be send to the counter-party, the error code is
encapsulated within an IOTP Error Block.
However, the IOTP server application reports business errors -
visible at the IOTP layer - in the Status Component of the respective
Response Block.
The IOTP Application Core may add the attributes (and values) within
the ErrorLocation elements that are omitted by the IOTP Payment
Bridge.
The following table mentions any modification from this general
processing for particular error values. Furthermore, it contains
hints for developers of IOTP Application Core software components
about the processing of error codes. Conversely, developers of IOTP
Payment Bridges get impressions about the expected behavior of the
IOTP Application Core.
The IOTP Payment API assumes that the IOTP Application Core
implements the dialog boxes needed for error resolution. But it does
not assume, that the IOTP Payment Bridge actually relies on them.
Instead, the IOTP Payment Bridge may try resolution on its own, may
implement specific dialog boxes, and may signal only final failures.
Note: This abstract document assumes that the API parameters are
exchanged XML encoded. Therefore, several error values might
disappear in lower level language specific derivations.
Error Value Error Description
----------- -----------------
Reserved Reserved. This error is reserved by the
vendor/developer of the software. Contact
the vendor/developer of the software for
more information (see the SoftwareId
attribute of the Message Id element in the
Transaction Reference Block [IOTP]).
XmlNotWellFrmd XML not well formed. The XML document is not
well formed. See [XML] for the meaning of
"well formed".
XmlNotValid XML not valid. The XML document is well
formed but the document is not valid. See
[XML] for the meaning of "valid".
Specifically:
o the XML document does not comply with the
constraints defined in the IOTP document
type declaration, and
o the XML document does not comply with the
constraints defined in the document type
declaration of any additional [XML-NS]
that are declared.
The Names attribute might refer some
attributes and elements of the input
parameter list.
(*)ElNotValid Element not valid. Invalid element in terms
of prescribed syntactical characteristics.
The ElementRef attributes of ErrorLocation
elements might refer to the corresponding
elements (if they have ID attributes).
The IOTP Application Core has to replace the
error code with "XmlNotValid" before
transmission to the counterparty.
ElUnexpected Unexpected element. Although the XML
document is well formed and valid, an
element is present that is not expected in
the particular context according to the
rules and constraints contained in this
specification.
The ElementRef attributes of ErrorLocation
elements might refer to the corresponding
elements (if they have ID attributes).
ElNotSupp Element not supported. Although the document
is well formed and valid, an element is
present that
o is consistent with the rules and
constraints contained in this
specification, but
o is not supported by the IOTP Aware
Application which is processing the IOTP
Message.
The ElementRef attributes of ErrorLocation
elements might refer to the corresponding
elements (if they have ID attributes).
ElMissing Element missing. Although the document is
well formed and valid, an element is missing
that should have been present if the rules
and constraints contained in this
specification are followed.
The ElementRef attributes of ErrorLocation
elements might refer to the corresponding
elements (if they have ID attributes).
ElContIllegal Element content illegal. Although the
document is well formed and valid, the
element contains values which do not conform
the rules and constraints contained in this
specification.
The ElementRef attributes of ErrorLocation
elements might refer to the corresponding
element (if they have ID attributes).
The IOTP Application Core has to replace the
Error Code with "ElNotSupp" before
transmission to the counter party, if the
ErrorLocation elements refer to
non-PackagedContent element.
EncapProtErr Encapsulated protocol error. Although the
document is well formed and valid, the
Packaged Content of an element contains data
from an encapsulated protocol which contains
errors.
The ElementRef attributes of ErrorLocation
elements might refer to the corresponding
element (if they have ID attributes).
AttUnexpected Unexpected attribute. Although the XML
document is well formed and valid, the
presence of the attribute is not expected in
the particular context according to the
rules and constraints contained in this
specification.
The AttName attributes of ErrorLocation
elements might refer to the corresponding
attribute tags.
(*)AttNotValid Attribute not valid. Invalid attribute value
in terms of prescribed syntactical
characteristics.
The AttName attributes of ErrorLocation
elements might refer to the corresponding
attribute tags.
The IOTP Application Core has to replace the
error code with "XmlNotValid" before
transmission to the counter party.
AttNotSupp Attribute not supported. Although the XML
document is well formed and valid, and the
presence of the attribute in an element is
consistent with the rules and constraints
contained in this specification, it is not
supported by the IOTP Aware Application
which is processing the IOTP Message.
AttMissing Attribute missing. Although the document is
well formed and valid, an attribute is
missing that should have been present if the
rules and constraints contained in this
specification are followed.
The AttName attributes of ErrorLocation
elements might refer to the corresponding
attribute tags.
If the attribute is required by the IOTP
Document Type Declaration (#REQUIRED) the
hints for non-valid attributes should be
adopted, otherwise these for illegal
attribute values.
AttValIllegal Attribute value illegal. The attribute
contains a value which does not conform to
the rules and constraints contained in this
specification.
The AttName attributes of ErrorLocation
elements might refer to the corresponding
attribute tags - valid values are:
BrandId: illegal/unknown Brand Identifier -
If the brand is not recognized/known by any
IOTP Payment Bridge, the IOTP Application
Core may offer the registration of a new
Payment Instrument.
PaymentInstrumentId: illegal/unknown
Payment Instrument Identifier - This
indicates a serious communication problem if
the attribute value has been reported by the
same "wallet" on a previous inquiry
requests. The IOTP Application Core has to
replace the error code with
"UnknownError" before transmission to the
counter party.
WalletId: illegal/unknown Wallet Identifier
- It is assumed that the wallet identifier
is checked before the pass phrase. On
invalid wallet identifiers, the IOTP
Application Core may open the dialog in
order to request the correct wallet
identifier. In addition, any pass phrase may
be supplied by the user. The dialog should
indicate the respective payment brand(s).
The IOTP Application Core has to replace the
error code with "UnknownError" before
transmission to the counter party.
Passphrase: illegal/unknown Pass Phrase -
The IOTP Application Core may open the
dialog in order to request the correct pass
phrase. If the pass phrase is wallet
identifier specific the dialog should
display the wallet identifier. The IOTP
Application Core has to replace the error
code with "TransportError" before
transmission to the counter party.
Action: illegal / unknown / unsupported
Action
PropertyTypeList: lists contains illegal /
unknown / unsupported Property Types - The
IOTP Application Core tries only the local
resolution but does never transmit any IOTP
Error Block to the counter party.
CurrCode: illegal/unknown/unsupported
Currency Code
CurrCodeType: illegal/unknown/unsupported
Currency Code Type
Amount: illegal/unknown/unsupported Payment
Amount
PayDirection: illegal/unknown/unsupported
Payment Direction
ProtocolId: illegal/unknown/unsupported
Protocol Identifier
OkFrom: illegal/unknown/unsupported OkFrom
Timestamp
OkTo: illegal/unknown/unsupported OkTo
Timestamp
ConsumerPayId: illegal/unknown Consumer
Payment Identifier
PaymentHandlerPayId: illegal/unknown Payment
Handler Payment Identifier
PayId: illegal/unknown Payment Identifier
AttValNotRecog Attribute Value Not Recognized. The
attribute contains a value which the IOTP
Aware Application generating the message
reporting the error could not recognize.
The AttName attributes of ErrorLocation
elements might refer to the corresponding
attribute tags.
MsgTooLarge Message too large. The message is too large
to be processed by the IOTP Payment Bridge
(or IOTP Application Core).
ElTooLarge Element too large. The element is too large
to be processed by the IOTP Payment Bridge
(or IOTP Application Core).
The ElementRef attributes of ErrorLocation
elements might refer to the corresponding
elements.
ValueTooSmall Value too small or early. The value of all
or part of an element content or an
attribute, although valid, is too small.
The ErrorLocation elements might refer to
the corresponding attribute tags or
elements.
ValueTooLarge Value too large or in the future. The value
of all or part of an element content or an
attribute, although valid, is too large.
The ErrorLocation elements might refer to
the corresponding attribute tags or
elements.
ElInconsistent Element Inconsistent. Although the document
is well formed and valid, according to the
rules and constraints contained in this
specification:
o the content of an element is inconsistent
with the content of other elements or
their attributes, or
o the value of an attribute is inconsistent
with the value of one or more other
attributes.
The Error Description may contain further
explanations.
The ErrorLocation elements might refer to
the corresponding attribute tags or elements
that are inconsistent.
TransportError Transport Error. This error code is used to
indicate that there is a problem with the
transport mechanism that is preventing the
message from being received. It is typically
associated with a "Transient Error".
The connection to some periphery or the
counter party could not be established,
is erroneous, or has been lost.
The Error Description may contain further
narrative explanations, e.g., "chip card
does not respond", "remote account manager
unreachable", "Internet connection to xyz
lost", "no Internet connection available",
"no modem connected", or "serial port to
modem used by another application". This
text should be shown to the end user. If
timeout has occurred at the Consumer this
text should be shown and the Consumer may
decide how to proceed - alternatives are
retry, payment transaction suspension, and
cancellation.
MsgBeingProc Message Being Processed. This error code is
only used with a Severity of Transient
Error. It indicates that the previous
message, which may be an exchange message or
a request message, is being processed and,
if no response is received by the time
indicated by the "MinRetrySecs" attribute,
then the original message should be resent.
SystemBusy System Busy. This error code is only used
with a Severity of Transient Error. It
indicates that the IOTP Payment Bridge or
Existing Payment Software that received the
API request is currently too busy to handle
it. If no response is received by the time
indicated by the "MinRetrySecs" attribute,
then the original message should be resent.
The Error Description may provide further
explanations, e.g., "wallet / chip card
reader is unavailable or locked by another
payment transaction", "payment gateway is
overloaded", "unknown chip card reader", or
"unrecognized chip card inserted, change
chip card".
The Consumer's IOTP Application Core may
display the error description and ask the
Consumer about the continuation -
alternatives are retry, payment transaction
suspension, and cancellation.
UnknownError Unknown Error. Indicates that the
transaction cannot complete for some reason
that is not covered explicitly by any of the
other errors. The Error description
attribute should be used to indicate the
nature of the problem.
The ErrorLocation elements might refer to
the corresponding attribute tags or elements
that are inconsistent.
(*)SyntaxError Syntax Error. An (unknown) syntax error has
occurred.
The ErrorLocation elements might refer to
the corresponding attribute tags or elements
that are inconsistent.
The IOTP Application Core has to replace the
error code with "XmlNotValid" or
"UnknownError" before transmission to the
counter party.
(*)ReqRefused Request refused. The API request is
(currently) refused by the IOTP Payment
Bridge. The error description may provide
further explanations, e.g., "wallet / chip
card reader is unavailable or locked by
another payment transaction", "payment
gateway is overloaded", "unknown chip card
reader", or "unrecognized chip card
inserted, change chip card".
The Consumer's IOTP Application Core may
display the error description and ask the
Consumer about the continuation -
alternatives are retry, payment transaction
suspension, and cancellation. Denials due to
invalid Process States should be signaled by
"BusinessError". Typically, this kind of
error is not passed to the counter party's
IOTP Application Core. Otherwise, it maps to
"TransportError" or "UnknownError".
(*)ReqNotSupp Request not supported. The API
function(ality) has not been implemented in
the IOTP Payment Bridge. Typically, this
kind of error is not passed to the
counter party's IOTP Application Core.
Otherwise, it maps to "TransportError" or
"UnknownError".
(*)BusError Business Error. The API request has been
rejected because some payment transaction
has an illegal payment status.
Particularly, this error code is used to
signal any raise of payment business layered
failures.
The ErrorLocation elements may refer to
payment transactions using the party's
Payment Identifier - it defaults to the
current transaction or might contain the
current payment transaction party's Payment
Identifier - identified by the ElementRef
attribute while the AttName attribute is
fixed with "PayId".
The IOTP Application Core must inquire the
IOTP Payment Bridge about the actual Process
State which actually encodes the business
error ("Inquire Process State").
This error code must not be
passed to the counter party's IOTP
Application Core.
Table 2: Common Error Codes
The IOTP Payment Bridge may also use the error description in order
to notify the Consumer about further necessary steps for failure
resolution, e.g., "Sorry, your payment transaction failed.
Unfortunately, you have been charged, please contact your issuer."
3.2. Attributes and Elements
The following table explains the XML attributes in alphabetical order
- any parenthesized number after the attribute tag is a recommended
maximal length of the attribute value in characters:
Attribute Description
--------- -----------
Amount (11) Indicates the payment amount to be paid in
AmountFrom(11) whole and fractional units of the currency.
AmountTo (11) For example $245.35 would be expressed
"245.35". Note that values smaller than the
smallest denomination are allowed. For
example one tenth of a cent would be
"0.001".
AuthenticationId An identifier specified by the
authenticator which, if returned by the
organization that receives the
authentication request, will enable the
authenticator to identify which
authentication is being referred to.
BrandId (128) This contains a unique identifier for the
brand (or promotional brand). It is used to
match against a list of Payment Instruments
which the Consumer holds to determine
whether or not the Consumer can pay with the
Brand.
Values of BrandId are managed under
procedure being described in the IOTP
protocol specification.
BrandLogoNetLocn The net location which can be used to
download the logo for the organization (cf.
IOTP Specification).
The content of this attribute must conform
to [URL].
BrandName This contains the name of the brand, for
example "MasterCard Credit". This is the
description of the Brand which is displayed
to the consumer in the Consumer's language
defined by "xml:lang". For example it might
be "American Airlines Advantage Visa". Note
that this attribute is not used for matching
against the payment instruments held by the
Consumer.
BrandNarrative This optional attribute is
used by the Merchant to indicate some
special conditions or benefit which would
apply if the Consumer selected that brand.
For example "5% discount", "free shipping
and handling", "free breakage insurance for
1 year", "double air miles apply", etc.
CallBackFunction A function which is called whenever there is
a change of Process State or payment
progress, e.g., for display updates. However,
the IOTP Payment Bridge may use its own
mechanisms and dialog boxes.
CallBackLanguageList
A list of language codes which contain, in
order of preference, the languages in which
the text passed to the Call Back function
will be encoded.
CompletionCode (14) Indicates how the process completed.
It is required if ProcessState is set to
"Failed" otherwise it is ignored. Valid
values as well as recovery options are given
in the IOTP specification.
The IOTP Payment Bridge may also use the
Status Description to notify the Consumer
about further necessary steps in order to
resolve some kind of business failures,
e.g.,
o "sorry, your payment transaction failed.
Unfortunately, you have been charged,
please contact your issuer."
o "insufficient capacity left (on your
stored value card) for refund",
o "payment failed/chip card error/internal
error, please contact your payment
instrument's issuer"
ConsumerDesc A narrative description of the Consumer.
ConsumerPayId (14) An unique identifier specified by the
Consumer that, if returned by the Payment
Handler in another Payment Scheme Component
or by other means, enables the Consumer to
identify which payment is being referred to.
This unique identifier is generated by the
IOTP Application Core and submitted to the
IOTP Payment Bridge on every API call. It
may equal the Payment Handler Payment
Identifiers but need not necessarily be so.
The uniqueness extends to multiple payment
instruments, payment brands, payment
protocols, wallet identifiers, and even
multiple IOTP Payment Bridges.
ContStatus During payment progress, this status value
indicates whether the payment needs to be
continued with further IOTP Payment Scheme
Component exchanges with the remote party.
"End" indicates that the reported payment
scheme data is the last data to be exchanged
with the counter party.
ContentSoftwareId This contains information that identifies
the software that generated the content of
the element. Its purpose is to help resolve
interoperability problems that might occur
as a result of incompatibilities between
messages produced by different software. It
is a single text string in the language
defined by xml:lang. It must contain, as a
minimum:
o the name of the software manufacturer,
o the name of the software,
o the version of the software, and
o the build of the software.
CurrCodeType (14) Indicates the domain of the CurrCode. This
attribute is included so that the currency
code may support nonstandard currencies
such as frequent flyer point, trading
stamps, etc. Its values may be
o ISO-4217-A, the default, indicates the
currency code is the three-letter
alphabetic code that conform to ISO-4217
[ISO4217].
o IOTP indicates that the values of
CurrCode are managed under the procedure
described in [IOTP].
CurrCode (14) A code which identifies the currency to be
used in the payment. The domain of valid
currency codes is defined by "CurrCodeType"
MerchantPayId (14) An private identifier specified by the
Merchant which will enable the Merchant to
identify which payment is being referred to.
It is a pure private item and is never sent
to any other party. It is provided by the
IOTP Payment Bridge on payment preparation
during brand compilation.
Cf. To "ConsumerPayId" for note about
uniqueness.
MerchantOrgId (64) A local item that might refer to some
specific shop in a multi shop environment.
This item is optional and might enrich the
Wallet Identifier which itself can be used
for the same purpose.
Name Distinguishes between multiple occurrences
of Packaged Content Elements at the same
point in IOTP. For example:
<ABCD>
<PackagedContent Name='FirstPiece'>
snroasdfnas934k
</PackagedContent>
<PackagedContent Name='SecondPiece'>
dvdsjnl5poidsdsflkjnw45
</PackagedContent>
</ABCD>
The "Name" attribute may be omitted, for
example if there is only one Packaged
Content element.
OkFrom (30) The date and time in UTC Format range
OkTo (30) indicated by the merchant in which the
Payment Handler may accept the payment.
For more information, see [UTC].
Passphrase (32) Payment wallets may use pass phrase
protection for transaction data and payment
instruments' data. However, it is assumed
that there exists a public and customizable
payment instrument identifier such that
these identifiers together with their
relationship to payment brands, payment
protocols, payment directions, and currency
amounts can be queried by the IOTP
application without any pass phrase
knowledge.
PayDirection Indicates the direction in which the
payment for which a Brand is being selected
is to be made. Its values may be:
o Debit: The sender of the Payment Request
Block (e.g., the Consumer) to which this
Brand List relates will make the payment
to the Payment Handler, or
o Credit: The sender of the Payment Request
Block to which this Brand List relates
will receive a payment from the Payment
Handler.
PayId (14) This attribute is introduced for API
simplification:
o The Consumer has to identify PayId and
ConsumerPayId.
o The Merchant has to identify PayId and
MerchantPayId.
o The Payment Handler has to identify PayId
and Payment Handler Pay Id.
PayInstId This contains the unique identifier used
internally by the IOTP Payment
Bridge/Existing Payment Software.
PayInstName This contains the user-defined name of the
payment instrument. There exist no
(technical) constraints like uniqueness. The
"xml:lang" attribute denotes the language
encoding of its value.
PaymentHandlerDesc A narrative description of the Payment
Handler.
PaymentHandlerPayId An unique identifier specified by the
(14) Payment Handler that, if returned by the
Consumer in another Payment Scheme Component
or by other means, enables the Payment
Handler to identify which payment is being
referred to. It is required whenever it is
known.
Cf. To "ConsumerPayId" for note about
uniqueness.
PaymentInstrumentId An identifier for a specific payment
(32) instrument, e.g., "credit card", "Mondex card
for English Pounds". This identifier is
fully customizable. It is assumed, that it
does not contain confidential information or
even an indication of it. The payment
instrument identifier is unique within each
payment brand. It is displayed to the
Consumer during brand selection.
PayReceiptNameRefs Optionally contains element references to
(32) other elements (containing payment scheme
specific data) that together make up the
receipt. Note that each payment scheme
defines in its supplement the elements that
must be referenced
The IOTP Application Core should save all
the components referenced so that the
payment receipt can be reconstructed when
required.
PayReqNetLocn The Net Location indicating where an
unsecured Payment Request message should be
sent if this protocol choice is used.
The content of this attribute must conform
to [URL] and depends on the Transport
Mechanism.
PercentComplete (3) A number between 0 and 100 which indicates
the progress of the payment transaction. The
values range between 0 and 99 for pending
and suspended transactions.
ProcessState Contains a Process State Code that
indicates the current state of the process
being carried out. Valid values are:
o NotYetStarted. The Payment Request Block
has been received but processing of the
Payment Request has not yet started
o InProgress. The payment transaction is
pending. The processing of the (Payment)
Request Block has started but it is not
yet complete.
o (*)Suspended: The payment transaction has
been suspended and can be resumed.
This process state is mapped to
"InProgress", if it is passed to the
counter party's IOTP Application Core.
o CompletedOk. The processing of the (Payment)
Request Block and any following Payment
Exchange Blocks has completed successfully.
o Failed. The payment processing has finally
failed for a Business Error.
o ProcessError. This value is only used
when the Status Component is being used in
connection with an Inquiry Request Trading
Block. It indicates there was a Technical
Error in the Request Block which is being
processed or some internal processing
error. Each party's IOTP Payment Bridge
uses this value in order to notify the
IOTP Application Core about the presence
of technical errors.
PropertyType (14) The property type defines codes used for
interrogation of specific properties about a
payment instrument. They are unique for each
payment brand. The predefined property "all"
is used on general inquiries. However, these
property types are not used during normal
payment processing. E.g., they may apply to
payment brand specific transactions or
out-of-band failure resolution.
PropertyDesc The property description carries the
respective human readable property (value)'s
description.
PropertyValue The actual property value intends automatic
post processing.
ProtocolBrandId (64)This is an identifier to be used with a
particular payment protocol. For example,
SET and EMV have their own well defined, yet
different, values for the Brand identifier
to be used with each protocol. The valid values
of this attribute are defined in the
supplement for the payment protocol
identified by "ProtocolId" that describes
how the payment protocol works with IOTP.
Identifier maps to at most one Protocol
Brand Identifier.
ProtocolId (64) An identifier for a specific payment
protocol and version, e.g., "SETv1.0",
"ecash". Valid values are defined by
supplements to the IOTP specification and
they are unique within each payment brand.
ProtocolIds A sequence of Protocol Identifiers
ProtocolName A narrative description of the payment
protocol and its version in the language
identified by "xml:lang". For example
"Secure Electronic Transaction Version 1.0".
Its purpose is to help provide information
on