Ripple(XRP)



  • Ripple Escrows 55 Billion XRP for Supply Predictability

    Earlier this year, we committed to placing 55 billion XRP in a cryptographically-secured escrow account to create certainty of XRP supply at any given time. As promised, today we completed the lockup.

    By securing the lion’s share of XRP in escrow, people can now mathematically verify the maximum supply that can enter the market. While Ripple has proved to be a responsible steward of XRP supply for almost five years – and has clearly demonstrated a tremendous track record of investing in and supporting the XRP ecosystem – this lockup eliminates any concern that Ripple could flood the market, which we’ve pointed out before is a scenario that would be bad for Ripple!

    This move underscores Ripple’s commitment to building XRP liquidity and a healthy and trusted market. Long term, the value of digital assets will be determined by their utility. XRP has emerged as the only digital asset with a clear institutional use case designed to solve a multi-trillion dollar problem – the global payment and liquidity challenges that banks, payment providers and corporates face.

    Unlike other digital assets purely driven by unexplained speculation, real institutional customers are already using and finding value in XRP, and governments, regulators and central banks are increasingly recognizing the role it could play in the global system

    XRP goes beyond what Bitcoin does well — a store of value — and delivers transaction speed and throughput that is orders of magnitude faster than BTC or ETH. While other digital assets continue to bump against their transaction limits, XRP remains the fastest, most efficient and most scalable digital asset in the world – making it the best digital asset for payments. It’s no surprise that institutions are looking to XRP to provide much-needed on-demand liquidity for cross-border payments.

    https://twitter.com/intent/twe...

    Here’s how the escrow works:

    The Escrow feature in the XRP Ledger allows parties to secure XRP for an allotted amount of time or until specific conditions are met. For example, Escrow allows a sender of XRP to put conditions on exactly when a payment can be completed, so the payment remains cryptographically locked until the due date.

    We use Escrow to establish 55 contracts of 1 billion XRP each that will expire on the first day of every month from months 0 to 54. As each contract expires, the XRP will become available for Ripple’s use. You can expect us to continue to use XRP for incentives to market makers who offer tighter spreads for payments and selling XRP to institutional investors.

    We’ll then return whatever is unused at the end of each month to the back of the escrow rotation. For example, if 500M XRP remain unspent at the end of the first month, those 500M XRP will be placed into a new escrow account set to expire in month 55. For comparison, Ripple has sold on average 300M XRP per month for the past 18 months.

    Ripple’s vision remains the same – to enable the Internet of Value in which money moves like information moves today – and XRP is at the heart.

    To learn more, please visit ripple.com/xrp.



  • Ripple (XRP)Internet of Value Depends on Interoperability, Not Blockchain Alone

    An important and highly relevant question has emerged in the financial industry: How does blockchain technology help institutions easily connect to the increasingly diverse types of payment networks?

    In our view, the ideal global payments network works just like the internet does — by using a common language to connect disparate systems.

    In the nascent stages of the web, there were different standards for networking or connecting computers. It wasn’t shrewd to get rid of each standard — there was a purpose for each one. Instead, it was better to preserve and connect them with a common protocol.

    All ledgers should work the same way and use a simple, common language so that money can move around the world real-time, much like information does today — enabling the Internet of value.

    Interledger Protocol is driving interoperability

    There is a global technical standard that provides this level of interoperability: The Interledger Protocol (ILP). ILP can connect any network or payment system, without fundamentally changing how they work.

    All banks and payment providers — from the smallest bank to the largest institution — can use the open protocol to power payments across networks globally.

    In fact, The Bank of England recently completed a proof of concept that explored the synchronized settlement of payments using ILP.

    Additionally, the Bill & Melinda Gates Foundation used ILP to power new open-source software — Mojaloop.

    ILP helps Mojaloop connect to various payment platforms and help unbanked people around the world access digital financial services.

    Stefan Thomas, the co-creator of ILP and CTO of Ripple, expounds on the need for common standards in blockchain in his latest Medium post, “Blockchain Advocates Must Learn the Law of Standards.



  • Ripple - How XRP Stacks Up Against Other Digital Assets

    Everyone is talking about the digital asset space. Wild price fluctuations, new XRP capital funds and Bitcoin (BTC) forks have made it virtually impossible for consumers or the financial industry to ignore the popularity and proliferation of these assets.

    In fact, the digital asset landscape has grown so much that there are more than 1,300 types of assets on the market with a collective market cap of $450 billion as of this posting.

    We examined the top digital assets for payments while comparing their speed, cost and scalability. Here’s what we found.


    Which digital asset is the best for payments?

    XRP is the only digital asset with a clear institutional use case designed to solve a multi-trillion dollar problem – the global payment and liquidity challenges that banks, payment providers and corporates face. In order to effectively solve this problem, speed, cost and scalability are of extreme importance. When you line up the top digital assets for these attributes, it’s clear that XRP is the winner.

    XRP is part of a bigger vision

    XRP is a key enabler of the Internet of Value — Ripple’s vision for making money move at the speed of digital information. XRP’s speed, transparency, and scalability help financial institutions move money like information moves today — in real time.

    It’s no wonder that real institutional customers are using and finding value in XRP and governments, regulators and central banks are increasingly recognizing the role it could play in the global system.

    For more information about XRP, visit our XRP Charts or learn how to buy XRP.



  • Ripple (XRP) - Top Korean Banks Work with Japan Bank Consortium to Modernize Cross-border Payments

    The ability to send money globally in real time has caught fire in the international financial industry. Large banking groups, such as the Japan Bank Consortium, are leading the charge.

    The Japan Bank Consortium — a coalition of 61 banks in Japan, organized by SBI Ripple Asia — has announced the launch of a new Ripple pilot with Woori Bank and Shinhan Bank, two of South Korea’s largest banks with a collective market capitalization of more than $30 billion.

    This initiative will be the first time money moves from Japan to Korea over RippleNet.

    Korean banks committing to the modernization of payments

    The Japan Bank Consortium will use Ripple’s settlement technology, xCurrent, to settle transactions between participating Japanese banks and Woori Bank or Shinhan Bank.

    The pilot solidifies the Japan Bank Consortium’s commitment to modernize payment systems — specifically in the Japan/Korea corridor where Korea is Japan’s third largest trade partner — to send money instantly, removing the need for intermediaries while reducing the cost of sending global payments.

    What’s more, the Japan Bank Consortium created a virtual currency and blockchain working group to explore the institutional use case of digital currencies, such as XRP, to source on-demand liquidity for these cross-border payments.

    Delivering a much-needed solution for cross-border payments

    Banks within the Japan Bank Consortium are one of many institutions that are actively working with Ripple to solve the multi-trillion dollar problem plaguing the financial industry, corporates and consumers worldwide — the lack of liquidity (or cash) to instantly send or receive low-cost international payments.

    “The Japan Bank Consortium’s pilot with Woori Bank and Shinhan Bank brings us closer to sending money in an important corridor,” said Emi Yoshikawa, director of partnerships at Ripple.

    “The use of RippleNet to send cross-border payments reinforces that financial institutions are ready to provide a modern payments experience and enable to the Internet of Value.”

    Visit our Solutions page to learn more about our products.



  • Ripple (XRP) Release rippled wallet V0.80.2

    Dec 15, 2017 | Rome Reginelli

    Ripple has released rippledversion 0.80.2, which improves the transaction dispatch logic of rippled, allows for more transactions to be in flight at any one time and reduces the overall resource usage of rippled. The improved transaction dispatch logic ensures that a transaction is dispatched at most once every 10 seconds, even if it received from multiple peers during that interval.

    The fix should also improve load accounting on peer links, reducing the number of extraneous server-server connection drops caused by redundant transaction dispatching.

    Ripple strongly recommends upgrading to rippled version 0.80.2 immediately.

    Action Required

    If you operate a rippledserver, then you should upgrade to 0.80.2 immediately.

    Impact of Not Upgrading

    • If you operate a rippledserver, but do not upgrade to rippled version 0.80.2, then your rippled server will use more resources than necessary and may periodically drop transactions and fall out of sync with the network.

    For instructions on updating rippled on supported platforms, see Updating a0f431a55a241770d7496b240e4d2c638f2cadd4126ee621c5ed980b8174223c

    The SHA-256 for the source RPM is: d25bda2c384c67e48fe6c29250c07039d33c6ed5d280ad19fc246469213fe251

    For other platforms, please compile version 0.80.2 from source.

    The first log entry should be the change setting the version:

    commit d2fc4e3569d79d3cade78533f673f642a8d26845
    Author: Nikolaos D. Bougalis <[email protected]>
    Date:   Thu Dec 14 15:30:20 2017 -0800
        Set version to 0.80.2
    

    Network Update

    The Ripple technical operations team will deploy rippledversion 0.80.2 to all production rippled servers under its operational control, on Friday, 12/15/2017.

    Learn, ask questions, and discuss

    Related documentation is available in the Ripple Developer PortalThe Ripple Forum

  • The Ripple Dev [email protected]
  • XRP Chat(#2294)
  • Control transaction dispatch rate (#2297)previously-released rippled version 0.80.1 also included the following fixes and improvements:

    New and Updated Features

    • Allow including validator manifests in published list (#2278#2242)
    • Support SNI#2275)
    • Grow TxQ expected size quickly, shrink slowly (#2235#2240)
    • Properly use ledger hash to break ties when determing working ledger for consensus (#2257#2252)
    • Verify validator token manifest matches private key (#2268)


  • Ripple(XRP) - Krungsri Collaborates with Petrochemical Company to Expedite Cross-border Payments and Retain Customers

    Bank customers — both consumers and businesses — have spoken and they demand a faster way to send money globally.

    Krungsri (Bank of Ayudhya PCL), one of the largest banks in Thailand, heard the call, and in an effort to better serve their customers, they joined RippleNet to remove the friction from cross-border payments.

    In fact, Krungsri now uses Ripple’s enterprise blockchain network to help a large Southeast Asian petrochemical company, send real-time cross-border payments to its foreign customers — a first for financial institutions in the Thai region.

    Breaking with the status quo for the good of the customer

    The collaboration between Krungsri and the large petrochemical company was born from a common pain point for most corporates: Customers were dissatisfied with the lack of speed and visibility into cross-border payments.

    When the company attempted to send payments to their partners it would take several days to complete the transaction.

    What’s more, neither the sender nor the receiver had visibility into the status of the payment — which was very frustrating for the petrochemical company’s customers.

    If the company continued to use the typical, slow, opaque payments process, then they risked losing valuable foreign partners, which would be detrimental to their bottom line.

    That’s when Krungsri stepped in to help their long-time customer.

    Krungsri President and Chief Executive Officer Mr. Noriaki Goto said, “We have gained trust from the large petrochemical company, our long-time major business partner, to deploy RippleNet for the money transfer between the company and its overseas trading partners.”

    RippleNet-enabled Krungsri provides innovative solution to client

    By using Ripple’s blockchain network, Krungsri is not only able to provide a real-time cross-border payment flow for the petrochemical company, but also provide complete transparency into when the payment would be received.

    “The transactions were successfully completed within a few seconds versus at least one to three business days under the previous system. This reflects the innovative strength of Ripple’s technology that will drive the Thai business sector towards faster expansion,” added Mr. Goto.

    The success of the large petrochemical company’s deployment marked a significant change in the financial landscape for Krungsri, who will continue to reap the benefits from using RippleNet’s blockchain network.

    As a subsidiary of Mitsubishi UFJ Financial Group (MUFG) — Japan’s largest financial group and one of the world’s five largest financial institutions, with more than 2,000 branches in over 50 countries — Krungsri is positioned to provide instant global payments to service their corporate customers’ needs.

    “Using RippleNet will be a catalyst to use additional financial innovations to deliver real-time cross-border payments for other business partners,” concluded Mr. Goto.

    Learn how Ripple has helped other corporate modernize global payments.



  • Ripple(XRP) Exploring Innovation in Payment System Infrastructures - added More Than 100 Clients to Ripplenet


    While the market has been focused on the bitcoin frenzy and commercial banks continue their migration onto enterprise-grade platforms, such as RippleNet, another revolution has quietly bubbled up around Distributed Ledger Technology (DLT).

    Central banks and financial market infrastructures, key stakeholders in the global payments system, have ramped up their engagement with technology providers to explore how they can leverage DLT.

    The Monetary Authority of Singapore (MAS) is front and center in this space, announcing the second phase of their Project UBIN at their fintech event in November 2017.

    Additionally, the Australian Stock Exchange has capped off two years of experimentation to declare the adoption of DLT to replace their legacy CHESS securities clearing and settlement platform.

    So what’s Ripple doing to help?

    Ripple is leading the sea change in payments

    At Ripple, we’re focused on engaging with commercial banks to implement production-grade enterprise systems — using DLT — to support cross-border payments. In fact, we recently celebrated a significant milestone — we added the 100th client to RippleNet. What’s more, banks like Siam Commercial in Thailand, Standard Chartered in Singapore, Axis in India and Rakbank in the UAE are already sending and receiving payments in commercial volumes. In Japan, 61 members of the Japan Bank Consortium are in pre-production stage on a hosted Ripple platform.

    The Ripple xCurrent product — a solution that allows banks to settle cross-border payments with end-to-end tracking instantly — is now enterprise-tested. Also, the public XRP Ledger, operating since late 2013, successfully completed 35 million ledger updates without failure and offered throughput of 1,500 transactions per second.

    The Bank of England has concluded a successful project to send transactions between two RTGS systems using Ripple.

    Additionally, Ripple’s Regulatory Affairs team has engaged central banks across the world to assess the implications of DLT for their economies, most recently via a Central Bank Summit that attracted over 30 delegates to New York City in October 2017.

    Driving infrastructure innovation

    Ripple is now taking the next logical step to help build the Internet of Value, by establishing an Infrastructure Innovation initiative. We’ll offer our technology products and deep expertise in both payment systems and DLT to enable central banks and market infrastructures to innovate on their own digital journey. We can provide proven building blocks for both regulators and commercial banks to pilot real-world solutions in collaboration with the Ripple team. We’re excited about the possibilities for innovation — to create regional networks, to reduce the systemic costs of payments, to open up networks to new participants while managing risks tightly with more granular information and smart automation.

    Ripple’s Infrastructure Innovation team will be led by Dilip Rao, a veteran at Ripple since July 2014. Rao has led the business development in the APAC/MENA region and worked closely with banks as well as central banks and market infrastructures. He has over 30 years of experience working with banking technology and innovation in payments and understands Ripple’s solutions well.

    As our new Global Head, Infrastructure Innovation, Rao will engage with known and new stakeholders responsible for the world’s payment infrastructure, bringing a consulting mindset to explore new concepts with the backing of Ripple’s technologists.

    “My first priority will be piloting interoperability between payment systems, the use of DLT for domestic clearing and settlement and novel applications of xCurrent as well as our digital asset XRP,” said Rao. “I look forward to exciting new initiatives in building the Internet of Value in 2018!”

    Ripple invites central banks and financial market infrastructure leaders to reach out and work with Ripple on these new frontiers.



  • Zoe Cruz Joins Ripple’s Board of Directors


    Ripple is excited to welcome Zoe Cruz to our board of directors. Cruz served as co-president for institutional securities and wealth management at Morgan Stanley from 2005 to 2007. Prior to that role, she was global head of fixed income, commodities and foreign exchange. She joined Morgan Stanley in 1982 and was the third founding member of the foreign exchange (FX) group.

    Forbes named her to its Most Powerful Women list for three years running (2005, 2006, 2007).

    Following her 25-year tenure at Morgan Stanley, Cruz founded an investment management firm, Voras Capital Management and was senior adviser at Promontory Financial Group. Today, she is founder and CEO of EOZ Global, a single family office.

    Cruz is a member of Old Mutual PLC’s board of directors and is a member of the investment committee for the endowment fund of Bowdoin college.

    “With her 35 years of experience in finance and foreign exchange, Zoe will offer us a unique perspective and invaluable guidance on how to accelerate RippleNet growth and XRP usage across the network globally,” said Brad Garlinghouse, CEO of Ripple. “The team is incredibly inspired by Zoe’s career and we very much look forward to leveraging her expertise to make our vision — an Internet of Value — a reality.”



  • Ripple - Happy 5th Anniversary, XRP Ledger!

    Ripple has had a lot to celebrate over the last year!

    From adding new RippleNet members, to launching our first blockchain conference, to completing the escrow of 55 billion XRP, it’s clear that the team’s hard work to enable the Internet of Value (IoV), coupled with the XRP community’s support, is paying off.

    In fact, XRP has experienced phenomenal growth — up nearly 12,000 percent — from December 2016 to December 2017. This makes XRP’s performance better than any other digital asset in the industry in 2017.

    But just as the year is coming to a close, there’s one more reason for the Ripple team and the XRP community to celebrate — the five year anniversary of the XRP Ledger.

    XRP sets the standard from the start

    Since 2012, XRP has been considered the only digital asset with a clear institutional use case that works to solve the multi-trillion dollar liquidity problem that plagues banks, payment providers and corporates.

    For example, XRP can provide liquidity to financial institutions who need to send cross-border payments — presenting a greater opportunity for these institutions to widen their footprint in major corridors or gain more access to emerging markets.

    Cuallix, a major payment provider, is the first RippleNet member to use xRapid — Ripple’s solution that uses XRP to source liquidity — to reduce the cost of sending cross-border payments and remittances from the U.S. to Mexico.

    The XRP Ledger, the digital asset’s underlying distributed ledger technology, is the key reason why XRP steadily led the pack of digital assets by being the fastest, most cost-effective, scalable digital asset for payments, which helps advance its goal — enabling IoV.

    IoV is the belief that money should move in the same fashion as digital information moves today — in real time.

    In order to deliver on this vision, Ripple continues to support the development and adoption of the XRP Ledger to ensure that XRP remains the fastest, most scalable digital asset on the market.

    Additionally, the digital asset market is seeing more demand for XRP which speaks to consumers’ understanding that XRP is the best digital asset to remove the friction from global payments.

    Ripple pledges to increase XRP usage

    The Ripple team is committed to furthering the adoption and usage of XRP for payments. In fact, we continuously work with regulators, governments and central banks to better understand how our technology can help remove the friction from cross-border payments.

    And, as more digital assets flood the market, the value of digital assets will be determined by their utility and the problem they solve for their users.

    Since XRP, has continually provided a strong use case and is undisputed in its technological achievements, it makes sense that the market would take notice — prompting a surge in XRP’s value.

    What’s more, XRP is now available to more than 50 exchanges worldwide to better serve the global demand for the digital asset.

    It has been a phenomenal five years, and the Ripple team is appreciative of the community’s support. We can’t wait to see what the future years will bring!

    Watch our live Q&A with David Schwarz today. As Brad Garlinghouse said in his livestream, “David Schwartz is the Steph Curry of cryptography.”



  • Ripple - XRP Now Available on 50 Exchanges Worldwide


    The digital asset market is heating up. Many new assets entered the space touting to be better and faster for settling payments. Worldwide interest surged, which boosted the collective market cap from $93.3 billion in August 2017 to just under $600 billion by mid-December 2017 — an increase of 543 percent in just four months.

    However, despite continued rise of digital assets, XRP remains the fastest and most scalable asset on the market.

    The market is taking notice of XRP’s speed, reliability and scalability — which has strengthened the demand for XRP and where it’s listed. In fact, we’re proud to announce that XRP has gone from being listed on six exchanges earlier this year to more than 50 worldwide.

    The increased demand for XRP speaks to the market’s understanding of the need for a fast and scalable asset that serves as a reliable liquidity tool for financial institutions through the product xRapid.

    To serve that role in cross-border flows, XRP needs deep liquidity across fiat currencies. In support of that goal and healthy XRP markets, it’s a top priority for Ripple to have XRP listed on top digital asset exchanges, making it broadly accessible worldwide. Ripple has dedicated resources to the initiative so you can expect ongoing progress.

    XRP’s widening footprint in major markets

    In addition to our current listings, expansion into the following global exchanges makes it possible for Ripple to better serve growing demand for XRP. It also reinforces that XRP is the digital asset that can truly modernize the global payments systems.

    XRP is now available on the following exchanges:

    • CEX.IO — One of the largest exchanges in the United Kingdom with an average daily total trade volume of $94 million.
    • GMOCoin — The leading exchange in Japan.
    • Huobi.pro — A major exchange in Singapore with an average daily total trade volume of $787 million.

    XRP is the leading digital asset to remove friction from global payments

    XRP’s long-term value is determined by its utility — including its ability to help financial institutions source liquidity for payments into and out of emerging markets. In fact, financial institutions have already begun to use XRP as a liquidity tool, reducing the cost of sending cross-border payments.

    “The market recognizes that XRP is the fastest, most scalable digital asset for global payments that can also provide liquidity to financial institutions,” said Patrick Griffin, SVP of business development for Ripple.

    “What’s more, being listed on more than 50 exchanges will not only make this asset more available globally but also further the Internet of Value, which will enable the world to move money as easily as information moves today.”

    Ready to learn more? Visit our XRP page

    The online HTML CheatSheet website shoult be the first bookmark of every web developer. It is the best one-page resource to generate the desired markup.



  • The Season for Giving: Auctioning Off Ripple-Branded Patagonia Jackets for Charity


    We’ve received a lot of interest in the Ripple-branded Patagonia jacket Ripple CEO Brad Garlinghouse sported on his end-of-year “Ask Me Anything.”

    Since it’s the season for giving (and for XRP!), we’re auctioning off 16 jackets for charity.

    We’ll donate 100 percent of the auction proceeds to GiveDirectly.org and we’ll match donations one-to-one. What’s more, we’ll make the donation in XRP — the world’s best digital asset for payments.

    Backed by GiveWell and Google.org, GiveDirectly puts donations into the hands of extremely poor families in the developing world in the most capital efficient way currently possible.

    The jackets will go to the 16 highest bidders. Ripple will cover the domestic and international shipping and handling costs.

    You can view and bid on the listings here:

    Women’s Small: https://www.ebay.com/ itm/122881674145 Women’s Small: https://www.ebay.com/ itm/122881664467

    Women’s Medium: https://www.ebay.com/ itm/122881668749 Women’s Medium: https://www.ebay.com/ itm/122881669251

    Women’s Large: https://www.ebay.com/ itm/122881666818 Women’s Large: https://www.ebay.com/ itm/122881668044

    Women’s XL: https://www.ebay.com/itm/ 122881665540 Women’s XL: https://www.ebay.com/itm/ 122881665881

    Men’s Small: https://www.ebay.com/ itm/122881672580 Men’s Small: https://www.ebay.com/ itm/122881673084

    Men’s Medium: https://www.ebay.com/ itm/122881671515 Men’s Medium: https://www.ebay.com/ itm/122881671979

    Men’s Large: https://www.ebay.com/ itm/122881670247 Men’s Large: https://www.ebay.com/ itm/122881671108

    Men’s XL: https://www.ebay.com/itm/ 122881669700
    Men’s XL: https://www.ebay.com/itm/ 122881665020



  • Ripple (XRP) Takes The 2nd Place for Market Cap.

    Ripple gain 84.27% and beat Eth. Ripple's total market cap is $71,946,339,810 & Ethereum cap is $71,642,914,669





    Image Source:https://coinmarketcap.com




  • Ripple (XRP) API Beginners Guide

    This tutorial guides you through the basics of building an XRP Ledger-connected application using Node.jsRippleAPI, a JavaScript API for accessing the XRP Ledger.

    The scripts and configuration files used in this guide are available in the Ripple Dev Portal GitHub Repository.

    Environment Setup

    The first step to using RippleAPI is setting up your development environment.

    Install Node.js and npm

    RippleAPI is built as an application for the Node.js runtime environment, so the first step is getting Node.js installed. RippleAPI requires Node.js version 0.12, version 4.x, or higher.

    This step depends on your operating system. We recommend the official instructions for installing Node.js using a package manager for your operating system. If the packages for Node.js and npm (Node Package Manager) are separate, install both. (This applies to Arch Linux, CentOS, Fedora, and RHEL.)

    After you have installed Node.js, you can check the version of the node binary from a command line:

    node --version
    

    On some platforms, the binary is named nodejs instead:

    nodejs --version
    

    Use NPM to install RippleAPI and dependencies

    RippleAPI uses the newest version of JavaScript, ECMAScript 6 (also known as ES2015). To use the new features of ECMAScript 6, RippleAPI depends on Babel-Node and its ES2015 presets. You can use npm to install RippleAPI and these dependencies together.

    1. Create a new directory for your project

    Create a folder called (for example) my_ripple_experiment:

    mkdir my_ripple_experiment && cd my_ripple_experiment
    

    Optionally, start a Git repository in that directory so you can track changes to your code.

    git init
    

    Alternatively, you can create a repo on GitHubclone the repo to your local machine and cd into that directory.

    2. Create a new package.json file for your project.

    Use the following template, which includes:

    • RippleAPI itself (ripple-lib)
    • Babel (babel-cli)
    • The ECMAScript 6 presets for Babel (babel-preset-es2015)
    • (Optional) ESLint (eslint) for checking code quality.
    "name": "my_ripple_experiment",
      "version": "0.0.1",
      "license": "MIT",
      "private": true,
      "//": "Change the license to something appropriate. You may want to use 'UNLICENSED' if you are just starting out.",
      "dependencies": {
        "ripple-lib": "*",
        "babel-cli": "^6.0.0",
        "babel-preset-es2015": "*"
      },
      "babel": {
        "presets": ["es2015"]
      },
      "devDependencies": {
        "eslint": "*"
      }

    This automatically installs all the dependencies defined in the package.json into the local folder node_modules/. (We recommend not using npm -g to install the dependencies globally.)

    The install process may take a while and end with a few warnings. You may safely ignore the following warnings:

    npm WARN optional Skipping failed optional dependency /chokidar/fsevents:
    npm WARN notsup Not compatible with your operating system or architecture: [email protected]
    npm WARN [email protected] requires a peer of [email protected].x but none was installed.
    

    First RippleAPI Script

    This script, get-account-info.js, fetches information about a hard-coded account. Use it to test that RippleAPI works:

    'use strict';
    const RippleAPI = require('ripple-lib').RippleAPI;
    const api = new RippleAPI({
      server: 'wss://s1.ripple.com' // Public rippled server
    });
    api.connect().then(() => {
      /* begin custom code ------------------------------------ */
      const myAddress = 'rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn';
      console.log('getting account info for', myAddress);
      return api.getAccountInfo(myAddress);
    }).then(info => {
      console.log(info);
      console.log('getAccountInfo done');
      /* end custom code -------------------------------------- */
    }).then(() => {
      return api.disconnect();
    }).then(() => {
      console.log('done and disconnected.');
    }).catch(console.error);

    Running the script

    RippleAPI and the script both use the ECMAScript 6 version of JavaScript. That's why we installed Babel earlier. The easiest way to run ECMAScript 6 is to use the babel-node binary, which NPM installs in the node_modules/.bin/ directory of your project. Thus, running the script looks like this:

    ./node_modules/.bin/babel-node get-account-info.js
    

    Output:

    getting account info for rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn
    { sequence: 359,
      xrpBalance: '75.181663',
      ownerCount: 4,
      previousInitiatedTransactionID: 'E5C6DD25B2DCF534056D98A2EFE3B7CFAE4EBC624854DE3FA436F733A56D8BD9',
      previousAffectingTransactionID: 'E5C6DD25B2DCF534056D98A2EFE3B7CFAE4EBC624854DE3FA436F733A56D8BD9',
      previousAffectingTransactionLedgerVersion: 18489336 }
    getAccountInfo done
    done and disconnected.
     
    

    Understanding the script

    In addition to RippleAPI-specific code, this script uses syntax and conventions that are recent developments in JavaScript. Let's divide the sample code into smaller chunks to explain each one.

    Script opening

    'use strict';
    const RippleAPI = require('ripple-lib').RippleAPI;
     
    

    The opening line enables strict modeRestrictions on Code in Strict Mode.

    The second line imports RippleAPI into the current scope using Node.js's require function. RippleAPI is one of the modules

    const api = new RippleAPI({
      server: 'wss://s1.ripple.com' // Public rippled server
    });
     
    


    This section creates a new instance of the RippleAPI class, assigning it to the variable api. (The api to some other value. The internal state of the object can still change, though.)

    The one argument to the constructor is an options object, which has a variety of options. The server parameter tells it where it should connect to a rippled server.


    Connecting and Promises

    api.connect().then(() => {
    


    The connect() methodPromise, which is a special kind of JavaScript object. A Promise is designed to do an asynchronous operation that returns a value later, such as querying the XRP Ledger.

    When you get a Promise back from some expression (like api.connect()), you call the Promise's then method and pass in a callback function. Passing a function as an argument is conventional in JavaScript, taking advantage of how JavaScript functions are first-class objects.

    When a Promise finishes with its asynchronous operations, the Promise runs the callback function you passed it. The return value from the then method is another Promise object, so you can "chain" that into another then method, or the Promise's catch method, which also takes a callback. The callback you pass to catch gets called if something goes wrong.

    Finally, we have more new ECMAScript 6 syntax - an arrow function. Arrow functions are a shorter way of defining anonymous functions. This is convenient for defining lots of one-off functions as callbacks. The syntax ()=> {...} is mostly equivalent to function() {...}. If you want an anonymous function with one parameter, you can use a syntax like info => {...} instead, which is almost the same as function(info) {...} syntax.

    Custom code

      /* begin custom code ------------------------------------ */
      const myAddress = 'rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn';
      console.log('getting account info for', myAddress);
      return api.getAccountInfo(myAddress);
    }).then(info => {
      console.log(info);
      console.log('getAccountInfo done');
      /* end custom code -------------------------------------- */
     
    

    This is the part that you change to do whatever you want the script to do.

    The example code looks up an XRP Ledger account by its address. Try running the code with different addresses to see different results.

    The console.log() function is built into both Node.js and web browsers, and writes out to the console. This example includes lots of console output to make it easier to understand what the code is doing.

    Keep in mind that the example code starts in the middle of a callback function (called when RippleAPI finishes connecting). That function calls RippleAPI's getAccountInfo API method returns another Promise, so the line }).then( info => { defines another anonymous callback function to run when this Promise's asynchronous work is done. Unlike the previous case, this callback function takes one argument, called info, which holds the asynchronous return value from the getAccountInfo API method. The rest of this callback function outputs that return value to the console.

    Cleanup

    }).then(() => {
      return api.disconnect();
    }).then(() => {
      console.log('done and disconnected.');
    }).catch(console.error);
     
    

    The rest of the sample code is mostly more boilerplate code. The first line ends the previous callback function, then chains to another callback to run when it ends. That method disconnects cleanly from the XRP Ledger, and has yet another callback which writes to the console when it finishes. If your script waits on RippleAPI events, do not disconnect until you are done waiting for events.

    The catch method ends this Promise chain. The callback provided here runs if any of the Promises or their callback functions encounters an error. In this case, we pass the standard console.error function, which writes to the console, instead of defining a custom callback. You could define a smarter callback function here to intelligently catch certain error types.

    Waiting for Validation


    One of the biggest challenges in using the XRP Ledger (or any decentralized system) is knowing the final, immutable transaction results. Even if you follow the best practicesconsensus process to finally accept or reject your transaction. The following example code demonstrates how to wait for the final outcome of a transaction:

    'use strict';
    /* import RippleAPI and support libraries */
    const RippleAPI = require('ripple-lib').RippleAPI;
    const assert = require('assert');
    /* Credentials of the account placing the order */
    const myAddr = 'rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn';
    const mySecret = 's████████████████████████████';
    /* Define the order to place here */
    const myOrder = {
      'direction': 'buy',
      'quantity': {
        'currency': 'FOO',
        'counterparty': 'rUpy3eEg8rqjqfUoLeBnZkscbKbFsKXC3v',
        'value': '100'
      },
      'totalPrice': {
        'currency': 'XRP',
        'value': '1000'
      }
    };
    /* Milliseconds to wait between checks for a new ledger. */
    const INTERVAL = 1000;
    /* Instantiate RippleAPI. Uses s2 (full history server) */
    const api = new RippleAPI({server: 'wss://s2.ripple.com'});
    /* Number of ledgers to check for valid transaction before failing */
    const ledgerOffset = 5;
    const myInstructions = {maxLedgerVersionOffset: ledgerOffset};
    /* Verify a transaction is in a validated XRP Ledger version */
    function verifyTransaction(hash, options) {
      console.log('Verifing Transaction');
      return api.getTransaction(hash, options).then(data => {
        console.log('Final Result: ', data.outcome.result);
        console.log('Validated in Ledger: ', data.outcome.ledgerVersion);
        console.log('Sequence: ', data.sequence);
        return data.outcome.result === 'tesSUCCESS';
      }).catch(error => {
        /* If transaction not in latest validated ledger,
           try again until max ledger hit */
        if (error instanceof api.errors.PendingLedgerVersionError) {
          return new Promise((resolve, reject) => {
            setTimeout(() => verifyTransaction(hash, options)
            .then(resolve, reject), INTERVAL);
          });
        }
        return error;
      });
    }
    /* Function to prepare, sign, and submit a transaction to the XRP Ledger. */
    function submitTransaction(lastClosedLedgerVersion, prepared, secret) {
      const signedData = api.sign(prepared.txJSON, secret);
      return api.submit(signedData.signedTransaction).then(data => {
        console.log('Tentative Result: ', data.resultCode);
        console.log('Tentative Message: ', data.resultMessage);
        /* If transaction was not successfully submitted throw error */
        assert.strictEqual(data.resultCode, 'tesSUCCESS');
        /* 'tesSUCCESS' means the transaction is being considered for the next ledger, and requires validation. */
        /* If successfully submitted, begin validation workflow */
        const options = {
          minLedgerVersion: lastClosedLedgerVersion,
          maxLedgerVersion: prepared.instructions.maxLedgerVersion
        };
        return new Promise((resolve, reject) => {
          setTimeout(() => verifyTransaction(signedData.id, options)
        .then(resolve, reject), INTERVAL);
        });
      });
    }
    api.connect().then(() => {
      console.log('Connected');
      return api.prepareOrder(myAddr, myOrder, myInstructions);
    }).then(prepared => {
      console.log('Order Prepared');
      return api.getLedger().then(ledger => {
        console.log('Current Ledger', ledger.ledgerVersion);
        return submitTransaction(ledger.ledgerVersion, prepared, mySecret);
      });
    }).then(() => {
      api.disconnect().then(() => {
        console.log('api disconnected');
        process.exit();
      });
    }).catch(console.error);
     
    

    This code creates and submits an order transaction, although the same principles apply to other types of transactions as well. After submitting the transaction, the code uses a new Promise, which queries the ledger again after using setTimeout to wait a fixed amount of time, to see if the transaction has been verified. If it hasn't been verified, the process repeats until either the transaction is found in a validated ledger or the returned ledger is higher than the LastLedgerSequence parameter.

    In rare cases (particularly with a large delay or a loss of power), the rippled server may be missing a ledger version between when you submitted the transaction and when you determined that the network has passed the maxLedgerVersion. In this case, you cannot be definitively sure whether the transaction has failed, or has been included in one of the missing ledger versions. RippleAPI returns MissingLedgerHistoryError in this case.

    If you are the administrator of the rippled server, you can manually request the missing ledger(s). Otherwise, you can try checking the ledger history using a different server. (Ripple runs a public full-history server at s2.ripple.com for this purpose.)

    See Reliable Transaction Submission for a more thorough explanation.

    RippleAPI in Web Browsers

    RippleAPI can also be used in a web browser if you compile a browser-compatible version and include lodash as a dependency before the RippleAPI script.

    Build Instructions

    To use RippleAPI in a browser, you need to build a browser-compatible version. The following process compiles RippleAPI into a single JavaScript file you can include in a webpage.

    1. Download a copy of the RippleAPI git repository.

    If you have Git installed, you can clone the repository and check out the master branch, which always has the latest official release:

    git clone https://github.com/ripple/ripple-lib.git
    cd ripple-lib
    git checkout master
    

    Alternatively, you can download an archive (.zip or .tar.gz) of a specific release from the RippleAPI releases page and extract it.

    2. Install dependencies using NPM

    You need to have NPM (Node.js Package Manager) installed first.

    Then, from within the ripple-lib directory, you can use NPM to install all the necessary dependencies:

    npm install
    

    (We recommend not using npm -g to install dependencies globally.)

    This can take a while, and may include some warnings. The following warnings are benign and do not indicate a problem:

    npm WARN optional Skipping failed optional dependency /chokidar/fsevents:
    npm WARN notsup Not compatible with your operating system or architecture: [email protected]
    

    3. Use Gulp to build a single JavaScript output

    RippleAPI comes with code to use the gulp package to compile all its source code into browser-compatible JavaScript files. Gulp is automatically installed as one of the dependencies, so all you have to do is run it. RippleAPI's configuration makes this easy:

    npm run build
    

    Output:

    > [email protected] build /home/username/ripple-lib
    > gulp
    [15:22:30] Using gulpfile /home/username/ripple-lib/Gulpfile.js
    [15:22:30] Starting 'build'...
    [15:22:30] Starting 'build-debug'...
    [15:22:42] Finished 'build' after 12 s
    [15:22:42] Starting 'build-min'...
    [15:22:42] Finished 'build-debug' after 12 s
    [15:22:51] Finished 'build-min' after 9.83 s
    [15:22:51] Starting 'default'...
    [15:22:51] Finished 'default' after 4.58 μs
     
    

    This may take a while. At the end, the build process creates a new build/ folder, which contains the files you want.

    The file build/ripple-<VERSION NUMBER>.js is a straight export of RippleAPI (whatever version you built) ready to be used in browsers. The file ending in -min.js is the same thing, but with the content minified for faster loading.

    Example Browser Usage

    The following HTML file demonstrates basic usage of the browser version of RippleAPI to connect to a public rippled server and report information about that server. Instead of using Node.js's "require" syntax, the browser version creates a global variable named ripple, which contains the RippleAPI class.

    To use this example, you must first build RippleAPI and then copy one of the resulting output files to the same folder as this HTML file. (You can use either the minified or full-size version.) Change the first <script> tag in this example to use the correct file name for the version of RippleAPI you built.

    browser-demo.html:

    <!DOCTYPE html>
    <html>
    <head>
      <script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.15.0/lodash.js"></script>
      <script src="ripple-0.17.7-min.js"></script>
      <script>
        console.log(ripple);
        var api = new ripple.RippleAPI({server:'wss://s1.ripple.com/'});
        api.connect().then(function() {
            return api.getServerInfo();
        }).then(function(server_info) {
        document.body.innerHTML += "<p>Connected to rippled server!</p>" +
    "      <table>" +
    "        <tr><th>Version</th>" +
    "          <td>" + server_info.buildVersion + "</td></tr>" +
    "        <tr><th>Ledgers available</th>" +
    "          <td>" + server_info.completeLedgers + "</td></tr>" +
    "        <tr><th>hostID</th>" +
    "          <td>" + server_info.hostID + "</td></tr>" +
    "        <tr><th>Most Recent Validated Ledger Seq.</th>" +
    "          <td>" + server_info.validatedLedger.ledgerVersion + "</td></tr>" +
    "        <tr><th>Most Recent Validated Ledger Hash</th>" +
    "          <td>" + server_info.validatedLedger.hash + "</td></tr>" +
    "        <tr><th>Seconds since last ledger validated</th>" +
    "          <td>" + server_info.validatedLedger.age + "</td></tr>" +
    "      </table>";
        });
      </script>
      <style type="text/css">
        td, th { border: 1px solid black; padding: 5px; }
        table { border-collapse: collapse; }
      </style>
    </head>
    <body></body>
    </html>
     
    



  • Ripple (XRP) - Looking Ahead: 2018 Predictions for the Digital Asset Space


    2017 was the year all eyes turned to digital assets and blockchain technology — spurring both to pop up everywhere around the globe.

    In fact, there are now more than 1,300 types of digital assets with a collective market capitalization of over $700 billion — which is a higher market cap than some of the biggest banks in the United States.

    And, these days it seems that everyone has a blockchain. Long Island Iced Tea purveyors of, well … iced tea, decided to move into the blockchain industry and changed their name to Long Blockchain.

    So what will 2018 mean for the space? Here are a few of the team’s predictions.

    If 2017 was the birth of the ICO, 2018 will be its demise 

    Ripple CEO Brad Garlinghouse has said several times over the course of last year that Initial Coin Offerings (ICOs) are toxic and many investors will get burned — badly.

    The first half of the new year will no doubt see this unfortunate prediction come to fruition. Regulators worldwide are already cracking down hard on many illegitimate, fraudulent ICOs and the people behind them.

    It wouldn’t surprise us if we see a proliferation of lawsuits, fines, and even jail time for some. We expect this will drive significant volatility in the crypto space, but only in the short term.

    Digital assets: the best versus the rest

    We also expect this period of uproar to shine a spotlight on the best digital assets (tokens) with the strongest use case, backed by real, legitimate businesses. Digital assets that solve real problems will emerge as winners. Period.

    Those that are nothing more than an experiment will scramble to find them. CryptoKitties is just one example of what we’ll see more and more over the next few months — half-baked attempts to find a use case for coins that never had a purpose to begin with.

    So while much of the general global public has heard of bitcoin or ethereum, or even Cryptokitties, demand for alternatives to these will grow exponentially.

    Which brings us to my next major prediction for 2018: We expect the digital asset market to surpass the $1 trillion mark before year end. And you know what that means…

    FOMO and interoperability

    Buyers that aren’t already exposed will have major FOMO — and dive in by the droves. We also wouldn’t be surprised to see new funds focused entirely on crypto funds spring up everywhere.

    Last but certainly not least, there won’t be one blockchain or digital asset to rule all. Those that think there will be one dominant network or cryptocurrency will fall by the wayside.

    In 2018 and beyond, the name of the game will be interoperability.

    Ripple CTO Stefan Thomas also offered his thoughts on where the space is headed next year, read about here.



  • Ripple - Listing XRP as an Exchange -  Guide

    This document describes the steps that an exchange needs to take to list XRP. For details about other aspects of rippled and the XRP Ledger, see the Ripple Developer Center

    Alpha Exchange

    For illustrative purposes, this document uses a fictitious business called Alpha Exchange to explain the high-level steps required to list XRP. For the purposes of this document, Alpha Exchange:

    • Currently specializes in listing BTC/USD

    • Wants to add BTC/XRP and XRP/USD trading pairs

    • Maintains balances for all of its customers

    • Maintains balances for each of its supported currencies

    User Benefits

    • Deposit XRP to Alpha Exchange from the XRP Ledger

    • Withdraw XRP from Alpha Exchange to the XRP Ledger

    • Trade XRP with other currencies, such as BTC, USD, among others

    Prerequisites for Supporting XRP

    To support XRP, Alpha Exchange must:

    See also:

    Partial Payments

    Before integrating, exchanges should be aware of the partial payments feature. This feature allows XRP Ledger users to send successful payments that reduce the amount received instead of increasing the SendMax. This feature can be useful for returning payments without incurring additional cost as the sender.

    Partial Payments Warning

    When the tfPartialPayment flag is enabled, the Amount field is not guaranteed to be the amount received. The delivered_amount field of a payment's metadata indicates the amount of currency actually received by the destination account. When receiving a payment, use delivered_amount instead of the Amount field to determine how much your account received instead.

    Warning: Be aware that malicious actors could exploit this. For more information, see Partial Payments.

    Accounts

    XRP is held in accounts (also referred to as wallets or addresses ) on the XRP Ledger. Accounts on the XRP Ledger are different than accounts on other blockchain ledgers, such as Bitcoin, where accounts incur little to no overhead. In the XRP Ledger, accounts can never be deleted, and each account must hold a separate reserve of XRP that cannot be sent to others. For these reasons, Ripple recommends that institutions not create excessive or needless accounts.

    To follow Ripple's recommended best practices, Alpha Exchange should create at least two new accounts on the XRP Ledger. To minimize the risks associated with a compromised secret key, Ripple recommends creating cold, hot, and warm accounts (these are sometimes referred to, respectively, as cold, hot, and warm wallets). The hot/warm/cold model is intended to balance security and convenience. Exchanges listing XRP should create the following accounts:

    • A cold wallet to securely hold the majority of XRP and customers' funds. For exchanges, this is also the address to which its users send deposits. To provide optimal security, this account's secret key should be offline.

      If a malicious actor compromises an exchange's cold wallet, the possible consequences are:

      • The malicious actor gets full access to all XRP in the cold wallet.

      • If the master key is compromised, the malicious actor can irrevocably take control of the cold wallet forever (by disabling the master key and setting a new regular key or signer list). This would also give the malicious actor control over all future XRP received by the cold wallet.

        • If this happens, the exchange has to make a new cold wallet address and tell its customers the new address.
      • If the regular key or signer list are comromised, the exchange can regain control of the cold wallet. However, some of a malicious actor's actions cannot easily be undone:

        • The malicious actor could issue currency in the XRP Ledger by using the cold wallet, but that currency should not be valued by anyone (unless the exchange explicitly stated it was also a gateway).

        • If a malicious actor sets the asfRequireAuth flag for the account, that cannot be unset, although this only relates to issuing currency and should not affect an exchange that is not also a gateway. Any other settings a malicious actor sets or unsets with a master key can be reverted.

    • One or more hot wallets to conduct the day-to-day business of managing customers' XRP withdrawals and deposits. For example, with a hot wallet, exchanges can securely support these types of automated XRP transfers. Hot wallets need to be online to service instant withdrawal requests.

      For more information about the possible consequences of a compromised hot wallet, see Operational Account Compromise.

    • Optionally, one or more warm wallets to provide an additional layer of security between the cold and hot wallets. Unlike a hot wallet, the secret key of a warm wallet does not need to be online. Additionally, you can distribute the secret keys for the warm wallet to several different people and implement multisigning to increase security.

      For more information about the possible consequences of a compromised warm wallet, see Standby Account Compromise.

    See also:

    Balance Sheets

    To custody its ccustomers' XRP, Alpha Exchange must track each customer's XRP balance and its own holdings. To do this, Alpha Exchange must create and maintain an additional balance sheet or accounting system. The following table illustrates what this balance sheet might look like.

    The new XRP Ledger accounts (Alpha Hot, Alpha Warm, Alpha Cold) are in the User column of the XRP Balances on XRP Ledger table.

    The Alpha Exchange XRP Balances table represents new, additional balance sheet. Alpha Exchange’s software manages their users’ balances of XRP on this accounting system.


    XRP Amounts

    Amounts of XRP are represented on the XRP Ledger as an unsigned integer count of drops, where one XRP is 1,000,000 drops. Ripple recommends that software store XRP balances as integer amounts of drops, and perform integer arithmetic on these values. However, user interfaces should present balances in units of XRP.

    One drop (.000001 XRP) cannot be further subdivided. Keep this in mind when calculating and displaying FX rates between XRP and other assets.

    For more information, see Specifying Currency Amounts.

    On-Ledger and Off-Ledger

    With exchanges like Alpha Exchange, XRP can be "on-ledger" or "off-ledger":

    • On-Ledger XRP: XRP that can be queried through the public XRP Ledger by specifying the public address of the XRP holder. The counterparty to these balances is the XRP Ledger. For more information, see Currencies.

    • Off-Ledger XRP: XRP that is held by the accounting system of an exchange and can be queried through the exchange interface. Off-ledger XRP balances are credit-based. The counterparty is the exchange holding the XRP.

      Off-ledger XRP balances are traded between the participants of an exchange. To support these trades, the exchange must hold a balance of on-ledger XRP equal to the aggregate amount of off-ledger XRP that it makes available for trade.

    Flow of Funds

    The remaining sections describe how funds flow through the accounts managed by Alpha Exchange as its users begin to deposit, trade, and redeem XRP balances. To illustrate the flow of funds, this document uses the tables introduced in the "Balance Sheets" section.

    There are four main steps involved in an exchange's typical flow of funds:

    1. Deposit XRP into Exchange

    2. Rebalance XRP Holdings

    3. Withdraw XRP from Exchange

    4. Trade XRP on the Exchange

    This list does not include the prerequisites required of an exchange.

    At this point, Alpha Exchange has created hot, warm, and cold wallets on the XRP Ledger and added them to its balance sheet, but has not accepted any deposits from its users.


    Deposit XRP into Exchange

    To track off-ledger XRP balances, exchanges need to create new balance sheets (or similar accounting systems). The following table illustrates the balance changes that take place on Alpha Exchange's new balance sheet as users begin to deposit XRP.

    A user named Charlie wants to deposit 50,000 XRP to Alpha Exchange. Doing this involves the following steps:

    1. Charlie submits a payment of 50,000 XRP (by using RippleAPI or similar software) to Alpha Exchange's cold wallet.

      a. Charlie adds an identifier (in this case, 789) to the payment to associate it with his account at Alpha Exchange. This is called a destination tag. (To use this, Alpha Exchange should have set the asfRequireDest flag on all of its accounts to require all incoming payments to have a destination tag like Charlie's. For more information, see AccountSet Flags).

    2. The software at Alpha Exchange detects the incoming payment, and recognizes 789 as the destination tag for Charlie’s account.

    3. When it detects the incoming payment, Alpha Exchange's software updates its balance sheet to indicate that the 50,000 XRP it received is controlled by Charlie.

      Charlie can now use up to 50,000 XRP on the exchange. For example, he can create offers to trade XRP with BTC or any of the other currencies Alpha Exchange supports.


    Trade XRP on the Exchange

    Alpha Exchange users (like Charlie) can trade credit-based balances on Alpha Exchange. Alpha Exchange should keep track of user balances on its new balance sheet as these trades are made. These trades are off-ledger and independent from the XRP Ledger, so the balance changes are not recorded on the XRP Ledger.

    Customers who hold XRP in their own XRP Ledger accounts can also use the distributed exchange built into the XRP Ledger to trade currencies issued by gateways. For more information about trading on the XRP Ledger, see Lifecycle of an Offer.

    Rebalance XRP Holdings

    Exchanges can adjust the balances between their hot and cold wallets at any time. Each balance adjustment consumes a transaction cost, but does not otherwise affect the aggregate balance of all the accounts. The aggregate, on-ledger balance should always exceed the total balance available for trade on the exchange. (The excess should be enough to cover the XRP Ledger's transaction costs.)

    The following table demonstrates a balance adjustment of 80,000 XRP (via a payment on the XRP Ledger) between Alpha Exchange's cold wallet and its hot wallet, where the cold wallet was debited and the hot wallet was credited. If the payment were reversed (debiting the hot wallet and crediting the cold wallet), the hot wallet balance would decrease. Balance adjustments like these allow an exchange to limit the risks associated with holding XRP in online hot wallets.


    Withdraw XRP from Exchange

    Withdrawals allow an exchange's users to move XRP from the exchange's off-ledger balance sheet to an account on the XRP Ledger.

    In this example, Charlie withdraws 25,000 XRP from Alpha Exchange. This involves the following steps:

    1. Charlie initiates the process on Alpha Exchange’s website. He provides instructions to transfer 25,000 XRP to a specific account on the XRP Ledger (named "Charlie XRP Ledger" in the following table).

    2. In response to Charlie’s instructions, Alpha Exchange does the following:

      a. Debits the amount (25,000 XRP) from Charlie’s account on its off-ledger balance sheet

      b. Submits a payment on the XRP Ledger for the same amount (25,000 XRP), from Alpha Exchange's hot wallet to Charlie’s XRP Ledger account





  • Ripple (XRP) Release rippled Wallet v 0.81.0

    set verson 0.81.0

    Download:

    https://github.com/ripple/ripp...



  • Ripple (XRP) - Who Really Cares About Real-time Payments?


    Behind the daily shouts about the market value of cryptocurrencies, there are quiet murmurs about another revolution in the making — real-time, domestic payment systems.

    Australia is set to launch their domestic New Payments Platform (NPP) in early 2018. Offering always-on, “near real-time” payments, consumer-friendly aliases (e.g. email, smartphone number) rather than bank account numbers and richer payment data, NPP holds great promise for consumers and businesses alike.

    Driven by the Reserve Bank of Australia after a strategic review in 2012, this has been a multi-million dollar investment in industry infrastructure over five years.

    Australia joins the ranks of the Korea (CD/ATM), UK (Faster Payments), Mexico (SPEI),Singapore (FAST/G3), the early adopters of so-called “Immediate Payments” domestic payment platforms. The US is not far behind: The US Federal Reserve established a “Faster Payments” Task Force in 2015 to engage with industry and drive adoption by 2020.

    The move to a real-time experience was driven by the proliferation of smartphones and their ability to access information immediately. Today, consumers want the same real-time experience from payment services — especially when buying online or sending payments to friends and family.

    Businesses and even large corporates, it would appear, want the same functionality and performance.

    “The provision of real-time cash positions, scenario-based forecasting and direct integration with client systems are top priorities for corporate treasurers,” according to an Ovum report quoted by Forbes.

    What’s more, the Bank for International Settlements said in a November 2016 report that “fast payments are of strategic importance for the long-run modernization of the payment system.”

    The so-called “Immediate Payments” is now a must-have national capability.

    But who can afford Immediate Payments?

    Even though there is an interest in moving to a faster experience, there seem to be a few hurdles along the way. Many central banks have examined their own national payments infrastructure and have found a hodge-podge of systems, built as silos for each popular method of payment: a silo for cheques, a silo for credit cards, a silo for low-value bank account payments, and a silo for high-value bank account payments.

    Each silo has its own messaging format, operational and “scheme” rules, governance and licensed participants — banks as well as non-bank financial institutions — with equally dated integrations into the participants’ applications.

    The new implementations in the UK, Singapore and Australia have not tried to undo the silos. Instead, they have built a new silo — new frontend services, new messaging (ISO 20022 being the current favorite), user-friendly aliasing to replace tedious bank account numbers for routing payments and finally, a new high-volume, real-time settlement system built and operated by the central bank.

    The cost? Tens of millions of dollars, borne by the entire industry, but mainly the commercial banks.The elapsed time from concept to launch — 3-5 years.

    For many countries, Immediate Payments may seem to be a distant goal. Yet, emerging markets need to remove payments friction both domestically and across borders today to spur global trade and rev up their economies. Ripple can help.

    Enter Ripple, stage left Since Ripple’s inception in 2012 — a new kid on the “blockchain” with a superior Distributed Ledger Technology — our focus has been to solve cross-border clearing and settlement between financial institutions.

    In fact Ripple’s product, xCurrent, enables banks to conduct coordinated “atomic” transactions across our ledgers, privately and with certainty and scalability. Many banks now conduct cross-border payments in “production” mode for real customers, on a 24/7 basis.

    xCurrent can also be deployed between banks for a domestic, single currency use case as a lightweight Immediate Payments infrastructure, with the support and participation of the central bank.

    Ripple offers cost-effective building blocks for a national payments scheme. Central banks and domestic commercial banks can architect a payments scheme that offer “overlay” payment services. Common scheme components, such as a user-friendly “aliasing” application can be built or bought in. Ripple also provides messaging translators to simplify integration into legacy bank applications. By leveraging the native cross-border capabilities of xCurrent, regional payment networks can be quickly established as well. For the first time, countries can build a clearing and settlement infrastructure that can be shared across domestic and cross-border payment services, with a distributed architecture mitigating systemic risks.

    Ripple invites any central bank to work with us on a beta trial of an Immediate Payments solution over a three- to six-month innovation project with a small number of their domestic banks. This will enable us to assess any gaps and steer a clear path to a commercial solution.

    Again quoting the BIS report, “Central banks, in particular, may contribute to the development and implementation of fast payments in their traditional roles as catalysts for change, as well as operators and overseers of payment systems, to the extent that fast payments contribute to meeting these public policy objectives.”

    The future is already here and can be more evenly distributed as well!



  • MoneyGram to Use Ripple (XRP) for Faster International Payments


    The global remittance market is a big business. In 2016, remitters sent nearly $600 billion in cross-border payments to help support family members living in their home countries or to settle transactions with business partners.

    Money transfer companies allow people to send cross-border payments. Unfortunately, the current model requires money transfer companies to use pre-funded accounts across the globe to source liquidity for these payments. The process makes payments costly and slow, which causes headaches for both the companies and their customers.

    To allow their customers to send and complete cross-border payments quicker and cheaper, MoneyGram — one of the world’s largest money transfer companies — will use XRP in their payment flows.

    The use of XRP allows MoneyGram to solve the age-old liquidity issue most financial institutions face while saving time and money. Additionally, customers will have the ability to send funds real time, with transparency and certainty.

    XRP, xRapid help source on-demand liquidity

    MoneyGram will access and use XRP, the native digital asset of the XRP Ledger, in their payment flows through xRapid, Ripple’s on-demand liquidity product.

    Here’s how it works: xRapid enables real-time foreign exchange (FX) settlement through XRP, which gives financial institutions the ability to unlock liquidity and access multiple corridors with one pre-funded originating account.

    What’s more, financial institutions will be able to send on-demand payments, reduce FX costs and fees, and customers will receive real-time insight into the status of their payments.

    “Ripple is at the forefront of blockchain technology and we look forward to piloting xRapid,” said Alex Holmes, chief executive officer of MoneyGram, in a press release. “We’re hopeful it will increase efficiency and improve services to MoneyGram’s customers.”

    Ripple strives to improve cross-border payments

    Ripple is focused on fixing the inefficiencies and problems that exist in cross-border payments, regardless of whether those payments originate with a bank, corporate or another financial institution.

    “The payments problem doesn’t just affect banks, it also affects companies like MoneyGram, which help people get money to the ones they care about,” said Brad Garlinghouse, CEO of Ripple. “By using a digital asset like XRP that settles in three seconds or less, our clients can move money as quickly as information.”

    For more information about xRapid, visit Ripple’s Solutions page.



  • Ripple (XRP)  How to Multi-Sign

    Multi-signing is one of three ways to authorize transactions for the XRP Ledger, alongside signing with regular keys and master keys. You can configure your address to allow any combination of the three methods to authorize transactions.

    Benefits of multi-signing include:

    • You can require keys from different devices, so that a malicious actor must compromise multiple machines to send transactions on your behalf.
    • You can share custody of an address between multiple people, each of whom only has one of several keys necessary to send transactions from that address.
    • You can delegate the power to send transactions from your address to a group of people, who can control your address if you are unavailable or unable to sign normally.
    • ... and more.

    To use multi-signing:

    1. The XRP Ledger peer-to-peer network must have multi-signing enabled.
    2. Set up a list of signers on your account.
    3. Send transactions using multiple signatures.

    Availability of Multi-Signing

    How to Multi-Sign

    Multi-signing is one of three ways to authorize transactions for the XRP Ledger, alongside signing with regular keys and master keys. You can configure your address to allow any combination of the three methods to authorize transactions.

    Benefits of multi-signing include:

    • You can require keys from different devices, so that a malicious actor must compromise multiple machines to send transactions on your behalf.
    • You can share custody of an address between multiple people, each of whom only has one of several keys necessary to send transactions from that address.
    • You can delegate the power to send transactions from your address to a group of people, who can control your address if you are unavailable or unable to sign normally.
    • ... and more.

    To use multi-signing:

    1. The XRP Ledger peer-to-peer network must have multi-signing enabled.Set up a list of signers on your account.
    2. Send transactions using multiple signatures.

    Availability of Multi-Signing

    Multi-signing has been enabled by an rippled with a fresh ledger in stand-alone modefeature command.

    To force the multi-signing feature to be enabled, add the following stanza to your rippled.cfg:

    [features]
    MultiSign
     

    Setting up Multi-Signing

    To multi-sign transactions from a particular address, you must create a list of addresses that can contribute to a multi-signature for your address. This list is stored in the XRP Ledger as a SignerList node. The following procedure demonstrates how to set up a SignerList for your address:

    1. Prepare a funded address

    You need an XRP Ledger address that can send transactions, and has enough XRP available. Multi-signing requires more than the usual amount of XRP for the account reserve and transaction cost, increasing with the number of signers and signatures you use.

    If you started rippled in stand-alone mode with a new genesis ledger, you must:

    1. Generate keys for a new address, or reuse keys you already have.
    2. Submit a Payment transaction to fund the new address from the genesis account. (Send at least 100,000,000 drops of XRP.)
    3. Manually close the ledger.

    2. Prepare member keys

    You need several sets of XRP Ledger keys (address and secret) to include as members of your SignerList. These can be funded addresses that exist in the ledger, or you can generate new addresses using the wallet_propose command. For example:

    $ rippled wallet_propose
    Loading: "/home/mduo13/.config/ripple/rippled.cfg"
    Connecting to 127.0.0.1:5005
    {
        "result" : {
            "account_id" : "rnRJ4dpSBKDR2M1itf4Ah6tZZm5xuNZFPH",
            "key_type" : "secp256k1",
            "master_key" : "FLOG SEND GOES CUFF GAGE FAT ANTI DEL GUM TIRE ISLE BEAR",
            "master_seed" : "snheH5UUjU4CWqiNVLny2k21TyKPC",
            "master_seed_hex" : "A9F859765EB8614D26809836382AFB82",
            "public_key" : "aBR4hxFXcDNHnGYvTiqb2KU8TTTV1cYV9wXTAuz2DjBm7S8TYEBU",
            "public_key_hex" : "03C09A5D112B393D531E4F092E3A5769A5752129F0A9C55C61B3A226BB9B567B9B",
            "status" : "success"
        }
    }

    Take note of the account_id (XRP Ledger Address) and master_seed (secret key) for each one you generate.

    3. Send SignerListSet transaction

    Sign and submit a SignerListSet transaction in the normal (single-signature) way. This associates a SignerList with your XRP Ledger address, so that a combination of signatures from the members of that SignerList can multi-sign later transactions on your behalf.

    In this example, the SignerList has 3 members, with the weights and quorum set up such that multi-signed transactions need a signature from rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW plus at least one signature from the other two members of the list.

    Caution: Never submit a secret key to a server you do not control. Do not send a secret key unencrypted over the network.

    $ rippled submit shqZZy2Rzs9ZqWTCQAdqc3bKgxnYq '{
    >     "Flags": 0,
    >     "TransactionType": "SignerListSet",
    >     "Account": "rnBFvgZphmN39GWzUJeUitaP22Fr9be75H",
    >     "Fee": "10000",
    >     "SignerQuorum": 3,
    >     "SignerEntries": [
    >         {
    >             "SignerEntry": {
    >                 "Account": "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW",
    >                 "SignerWeight": 2
    >             }
    >         },
    >         {
    >             "SignerEntry": {
    >                 "Account": "rUpy3eEg8rqjqfUoLeBnZkscbKbFsKXC3v",
    >                 "SignerWeight": 1
    >             }
    >         },
    >         {
    >             "SignerEntry": {
    >                 "Account": "raKEEVSGnKSD9Zyvxu4z6Pqpm4ABH8FS6n",
    >                 "SignerWeight": 1
    >             }
    >         }
    >     ]
    > }'
    Loading: "/home/mduo13/.config/ripple/rippled.cfg"
    Connecting to 127.0.0.1:5005
    {
       "result" : {
          "engine_result" : "tesSUCCESS",
          "engine_result_code" : 0,
          "engine_result_message" : "The transaction was applied. Only final in a validated ledger.",
          "status" : "success",
          "tx_blob" : "12000C2200000000240000000120230000000368400000000000271073210303E20EC6B4A39A629815AE02C0A1393B9225E3B890CAE45B59F42FA29BE9668D74473045022100BEDFA12502C66DDCB64521972E5356F4DB965F553853D53D4C69B4897F11B4780220595202D1E080345B65BAF8EBD6CA161C227F1B62C7E72EA5CA282B9434A6F04281142DECAB42CA805119A9BA2FF305C9AFA12F0B86A1F4EB1300028114204288D2E47F8EF6C99BCC457966320D12409711E1EB13000181147908A7F0EDD48EA896C3580A399F0EE78611C8E3E1EB13000181143A4C02EA95AD6AC3BED92FA036E0BBFB712C030CE1F1",
          "tx_json" : {
             "Account" : "rnBFvgZphmN39GWzUJeUitaP22Fr9be75H",
             "Fee" : "10000",
             "Flags" : 0,
             "Sequence" : 1,
             "SignerEntries" : [
                {
                   "SignerEntry" : {
                      "Account" : "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW",
                      "SignerWeight" : 2
                   }
                },
                {
                   "SignerEntry" : {
                      "Account" : "rUpy3eEg8rqjqfUoLeBnZkscbKbFsKXC3v",
                      "SignerWeight" : 1
                   }
                },
                {
                   "SignerEntry" : {
                      "Account" : "raKEEVSGnKSD9Zyvxu4z6Pqpm4ABH8FS6n",
                      "SignerWeight" : 1
                   }
                }
             ],
             "SignerQuorum" : 3,
             "SigningPubKey" : "0303E20EC6B4A39A629815AE02C0A1393B9225E3B890CAE45B59F42FA29BE9668D",
             "TransactionType" : "SignerListSet",
             "TxnSignature" : "3045022100BEDFA12502C66DDCB64521972E5356F4DB965F553853D53D4C69B4897F11B4780220595202D1E080345B65BAF8EBD6CA161C227F1B62C7E72EA5CA282B9434A6F042",
             "hash" : "3950D98AD20DA52EBB1F3937EF32F382D74092A4C8DF9A0B1A06ED25200B5756"
          }
       }
    }

    Make sure that the Transaction Result is tesSUCCESS. Otherwise, the transaction failed. If you have a problem in stand-alone mode or a non-production network, check that multi-sign is enabled.

    Note: The more members in the SignerList, the more XRP your address must have for purposes of the owner reserve. If your address does not have enough XRP, the transaction fails with tecINSUFFICIENT_RESERVE. See also: SignerLists and Reserve

    How to Multi-Sign

    Multi-signing is one of three ways to authorize transactions for the XRP Ledger, alongside signing with regular keys and master keys. You can configure your address to allow any combination of the three methods to authorize transactions.

    Benefits of multi-signing include:

    • You can require keys from different devices, so that a malicious actor must compromise multiple machines to send transactions on your behalf.
    • You can share custody of an address between multiple people, each of whom only has one of several keys necessary to send transactions from that address.
    • You can delegate the power to send transactions from your address to a group of people, who can control your address if you are unavailable or unable to sign normally.
    • ... and more.

    To use multi-signing:

    1. The XRP Ledger peer-to-peer network must have multi-signing enabled.Set up a list of signers on your account.
    2. Send transactions using multiple signatures.

    Availability of Multi-Signing

    Multi-signing has been enabled by an rippled with a fresh ledger in stand-alone modefeature command.

    To force the multi-signing feature to be enabled, add the following stanza to your rippled.cfg:

    [features]
    MultiSign
     
    

    Setting up Multi-Signing

    To multi-sign transactions from a particular address, you must create a list of addresses that can contribute to a multi-signature for your address. This list is stored in the XRP Ledger as a SignerList node. The following procedure demonstrates how to set up a SignerList for your address:

    1. Prepare a funded address

    You need an XRP Ledger address that can send transactions, and has enough XRP available. Multi-signing requires more than the usual amount of XRP for the account reservetransaction cost, increasing with the number of signers and signatures you use.

    If you started rippled in stand-alone mode with a new genesis ledger, you must:

    1. Generate keys for a new address, or reuse keys you already have.
    2. Submit a Payment transaction to fund the new address from the genesis account. (Send at least 100,000,000 drops of XRP.)
    3. Manually close the ledger.

    2. Prepare member keys

    You need several sets of XRP Ledger keys (address and secret) to include as members of your SignerList. These can be funded addresses that exist in the ledger, or you can generate new addresses using the

    $ rippled wallet_propose
    Loading: "/home/mduo13/.config/ripple/rippled.cfg"
    Connecting to 127.0.0.1:5005
    {
        "result" : {
            "account_id" : "rnRJ4dpSBKDR2M1itf4Ah6tZZm5xuNZFPH",
            "key_type" : "secp256k1",
            "master_key" : "FLOG SEND GOES CUFF GAGE FAT ANTI DEL GUM TIRE ISLE BEAR",
            "master_seed" : "snheH5UUjU4CWqiNVLny2k21TyKPC",
            "master_seed_hex" : "A9F859765EB8614D26809836382AFB82",
            "public_key" : "aBR4hxFXcDNHnGYvTiqb2KU8TTTV1cYV9wXTAuz2DjBm7S8TYEBU",
            "public_key_hex" : "03C09A5D112B393D531E4F092E3A5769A5752129F0A9C55C61B3A226BB9B567B9B",
            "status" : "success"
        }
    }
     
    

    Take note of the account_id (XRP Ledger Address) and master_seed (secret key) for each one you generate.

    3. Send SignerListSet transaction


    Sign and submitSignerListSet transaction in the normal (single-signature) way. This associates a SignerList with your XRP Ledger address, so that a combination of signatures from the members of that SignerList can multi-sign later transactions on your behalf.

    In this example, the SignerList has 3 members, with the weights and quorum set up such that multi-signed transactions need a signature from rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW plus at least one signature from the other two members of the list.

    Caution: Never submit a secret key to a server you do not control. Do not send a secret key unencrypted over the network.

    $ rippled submit shqZZy2Rzs9ZqWTCQAdqc3bKgxnYq '{
    >     "Flags": 0,
    >     "TransactionType": "SignerListSet",
    >     "Account": "rnBFvgZphmN39GWzUJeUitaP22Fr9be75H",
    >     "Fee": "10000",
    >     "SignerQuorum": 3,
    >     "SignerEntries": [
    >         {
    >             "SignerEntry": {
    >                 "Account": "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW",
    >                 "SignerWeight": 2
    >             }
    >         },
    >         {
    >             "SignerEntry": {
    >                 "Account": "rUpy3eEg8rqjqfUoLeBnZkscbKbFsKXC3v",
    >                 "SignerWeight": 1
    >             }
    >         },
    >         {
    >             "SignerEntry": {
    >                 "Account": "raKEEVSGnKSD9Zyvxu4z6Pqpm4ABH8FS6n",
    >                 "SignerWeight": 1
    >             }
    >         }
    >     ]
    > }'
    Loading: "/home/mduo13/.config/ripple/rippled.cfg"
    Connecting to 127.0.0.1:5005
    {
       "result" : {
          "engine_result" : "tesSUCCESS",
          "engine_result_code" : 0,
          "engine_result_message" : "The transaction was applied. Only final in a validated ledger.",
          "status" : "success",
          "tx_blob" : "12000C2200000000240000000120230000000368400000000000271073210303E20EC6B4A39A629815AE02C0A1393B9225E3B890CAE45B59F42FA29BE9668D74473045022100BEDFA12502C66DDCB64521972E5356F4DB965F553853D53D4C69B4897F11B4780220595202D1E080345B65BAF8EBD6CA161C227F1B62C7E72EA5CA282B9434A6F04281142DECAB42CA805119A9BA2FF305C9AFA12F0B86A1F4EB1300028114204288D2E47F8EF6C99BCC457966320D12409711E1EB13000181147908A7F0EDD48EA896C3580A399F0EE78611C8E3E1EB13000181143A4C02EA95AD6AC3BED92FA036E0BBFB712C030CE1F1",
          "tx_json" : {
             "Account" : "rnBFvgZphmN39GWzUJeUitaP22Fr9be75H",
             "Fee" : "10000",
             "Flags" : 0,
             "Sequence" : 1,
             "SignerEntries" : [
                {
                   "SignerEntry" : {
                      "Account" : "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW",
                      "SignerWeight" : 2
                   }
                },
                {
                   "SignerEntry" : {
                      "Account" : "rUpy3eEg8rqjqfUoLeBnZkscbKbFsKXC3v",
                      "SignerWeight" : 1
                   }
                },
                {
                   "SignerEntry" : {
                      "Account" : "raKEEVSGnKSD9Zyvxu4z6Pqpm4ABH8FS6n",
                      "SignerWeight" : 1
                   }
                }
             ],
             "SignerQuorum" : 3,
             "SigningPubKey" : "0303E20EC6B4A39A629815AE02C0A1393B9225E3B890CAE45B59F42FA29BE9668D",
             "TransactionType" : "SignerListSet",
             "TxnSignature" : "3045022100BEDFA12502C66DDCB64521972E5356F4DB965F553853D53D4C69B4897F11B4780220595202D1E080345B65BAF8EBD6CA161C227F1B62C7E72EA5CA282B9434A6F042",
             "hash" : "3950D98AD20DA52EBB1F3937EF32F382D74092A4C8DF9A0B1A06ED25200B5756"
          }
       }
    }
     
    

    Make sure that the Transaction ResulttesSUCCESS. Otherwise, the transaction failed. If you have a problem in stand-alone mode or a non-production network, check that multi-sign is enabled.

    Note: The more members in the SignerList, the more XRP your address must have for purposes of the owner reservetecINSUFFICIENT_RESERVE. See also: SignerLists and Reserves.

    4. Close the ledger

    On the live network, you can wait 4-7 seconds for the ledger to close automatically.

    If you're running rippled in stand-alone mode, use the $ rippled ledger_accept Loading: "/home/mduo13/.config/ripple/rippled.cfg" Connecting to 127.0.0.1:5005 { "result" : { "ledger_current_index" : 6, "status" : "success" } }

    5. Confirm the new signer list

    Use the account_objects command to confirm that the SignerList is associated with the address in the latest validated ledger.

    Normally, an account can own many objects of different types (such as trust lines and offers). If you funded a new address for this tutorial, the SignerList is the only object in the response.

    $ rippled account_objects rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC validated
    Loading: "/home/mduo13/.config/ripple/rippled.cfg"
    Connecting to 127.0.0.1:5005
    {
       "result" : {
          "account" : "rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC",
          "account_objects" : [
             {
                "Flags" : 0,
                "LedgerEntryType" : "SignerList",
                "OwnerNode" : "0000000000000000",
                "PreviousTxnID" : "8FDC18960455C196A8C4DE0D24799209A21F4A17E32102B5162BD79466B90222",
                "PreviousTxnLgrSeq" : 5,
                "SignerEntries" : [
                   {
                      "SignerEntry" : {
                         "Account" : "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW",
                         "SignerWeight" : 2
                      }
                   },
                   {
                      "SignerEntry" : {
                         "Account" : "raKEEVSGnKSD9Zyvxu4z6Pqpm4ABH8FS6n",
                         "SignerWeight" : 1
                      }
                   },
                   {
                      "SignerEntry" : {
                         "Account" : "rUpy3eEg8rqjqfUoLeBnZkscbKbFsKXC3v",
                         "SignerWeight" : 1
                      }
                   }
                ],
                "SignerListID" : 0,
                "SignerQuorum" : 3,
                "index" : "79FD203E4DDDF2EA78B798C963487120C048C78652A28682425E47C96D016F92"
             }
          ],
          "ledger_hash" : "56E81069F06492FB410A70218C08169BE3AB3CFD5AEA20E999662D81DC361D9F",
          "ledger_index" : 5,
          "status" : "success",
          "validated" : true
       }
    }

    If the SignerList is present with the expected contents, then your address is ready to multi-sign.

    6. Further steps

    At this point, your address is ready to send a multi-signed transaction. You may also want to:

    Sending a Multi-Signed Transaction

    Before you can multi-sign a transaction, first set up multi-signing for your address. The following procedure demonstrates how to create, sign, and submit a multi-signed transaction.

    1. Create the transaction

    Create a JSON object that represents the transaction you want to submit. You have to specify everything about this transaction, including Fee and Sequence. Also include the field SigningPubKey as an empty string, to indicate that the transaction is multi-signed.

    Keep in mind that the Fee for multi-signed transactions is significantly higher than for regularly-signed transactions. It should be at least (N+1) times the normal transaction cost, where N is the number of signatures you plan to provide. Since it sometimes takes a while to collect signatures from multiple sources, you may want to specify more than the current minimum, in case the transaction cost increases in that time.

    Here's an example transaction ready to be multi-signed:

    {
        "TransactionType": "TrustSet",
        "Account": "rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC",
        "Flags": 262144,
        "LimitAmount": {
            "currency": "USD",
            "issuer": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
            "value": "100"
        },
        "Sequence": 2,
        "SigningPubKey": "",
        "Fee": "30000"
    }

    (This transaction creates an accounting relationship from rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC to rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh with a maximum balance of 100 USD.)

    2. Get one signature

    Use the sign_for command with the secret key and address of one of the members of your SignerList to get a signature for that member.

    Caution: Never submit a secret key to a server you do not control. Do not send a secret key unencrypted over the network.

    $ rippled sign_for rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW <rsA2L..'s secret> '{
    >     "TransactionType": "TrustSet",
    >     "Account": "rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC",
    >     "Flags": 262144,
    >     "LimitAmount": {
    >         "currency": "USD",
    >         "issuer": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
    >         "value": "100"
    >     },
    >     "Sequence": 2,
    >     "SigningPubKey": "",
    >     "Fee": "30000"
    > }'
    Loading: "/home/mduo13/.config/ripple/rippled.cfg"
    Connecting to 127.0.0.1:5005
    {
       "result" : {
          "status" : "success",
          "tx_blob" : "1200142200040000240000000263D5038D7EA4C680000000000000000000000000005553440000000000B5F762798A53D543A014CAF8B297CFF8F2F937E868400000000000753073008114A3780F5CB5A44D366520FC44055E8ED44D9A2270F3E010732102B3EC4E5DD96029A647CFA20DA07FE1F85296505552CCAC114087E66B46BD77DF744730450221009C195DBBF7967E223D8626CA19CF02073667F2B22E206727BFE848FF42BEAC8A022048C323B0BED19A988BDBEFA974B6DE8AA9DCAE250AA82BBD1221787032A864E58114204288D2E47F8EF6C99BCC457966320D12409711E1F1",
          "tx_json" : {
             "Account" : "rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC",
             "Fee" : "30000",
             "Flags" : 262144,
             "LimitAmount" : {
                "currency" : "USD",
                "issuer" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
                "value" : "100"
             },
             "Sequence" : 2,
             "Signers" : [
                {
                   "Signer" : {
                      "Account" : "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW",
                      "SigningPubKey" : "02B3EC4E5DD96029A647CFA20DA07FE1F85296505552CCAC114087E66B46BD77DF",
                      "TxnSignature" : "30450221009C195DBBF7967E223D8626CA19CF02073667F2B22E206727BFE848FF42BEAC8A022048C323B0BED19A988BDBEFA974B6DE8AA9DCAE250AA82BBD1221787032A864E5"
                   }
                }
             ],
             "SigningPubKey" : "",
             "TransactionType" : "TrustSet",
             "hash" : "A94A6417D1A7AAB059822B894E13D322ED3712F7212CE9257801F96DE6C3F6AE"
          }
       }
    }

    Save the tx_json field of the response: it has the new signature in the Signers field. You can discard the value of the tx_blob field.

    If you have a problem in stand-alone mode or a non-production network, check that multi-sign is enabled.

    3. Get additional signatures

    You can collect additional signatures in parallel or in serial:

    • In parallel: Use the sign_for command with the original JSON for the transaction. Each response has a single signature in the Signers array.
    • In serial: Use the sign_for command with the tx_json value from the previous sign_for response. Each response adds a new signature to the existing Signers array.

    Caution: Never submit a secret key to a server you do not control. Do not send a secret key unencrypted over the network.

    $ rippled sign_for rUpy3eEg8rqjqfUoLeBnZkscbKbFsKXC3v <rUpy..'s secret> '{
    >    "Account" : "rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC",
    >    "Fee" : "30000",
    >    "Flags" : 262144,
    >    "LimitAmount" : {
    >       "currency" : "USD",
    >       "issuer" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
    >       "value" : "100"
    >    },
    >    "Sequence" : 2,
    >    "Signers" : [
    >       {
    >          "Signer" : {
    >             "Account" : "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW",
    >             "SigningPubKey" : "02B3EC4E5DD96029A647CFA20DA07FE1F85296505552CCAC114087E66B46BD77DF",
    >             "TxnSignature" : "30450221009C195DBBF7967E223D8626CA19CF02073667F2B22E206727BFE848FF42BEAC8A022048C323B0BED19A988BDBEFA974B6DE8AA9DCAE250AA82BBD1221787032A864E5"
    >          }
    >       }
    >    ],
    >    "SigningPubKey" : "",
    >    "TransactionType" : "TrustSet",
    >    "hash" : "A94A6417D1A7AAB059822B894E13D322ED3712F7212CE9257801F96DE6C3F6AE"
    > }'
    Loading: "/home/mduo13/.config/ripple/rippled.cfg"
    Connecting to 127.0.0.1:5005
    {
       "result" : {
          "status" : "success",
          "tx_blob" : "1200142200040000240000000263D5038D7EA4C680000000000000000000000000005553440000000000B5F762798A53D543A014CAF8B297CFF8F2F937E868400000000000753073008114A3780F5CB5A44D366520FC44055E8ED44D9A2270F3E010732102B3EC4E5DD96029A647CFA20DA07FE1F85296505552CCAC114087E66B46BD77DF744730450221009C195DBBF7967E223D8626CA19CF02073667F2B22E206727BFE848FF42BEAC8A022048C323B0BED19A988BDBEFA974B6DE8AA9DCAE250AA82BBD1221787032A864E58114204288D2E47F8EF6C99BCC457966320D12409711E1E0107321028FFB276505F9AC3F57E8D5242B386A597EF6C40A7999F37F1948636FD484E25B744630440220680BBD745004E9CFB6B13A137F505FB92298AD309071D16C7B982825188FD1AE022004200B1F7E4A6A84BB0E4FC09E1E3BA2B66EBD32F0E6D121A34BA3B04AD99BC181147908A7F0EDD48EA896C3580A399F0EE78611C8E3E1F1",
          "tx_json" : {
             "Account" : "rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC",
             "Fee" : "30000",
             "Flags" : 262144,
             "LimitAmount" : {
                "currency" : "USD",
                "issuer" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
                "value" : "100"
             },
             "Sequence" : 2,
             "Signers" : [
                {
                   "Signer" : {
                      "Account" : "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW",
                      "SigningPubKey" : "02B3EC4E5DD96029A647CFA20DA07FE1F85296505552CCAC114087E66B46BD77DF",
                      "TxnSignature" : "30450221009C195DBBF7967E223D8626CA19CF02073667F2B22E206727BFE848FF42BEAC8A022048C323B0BED19A988BDBEFA974B6DE8AA9DCAE250AA82BBD1221787032A864E5"
                   }
                },
                {
                   "Signer" : {
                      "Account" : "rUpy3eEg8rqjqfUoLeBnZkscbKbFsKXC3v",
                      "SigningPubKey" : "028FFB276505F9AC3F57E8D5242B386A597EF6C40A7999F37F1948636FD484E25B",
                      "TxnSignature" : "30440220680BBD745004E9CFB6B13A137F505FB92298AD309071D16C7B982825188FD1AE022004200B1F7E4A6A84BB0E4FC09E1E3BA2B66EBD32F0E6D121A34BA3B04AD99BC1"
                   }
                }
             ],
             "SigningPubKey" : "",
             "TransactionType" : "TrustSet",
             "hash" : "BD636194C48FD7A100DE4C972336534C8E710FD008C0F3CF7BC5BF34DAF3C3E6"
          }
       }
    }

    Depending on the SignerList you configured, you may need to repeat this step several times to get signatures from all the necessary parties.

    4. Combine signatures and submit

    If you collected the signatures in serial, the tx_json from the last sign_for response has all the signatures assembled, so you can use that as the argument to the submit_multisigned command.

    If you collected the signatures in parallel, you must manually construct a tx_json object with all the signatures included. Take the Signers arrays from all the sign_for responses, and combine their contents into a single Signers array that has each signature. Add the combined Signers array to the original transaction JSON value, and use that as the argument to the submit_multisigned command.

    $ rippled submit_multisigned '{
    >              "Account" : "rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC",
    >              "Fee" : "30000",
    >              "Flags" : 262144,
    >              "LimitAmount" : {
    >                 "currency" : "USD",
    >                 "issuer" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
    >                 "value" : "100"
    >              },
    >              "Sequence" : 2,
    >              "Signers" : [
    >                 {
    >                    "Signer" : {
    >                       "Account" : "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW",
    >                       "SigningPubKey" : "02B3EC4E5DD96029A647CFA20DA07FE1F85296505552CCAC114087E66B46BD77DF",
    >                       "TxnSignature" : "30450221009C195DBBF7967E223D8626CA19CF02073667F2B22E206727BFE848FF42BEAC8A022048C323B0BED19A988BDBEFA974B6DE8AA9DCAE250AA82BBD1221787032A864E5"
    >                    }
    >                 },
    >                 {
    >                    "Signer" : {
    >                       "Account" : "rUpy3eEg8rqjqfUoLeBnZkscbKbFsKXC3v",
    >                       "SigningPubKey" : "028FFB276505F9AC3F57E8D5242B386A597EF6C40A7999F37F1948636FD484E25B",
    >                       "TxnSignature" : "30440220680BBD745004E9CFB6B13A137F505FB92298AD309071D16C7B982825188FD1AE022004200B1F7E4A6A84BB0E4FC09E1E3BA2B66EBD32F0E6D121A34BA3B04AD99BC1"
    >                    }
    >                 }
    >              ],
    >              "SigningPubKey" : "",
    >              "TransactionType" : "TrustSet",
    >              "hash" : "BD636194C48FD7A100DE4C972336534C8E710FD008C0F3CF7BC5BF34DAF3C3E6"
    >           }'
    Loading: "/home/mduo13/.config/ripple/rippled.cfg"
    Connecting to 127.0.0.1:5005
    {
        "result": {
            "engine_result": "tesSUCCESS",
            "engine_result_code": 0,
            "engine_result_message": "The transaction was applied. Only final in a validated ledger.",
            "status": "success",
            "tx_blob": "1200142200040000240000000263D5038D7EA4C680000000000000000000000000005553440000000000B5F762798A53D543A014CAF8B297CFF8F2F937E868400000000000753073008114A3780F5CB5A44D366520FC44055E8ED44D9A2270F3E010732102B3EC4E5DD96029A647CFA20DA07FE1F85296505552CCAC114087E66B46BD77DF744730450221009C195DBBF7967E223D8626CA19CF02073667F2B22E206727BFE848FF42BEAC8A022048C323B0BED19A988BDBEFA974B6DE8AA9DCAE250AA82BBD1221787032A864E58114204288D2E47F8EF6C99BCC457966320D12409711E1E0107321028FFB276505F9AC3F57E8D5242B386A597EF6C40A7999F37F1948636FD484E25B744630440220680BBD745004E9CFB6B13A137F505FB92298AD309071D16C7B982825188FD1AE022004200B1F7E4A6A84BB0E4FC09E1E3BA2B66EBD32F0E6D121A34BA3B04AD99BC181147908A7F0EDD48EA896C3580A399F0EE78611C8E3E1F1",
            "tx_json": {
                "Account": "rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC",
                "Fee": "30000",
                "Flags": 262144,
                "LimitAmount": {
                    "currency": "USD",
                    "issuer": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
                    "value": "100"
                },
                "Sequence": 2,
                "Signers": [{
                    "Signer": {
                        "Account": "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW",
                        "SigningPubKey": "02B3EC4E5DD96029A647CFA20DA07FE1F85296505552CCAC114087E66B46BD77DF",
                        "TxnSignature": "30450221009C195DBBF7967E223D8626CA19CF02073667F2B22E206727BFE848FF42BEAC8A022048C323B0BED19A988BDBEFA974B6DE8AA9DCAE250AA82BBD1221787032A864E5"
                    }
                }, {
                    "Signer": {
                        "Account": "rUpy3eEg8rqjqfUoLeBnZkscbKbFsKXC3v",
                        "SigningPubKey": "028FFB276505F9AC3F57E8D5242B386A597EF6C40A7999F37F1948636FD484E25B",
                        "TxnSignature": "30440220680BBD745004E9CFB6B13A137F505FB92298AD309071D16C7B982825188FD1AE022004200B1F7E4A6A84BB0E4FC09E1E3BA2B66EBD32F0E6D121A34BA3B04AD99BC1"
                    }
                }],
                "SigningPubKey": "",
                "TransactionType": "TrustSet",
                "hash": "BD636194C48FD7A100DE4C972336534C8E710FD008C0F3CF7BC5BF34DAF3C3E6"
            }
        }
    }

    Take note of the hash value from the response so you can check the results of the transaction later. (In this case, the hash is BD636194C48FD7A100DE4C972336534C8E710FD008C0F3CF7BC5BF34DAF3C3E6.)

    5. Close the ledger

    If you are using the live network, you can wait 4-7 seconds for the ledger to close automatically.

    If you're running rippled in stand-alone mode, use the ledger_accept command to manually close the ledger:

    $ rippled ledger_accept
    Loading: "/home/mduo13/.config/ripple/rippled.cfg"
    Connecting to 127.0.0.1:5005
    {
       "result" : {
          "ledger_current_index" : 7,
          "status" : "success"
       }
    }

    6. Confirm transaction results

    Use the hash value from the response to the submit_multisigned command to look up the transaction using the tx command. In particular, check that the TransactionResult is the string tesSUCCESS.

    On the live network, you must also confirm that the validated field is set to the boolean true. If the field is not true, you might need to wait longer for the consensus process to finish; or your transaction may be unable to be included in a ledger for some reason.

    In stand-alone mode, the server automatically considers a ledger to be validated if it has been manually closed.

    $ rippled tx BD636194C48FD7A100DE4C972336534C8E710FD008C0F3CF7BC5BF34DAF3C3E6
    Loading: "/home/mduo13/.config/ripple/rippled.cfg"
    Connecting to 127.0.0.1:5005
    {
        "result": {
            "Account": "rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC",
            "Fee": "30000",
            "Flags": 262144,
            "LimitAmount": {
                "currency": "USD",
                "issuer": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
                "value": "100"
            },
            "Sequence": 2,
            "Signers": [{
                "Signer": {
                    "Account": "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW",
                    "SigningPubKey": "02B3EC4E5DD96029A647CFA20DA07FE1F85296505552CCAC114087E66B46BD77DF",
                    "TxnSignature": "30450221009C195DBBF7967E223D8626CA19CF02073667F2B22E206727BFE848FF42BEAC8A022048C323B0BED19A988BDBEFA974B6DE8AA9DCAE250AA82BBD1221787032A864E5"
                }
            }, {
                "Signer": {
                    "Account": "rUpy3eEg8rqjqfUoLeBnZkscbKbFsKXC3v",
                    "SigningPubKey": "028FFB276505F9AC3F57E8D5242B386A597EF6C40A7999F37F1948636FD484E25B",
                    "TxnSignature": "30440220680BBD745004E9CFB6B13A137F505FB92298AD309071D16C7B982825188FD1AE022004200B1F7E4A6A84BB0E4FC09E1E3BA2B66EBD32F0E6D121A34BA3B04AD99BC1"
                }
            }],
            "SigningPubKey": "",
            "TransactionType": "TrustSet",
            "date": 512172510,
            "hash": "BD636194C48FD7A100DE4C972336534C8E710FD008C0F3CF7BC5BF34DAF3C3E6",
            "inLedger": 6,
            "ledger_index": 6,
            "meta": {
                "AffectedNodes": [{
                    "ModifiedNode": {
                        "LedgerEntryType": "AccountRoot",
                        "LedgerIndex": "2B6AC232AA4C4BE41BF49D2459FA4A0347E1B543A4C92FCEE0821C0201E2E9A8",
                        "PreviousTxnID": "B7E1D33DB7DEA3BB65BFAB2C80E02125F47FCCF6C957A7FDECD915B3EBE0C1DD",
                        "PreviousTxnLgrSeq": 4
                    }
                }, {
                    "CreatedNode": {
                        "LedgerEntryType": "RippleState",
                        "LedgerIndex": "93E317B32022977C77810A2C558FBB28E30E744C68E73720622B797F957EC5FA",
                        "NewFields": {
                            "Balance": {
                                "currency": "USD",
                                "issuer": "rrrrrrrrrrrrrrrrrrrrBZbvji",
                                "value": "0"
                            },
                            "Flags": 2162688,
                            "HighLimit": {
                                "currency": "USD",
                                "issuer": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
                                "value": "0"
                            },
                            "LowLimit": {
                                "currency": "USD",
                                "issuer": "rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC",
                                "value": "100"
                            }
                        }
                    }
                }, {
                    "ModifiedNode": {
                        "FinalFields": {
                            "Account": "rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC",
                            "Balance": "999960000",
                            "Flags": 0,
                            "OwnerCount": 6,
                            "Sequence": 3
                        },
                        "LedgerEntryType": "AccountRoot",
                        "LedgerIndex": "A6B1BA6F2D70813100908EA84ABB7783695050312735E2C3665259F388804EA0",
                        "PreviousFields": {
                            "Balance": "999990000",
                            "OwnerCount": 5,
                            "Sequence": 2
                        },
                        "PreviousTxnID": "8FDC18960455C196A8C4DE0D24799209A21F4A17E32102B5162BD79466B90222",
                        "PreviousTxnLgrSeq": 5
                    }
                }, {
                    "ModifiedNode": {
                        "FinalFields": {
                            "Flags": 0,
                            "Owner": "rEuLyBCvcw4CFmzv8RepSiAoNgF8tTGJQC",
                            "RootIndex": "C2728175908D82FB1DE6676F203D8D3C056995A9FA9B369EF326523F1C65A1DE"
                        },
                        "LedgerEntryType": "DirectoryNode",
                        "LedgerIndex": "C2728175908D82FB1DE6676F203D8D3C056995A9FA9B369EF326523F1C65A1DE"
                    }
                }, {
                    "CreatedNode": {
                        "LedgerEntryType": "DirectoryNode",
                        "LedgerIndex": "D8120FC732737A2CF2E9968FDF3797A43B457F2A81AA06D2653171A1EA635204",
                        "NewFields": {
                            "Owner": "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
                            "RootIndex": "D8120FC732737A2CF2E9968FDF3797A43B457F2A81AA06D2653171A1EA635204"
                        }
                    }
                }],
                "TransactionIndex": 0,
                "TransactionResult": "tesSUCCESS"
            },
            "status": "success",
            "validated": true
        }
    }


  • Ripple - REMINDER: rippled Version 0.81.0 Validator Key Replacement

    On Thursday, January 18, 2018, as described in the 0.81.0 release notes, the current validator keys on all five Ripple-operated rippled validator servers will be replaced. If you have been using the previous recommended default configuration and do not reconfigure your rippled server to the new recommended default configuration before that time, then your rippled server will stop seeing validated ledgers.

    Ripple strongly recommends upgrading to rippled version 0.81.0 immediately.

    Action Required

    If you operate a rippled server, then you should upgrade to 0.81.0 immediately.

    Ripple recommends that you:

    • Edit your rippled.cfg to remove the [validators] section, if one is present
    • Add a [validators_file] section, if one is not present, and add the name of your validators.txt file.
    • Replace the contents of any existing validators.txt file with the version included with this release. If you are upgrading to rippled version 0.81.0 using the rippled RPM package, then your default validators.txt file may automatically be updated, in which case you will not need to modify the file. The validators.txt file is usually in the same directory as your rippled.cfg file.
    • After starting your rippled server, confirm that it is configured to use the new defaults by executing:
      /opt/ripple/bin/rippled validators
      

    The result should include the following:

     "local_static_keys" : [],
     "publisher_lists" : [
     {
     "available" : true,
     "expiration" : "2018-Jan-23 00:00:00",
     "list" : [
     "nHB1FqfBpNg7UTpiqEUkKcAiWqC2PFuoGY7FPWtCcXAxSkhpqDkm",
     "nHUpwrafS45zmi6eT72XS5ijpkW5JwfL5mLdPhEibrqUvtRcMAjU",
     "nHUBGitjsiaiMJBWKYsJBHU2shmYt9m29hRqoh8AS5bSAjXoHmdd",
     "nHUXh1ELizQ5QLLqtNaVEbbbfMdq3wMkh14aJo5xi83xzzaatWWP",
     "nHUgoJvpqXZMZwxh8ZoFseFJEVF8ryup9r2mFYchX7ftMdNn3jLT"
     ],
     "pubkey_publisher" : "ED2677ABFFD1B33AC6FBC3062B71F1E8397C1505E1C42C64D11AD1B28FF73F4734",
     "seq" : 2,
     "version" : 1
     }
     ],
    

    Impact of Not Upgrading

    • If you operate a rippled server, but do not upgrade to rippled version 0.81.0, then your rippled server may periodically drop transactions and fall out of sync with the network.
    • On Thursday, January 18, 2018, as described in the 0.81.0 release notes, the current validator keys on all five Ripple-operated rippled validator servers will be replaced. If you have been using the recommended default configuration and do not reconfigure your rippled server before that time, then your rippled server will stop seeing validated ledgers.

    For instructions on updating rippled on supported platforms, see Updating rippled on supported platforms.

    The sha256 for the RPM is: 75acdf54e472875bff609fa2d1cc59524e4d8f8e885751b50aaeb85938ab3609

    The sha256 for the source RPM is: fbc95f6168d015190b93b81f97c20979886fa2f6663e4dd15157409075db46e9

    For other platforms, please compile version 0.81.0 from source.

    The first log entry should be the change setting the version:

    commit 4e8c8deeaac83d18eb62c95b7425d96e11847a41
    Author: Nikolaos D. Bougalis <[email protected]>
    Date: Wed Jan 3 14:43:42 2018 -0800
     Set version to 0.81.0
    

    0.81.0 Change Log

    • New hosted validator configuration

    Bug Fixes

    • Optimize queries for account_tx to work around SQLite query planner (#2312)

    Network Update

    The Ripple technical operations team deployed rippled version 0.81.0 to all rippled validator servers under its operational control, on Tuesday, 2018-01-09.

    Learn, ask questions, and discuss

    Related documentation is available in the Ripple Developer Portal, including detailed example API calls and web tools for API testing.

    Other resources:


  • Log in to reply
     

    Looks like your connection to Cryptocentral was lost, please wait while we try to reconnect.