Re: On Interoperability

I completely agree with this. 

What the payment space needs is a way to authorize and clear in *real-time* the transfer of liability, via a chain of debit/credit on the balance sheet of various nodes (credit intermediaries), whether official banks or not. The challenge is to be able to discover nodes that can participate in this chain based on the preferences of the parties to the transaction, and then be able to commit that chain of transactions.

The interesting thing is that every transaction in this chain is a transaction on a credit intermediary's balance sheet, from one account of an issuer of assets to another account at the same issuer, so OpenTransact fits really well this model.

Guillaume Lebleu

On Jan 12, 2012, at 10:37 AM, Pelle Braendgaard wrote:

> OpenTransact is all about interoperability. That is why it was created. I have been quite perplexed to be honest where this comes from.
> 
> It is not just library interoperability. 
> 
> It is trusting that my application can work with many different providers.
> 
> It is allowing people to create new interesting derivative open transact services on top of existing services.
> 
> It is also about letting me bring my transactions with me and maintain them in a separate app.
> 
> However as I understand it the very narrow definition of Interoperability that Manu believes we don't support is:
> 
> I want to pay someone from my PayPal account and having it show up in my Moms Dwolla account.
> 
> http://manu.sporny.org/2011/web-payments-comparison/#interoperability
> 
> Just like when you in a bank can send money from one bank to another.
> 
> Before I start going through the issues here. I would like to ask where PaySwarm specifically specifies how to move money from one payment provider to another? I can not find it in the spec.
> 
> What we realize though is that there are many different ways payment services can interoperate.
> 
> This is not as simple as defining a protocol. There are many different issues here.
> 
> Like how do I as PayPal move money to Dwolla? That is not an API issue.
> 
> Traditionally in the US you can abstract that away to banks via the ACH network and SWIFT internationally.
> 
> PayPal and Dwolla both use ACH to move money between peoples bank accounts.
> 
> The way money is moved in banking has traditionally been through banks maintaining "nostro" accounts within each other. 
> 
> So if I have an account with CitiBank and want to send $20 to someone in Wells Fargo. Citi would credit Well's Fargos nostro account $20 and tell them to send it to their customers account. Chase would charge Citibanks nostro account $20 and move that into their customers account.
> 
> Every now and then (in the old days) you would have to physically move money or gold to maintain good nostro account levels.
> 
> This was later modernized by having central banks deal with such movements in a centralized ledger, so individual banks didn't have to have connections with everyone.
> 
> In a web payment 1.0 world PayPal and Dwolla use ACH to abstract away all of that.
> 
> In a web payment 2.0 world without ACH things are different. We want to move money between two of possibly thousands of payment providers, we need either a distributed graph of connected payment providers each with "nostro" accounts with each other or a few central players.
> 
> I like the distributed graph model myself. The most important proposal in this space is Ryan Fuggers Ripple project http://ripple-project.org/
> 
> There is actually an OpenTransact implementation of it called Rivulet here:
> 
> https://github.com/jplewicke/rivulet
> 
> These are currently all based on a central graph database. But the ideas could definitely be implemented in a distributed way using OpenTransact.
> 
> The point of all of this is interoperability can mean a lot of things. Also that sending money from one institution to another is not quite as simple as it is made out.
> 
> P
> 
> 
> -- 
> http://picomoney.com - Like money, just smaller
> http://stakeventures.com - My blog about startups and agile banking