diff --git a/include/xrpl/protocol/Feature.h b/include/xrpl/protocol/Feature.h index 369ec3304ef..bff3e57597f 100644 --- a/include/xrpl/protocol/Feature.h +++ b/include/xrpl/protocol/Feature.h @@ -80,7 +80,7 @@ namespace detail { // Feature.cpp. Because it's only used to reserve storage, and determine how // large to make the FeatureBitset, it MAY be larger. It MUST NOT be less than // the actual number of amendments. A LogicError on startup will verify this. -static constexpr std::size_t numFeatures = 85; +static constexpr std::size_t numFeatures = 86; /** Amendments that this server supports and the default voting behavior. Whether they are enabled depends on the Rules defined in the validated diff --git a/include/xrpl/protocol/detail/features.macro b/include/xrpl/protocol/detail/features.macro index d90dc327780..05248854847 100644 --- a/include/xrpl/protocol/detail/features.macro +++ b/include/xrpl/protocol/detail/features.macro @@ -29,6 +29,7 @@ // If you add an amendment here, then do not forget to increment `numFeatures` // in include/xrpl/protocol/Feature.h. +XRPL_FIX (FrozenLPTokenTransfer, Supported::yes, VoteBehavior::DefaultNo) XRPL_FEATURE(PermissionedDomains, Supported::no, VoteBehavior::DefaultNo) XRPL_FEATURE(DynamicNFT, Supported::yes, VoteBehavior::DefaultNo) XRPL_FEATURE(Credentials, Supported::yes, VoteBehavior::DefaultNo) diff --git a/src/test/app/LPTokenTransfer_test.cpp b/src/test/app/LPTokenTransfer_test.cpp new file mode 100644 index 00000000000..efb403ae7f1 --- /dev/null +++ b/src/test/app/LPTokenTransfer_test.cpp @@ -0,0 +1,476 @@ +//------------------------------------------------------------------------------ +/* + This file is part of rippled: https://github.com/ripple/rippled + Copyright (c) 2024 Ripple Labs Inc. + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ +//============================================================================== + +#include +#include +#include + +namespace ripple { +namespace test { + +class LPTokenTransfer_test : public jtx::AMMTest +{ + void + testDirectStep(FeatureBitset features) + { + testcase("DirectStep"); + + using namespace jtx; + Env env{*this, features}; + fund(env, gw, {alice}, {USD(20'000), BTC(0.5)}, Fund::All); + env.close(); + + AMM ammAlice(env, alice, USD(20'000), BTC(0.5)); + BEAST_EXPECT( + ammAlice.expectBalances(USD(20'000), BTC(0.5), IOUAmount{100, 0})); + + fund(env, gw, {carol}, {USD(4'000), BTC(1)}, Fund::Acct); + ammAlice.deposit(carol, 10); + BEAST_EXPECT( + ammAlice.expectBalances(USD(22'000), BTC(0.55), IOUAmount{110, 0})); + + fund(env, gw, {bob}, {USD(4'000), BTC(1)}, Fund::Acct); + ammAlice.deposit(bob, 10); + BEAST_EXPECT( + ammAlice.expectBalances(USD(24'000), BTC(0.60), IOUAmount{120, 0})); + + auto const lpIssue = ammAlice.lptIssue(); + env.trust(STAmount{lpIssue, 500}, alice); + env.trust(STAmount{lpIssue, 500}, bob); + env.trust(STAmount{lpIssue, 500}, carol); + env.close(); + + // gateway freezes carol's USD + env(trust(gw, carol["USD"](0), tfSetFreeze)); + env.close(); + + // bob can still send lptoken to carol even tho carol's USD is + // frozen, regardless of whether fixFrozenLPTokenTransfer is enabled or + // not + // Note: Deep freeze is not considered for LPToken transfer + env(pay(bob, carol, STAmount{lpIssue, 5})); + env.close(); + + // cannot transfer to an amm account + env(pay(carol, lpIssue.getIssuer(), STAmount{lpIssue, 5}), + ter(tecNO_PERMISSION)); + env.close(); + + if (features[fixFrozenLPTokenTransfer]) + { + // carol is frozen on USD and therefore can't send lptoken to bob + env(pay(carol, bob, STAmount{lpIssue, 5}), ter(tecPATH_DRY)); + } + else + { + // carol can still send lptoken with frozen USD + env(pay(carol, bob, STAmount{lpIssue, 5})); + } + } + + void + testBookStep(FeatureBitset features) + { + testcase("BookStep"); + + using namespace jtx; + Env env{*this, features}; + + fund( + env, + gw, + {alice, bob, carol}, + {USD(10'000), EUR(10'000)}, + Fund::All); + AMM ammAlice(env, alice, USD(10'000), EUR(10'000)); + ammAlice.deposit(carol, 1'000); + ammAlice.deposit(bob, 1'000); + + auto const lpIssue = ammAlice.lptIssue(); + + // carols creates an offer to sell lptoken + env(offer(carol, XRP(10), STAmount{lpIssue, 10}), txflags(tfPassive)); + env.close(); + BEAST_EXPECT(expectOffers(env, carol, 1)); + + env.trust(STAmount{lpIssue, 1'000'000'000}, alice); + env.trust(STAmount{lpIssue, 1'000'000'000}, bob); + env.trust(STAmount{lpIssue, 1'000'000'000}, carol); + env.close(); + + // gateway freezes carol's USD + env(trust(gw, carol["USD"](0), tfSetFreeze)); + env.close(); + + // exercises alice's ability to consume carol's offer to sell lptoken + // when carol's USD is frozen pre/post fixFrozenLPTokenTransfer + // amendment + if (features[fixFrozenLPTokenTransfer]) + { + // with fixFrozenLPTokenTransfer, alice fails to consume carol's + // offer since carol's USD is frozen + env(pay(alice, bob, STAmount{lpIssue, 10}), + txflags(tfPartialPayment), + sendmax(XRP(10)), + ter(tecPATH_DRY)); + env.close(); + BEAST_EXPECT(expectOffers(env, carol, 1)); + + // gateway unfreezes carol's USD + env(trust(gw, carol["USD"](1'000'000'000), tfClearFreeze)); + env.close(); + + // alice successfully consumes carol's offer + env(pay(alice, bob, STAmount{lpIssue, 10}), + txflags(tfPartialPayment), + sendmax(XRP(10))); + env.close(); + BEAST_EXPECT(expectOffers(env, carol, 0)); + } + else + { + // without fixFrozenLPTokenTransfer, alice can consume carol's offer + // even when carol's USD is frozen + env(pay(alice, bob, STAmount{lpIssue, 10}), + txflags(tfPartialPayment), + sendmax(XRP(10))); + env.close(); + BEAST_EXPECT(expectOffers(env, carol, 0)); + } + + // make sure carol's USD is not frozen + env(trust(gw, carol["USD"](1'000'000'000), tfClearFreeze)); + env.close(); + + // ensure that carol's offer to buy lptoken can be consumed by alice + // even when carol's USD is frozen + { + // carol creates an offer to buy lptoken + env(offer(carol, STAmount{lpIssue, 10}, XRP(10)), + txflags(tfPassive)); + env.close(); + BEAST_EXPECT(expectOffers(env, carol, 1)); + + // gateway freezes carol's USD + env(trust(gw, carol["USD"](0), tfSetFreeze)); + env.close(); + + // alice successfully consumes carol's offer + env(pay(alice, bob, XRP(10)), + txflags(tfPartialPayment), + sendmax(STAmount{lpIssue, 10})); + env.close(); + BEAST_EXPECT(expectOffers(env, carol, 0)); + } + } + + void + testOfferCreation(FeatureBitset features) + { + testcase("Create offer"); + + using namespace jtx; + Env env{*this, features}; + + fund( + env, + gw, + {alice, bob, carol}, + {USD(10'000), EUR(10'000)}, + Fund::All); + AMM ammAlice(env, alice, USD(10'000), EUR(10'000)); + ammAlice.deposit(carol, 1'000); + ammAlice.deposit(bob, 1'000); + + auto const lpIssue = ammAlice.lptIssue(); + + // gateway freezes carol's USD + env(trust(gw, carol["USD"](0), tfSetFreeze)); + env.close(); + + // exercises carol's ability to create a new offer to sell lptoken with + // frozen USD, before and after fixFrozenLPTokenTransfer + if (features[fixFrozenLPTokenTransfer]) + { + // with fixFrozenLPTokenTransfer, carol can't create an offer to + // sell lptoken when one of the assets is frozen + + // carol can't create an offer to sell lptoken + env(offer(carol, XRP(10), STAmount{lpIssue, 10}), + txflags(tfPassive), + ter(tecUNFUNDED_OFFER)); + env.close(); + BEAST_EXPECT(expectOffers(env, carol, 0)); + + // gateway unfreezes carol's USD + env(trust(gw, carol["USD"](1'000'000'000), tfClearFreeze)); + env.close(); + + // carol can create an offer to sell lptoken after USD is unfrozen + env(offer(carol, XRP(10), STAmount{lpIssue, 10}), + txflags(tfPassive)); + env.close(); + BEAST_EXPECT(expectOffers(env, carol, 1)); + } + else + { + // without fixFrozenLPTokenTransfer, carol can create an offer + env(offer(carol, XRP(10), STAmount{lpIssue, 10}), + txflags(tfPassive)); + env.close(); + BEAST_EXPECT(expectOffers(env, carol, 1)); + } + + // gateway freezes carol's USD + env(trust(gw, carol["USD"](0), tfSetFreeze)); + env.close(); + + // carol can create offer to buy lptoken even if USD is frozen + env(offer(carol, STAmount{lpIssue, 10}, XRP(5)), txflags(tfPassive)); + env.close(); + BEAST_EXPECT(expectOffers(env, carol, 2)); + } + + void + testOfferCrossing(FeatureBitset features) + { + testcase("Offer crossing"); + + using namespace jtx; + Env env{*this, features}; + + // Offer crossing with two AMM LPTokens. + fund(env, gw, {alice, carol}, {USD(10'000)}, Fund::All); + AMM ammAlice1(env, alice, XRP(10'000), USD(10'000)); + ammAlice1.deposit(carol, 10'000'000); + + fund(env, gw, {alice, carol}, {EUR(10'000)}, Fund::IOUOnly); + AMM ammAlice2(env, alice, XRP(10'000), EUR(10'000)); + ammAlice2.deposit(carol, 10'000'000); + auto const token1 = ammAlice1.lptIssue(); + auto const token2 = ammAlice2.lptIssue(); + + // carol creates offer + env(offer(carol, STAmount{token2, 100}, STAmount{token1, 100})); + env.close(); + BEAST_EXPECT(expectOffers(env, carol, 1)); + + // gateway freezes carol's USD, carol's token1 should be frozen as well + env(trust(gw, carol["USD"](0), tfSetFreeze)); + env.close(); + + // alice creates an offer which exhibits different behavior on offer + // crossing depending on if fixFrozenLPTokenTransfer is enabled + env(offer(alice, STAmount{token1, 100}, STAmount{token2, 100})); + env.close(); + + // exercises carol's offer's ability to cross with alice's offer when + // carol's USD is frozen, before and after fixFrozenLPTokenTransfer + if (features[fixFrozenLPTokenTransfer]) + { + // with fixFrozenLPTokenTransfer enabled, alice's offer can no + // longer cross with carol's offer + BEAST_EXPECT( + expectLine(env, alice, STAmount{token1, 10'000'000}) && + expectLine(env, alice, STAmount{token2, 10'000'000})); + BEAST_EXPECT( + expectLine(env, carol, STAmount{token2, 10'000'000}) && + expectLine(env, carol, STAmount{token1, 10'000'000})); + BEAST_EXPECT( + expectOffers(env, alice, 1) && expectOffers(env, carol, 0)); + } + else + { + // alice's offer still crosses with carol's offer despite carol's + // token1 is frozen + BEAST_EXPECT( + expectLine(env, alice, STAmount{token1, 10'000'100}) && + expectLine(env, alice, STAmount{token2, 9'999'900})); + BEAST_EXPECT( + expectLine(env, carol, STAmount{token2, 10'000'100}) && + expectLine(env, carol, STAmount{token1, 9'999'900})); + BEAST_EXPECT( + expectOffers(env, alice, 0) && expectOffers(env, carol, 0)); + } + } + + void + testCheck(FeatureBitset features) + { + testcase("Check"); + + using namespace jtx; + Env env{*this, features}; + + fund( + env, + gw, + {alice, bob, carol}, + {USD(10'000), EUR(10'000)}, + Fund::All); + AMM ammAlice(env, alice, USD(10'000), EUR(10'000)); + ammAlice.deposit(carol, 1'000); + ammAlice.deposit(bob, 1'000); + + auto const lpIssue = ammAlice.lptIssue(); + + // gateway freezes carol's USD + env(trust(gw, carol["USD"](0), tfSetFreeze)); + env.close(); + + // carol can always create a check with lptoken that has frozen + // token + uint256 const chkId{keylet::check(carol, env.seq(carol)).key}; + env(check::create(carol, bob, STAmount{lpIssue, 10})); + env.close(); + + // with fixFrozenLPTokenTransfer enabled, bob fails to cash the check + if (features[fixFrozenLPTokenTransfer]) + env(check::cash(bob, chkId, STAmount{lpIssue, 10}), + ter(tecPATH_PARTIAL)); + else + env(check::cash(bob, chkId, STAmount{lpIssue, 10})); + + env.close(); + } + + void + testNFTOffers(FeatureBitset features) + { + testcase("NFT Offers"); + using namespace test::jtx; + + Env env{*this, features}; + + // Setup AMM + fund( + env, + gw, + {alice, bob, carol}, + {USD(10'000), EUR(10'000)}, + Fund::All); + AMM ammAlice(env, alice, USD(10'000), EUR(10'000)); + ammAlice.deposit(carol, 1'000); + ammAlice.deposit(bob, 1'000); + + auto const lpIssue = ammAlice.lptIssue(); + + // bob mints a nft + uint256 const nftID{token::getNextID(env, bob, 0u, tfTransferable)}; + env(token::mint(bob, 0), txflags(tfTransferable)); + env.close(); + + // bob creates a sell offer for lptoken + uint256 const sellOfferIndex = keylet::nftoffer(bob, env.seq(bob)).key; + env(token::createOffer(bob, nftID, STAmount{lpIssue, 10}), + txflags(tfSellNFToken)); + env.close(); + + // gateway freezes carol's USD + env(trust(gw, carol["USD"](0), tfSetFreeze)); + env.close(); + + // exercises one's ability to transfer NFT using lptoken when one of the + // assets is frozen + if (features[fixFrozenLPTokenTransfer]) + { + // with fixFrozenLPTokenTransfer, freezing USD will prevent buy/sell + // offers with lptokens from being created/accepted + + // carol fails to accept bob's offer with lptoken because carol's + // USD is frozen + env(token::acceptSellOffer(carol, sellOfferIndex), + ter(tecINSUFFICIENT_FUNDS)); + env.close(); + + // gateway unfreezes carol's USD + env(trust(gw, carol["USD"](1'000'000), tfClearFreeze)); + env.close(); + + // carol can now accept the offer and own the nft + env(token::acceptSellOffer(carol, sellOfferIndex)); + env.close(); + + // gateway freezes bobs's USD + env(trust(gw, bob["USD"](0), tfSetFreeze)); + env.close(); + + // bob fails to create a buy offer with lptoken for carol's nft + // since bob's USD is frozen + env(token::createOffer(bob, nftID, STAmount{lpIssue, 10}), + token::owner(carol), + ter(tecUNFUNDED_OFFER)); + env.close(); + + // gateway unfreezes bob's USD + env(trust(gw, bob["USD"](1'000'000), tfClearFreeze)); + env.close(); + + // bob can now create a buy offer + env(token::createOffer(bob, nftID, STAmount{lpIssue, 10}), + token::owner(carol)); + env.close(); + } + else + { + // without fixFrozenLPTokenTransfer, freezing USD will still allow + // buy/sell offers to be created/accepted with lptoken + + // carol can still accept bob's offer despite carol's USD is frozen + env(token::acceptSellOffer(carol, sellOfferIndex)); + env.close(); + + // gateway freezes bob's USD + env(trust(gw, bob["USD"](0), tfSetFreeze)); + env.close(); + + // bob creates a buy offer with lptoken despite bob's USD is frozen + uint256 const buyOfferIndex = + keylet::nftoffer(bob, env.seq(bob)).key; + env(token::createOffer(bob, nftID, STAmount{lpIssue, 10}), + token::owner(carol)); + env.close(); + + // carol accepts bob's offer + env(token::acceptBuyOffer(carol, buyOfferIndex)); + env.close(); + } + } + +public: + void + run() override + { + FeatureBitset const all{jtx::supported_amendments()}; + + for (auto const features : {all, all - fixFrozenLPTokenTransfer}) + { + testDirectStep(features); + testBookStep(features); + testOfferCreation(features); + testOfferCrossing(features); + testCheck(features); + testNFTOffers(features); + } + } +}; + +BEAST_DEFINE_TESTSUITE(LPTokenTransfer, app, ripple); +} // namespace test +} // namespace ripple diff --git a/src/xrpld/app/misc/detail/AMMUtils.cpp b/src/xrpld/app/misc/detail/AMMUtils.cpp index f5f6ae6612c..d99eaf1f284 100644 --- a/src/xrpld/app/misc/detail/AMMUtils.cpp +++ b/src/xrpld/app/misc/detail/AMMUtils.cpp @@ -116,13 +116,34 @@ ammLPHolds( AccountID const& lpAccount, beast::Journal const j) { - return accountHolds( - view, - lpAccount, - ammLPTCurrency(cur1, cur2), - ammAccount, - FreezeHandling::fhZERO_IF_FROZEN, - j); + // This function looks similar to `accountHolds`. However, it only checks if + // a LPToken holder has enough balance. On the other hand, `accountHolds` + // checks if the underlying assets of LPToken are frozen with the + // fixFrozenLPTokenTransfer amendment + + auto const currency = ammLPTCurrency(cur1, cur2); + STAmount amount; + + auto const sle = view.read(keylet::line(lpAccount, ammAccount, currency)); + if (!sle) + amount.clear(Issue{currency, ammAccount}); + else if (isFrozen(view, lpAccount, currency, ammAccount)) + amount.clear(Issue{currency, ammAccount}); + else + { + amount = sle->getFieldAmount(sfBalance); + if (lpAccount > ammAccount) + { + // Put balance in account terms. + amount.negate(); + } + amount.setIssuer(ammAccount); + } + JLOG(j.trace()) << "ammLPHolds:" + << " lpAccount=" << to_string(lpAccount) + << " amount=" << amount.getFullText(); + + return view.balanceHook(lpAccount, ammAccount, amount); } STAmount diff --git a/src/xrpld/app/paths/detail/DirectStep.cpp b/src/xrpld/app/paths/detail/DirectStep.cpp index 95e64b337bc..34723d36bca 100644 --- a/src/xrpld/app/paths/detail/DirectStep.cpp +++ b/src/xrpld/app/paths/detail/DirectStep.cpp @@ -204,7 +204,8 @@ class DirectStepI : public StepImp> logStringImpl(char const* name) const { std::ostringstream ostr; - ostr << name << ": " << "\nSrc: " << src_ << "\nDst: " << dst_; + ostr << name << ": " + << "\nSrc: " << src_ << "\nDst: " << dst_; return ostr.str(); } diff --git a/src/xrpld/app/paths/detail/StepChecks.h b/src/xrpld/app/paths/detail/StepChecks.h index 2c2fee91cf9..536dfdae94a 100644 --- a/src/xrpld/app/paths/detail/StepChecks.h +++ b/src/xrpld/app/paths/detail/StepChecks.h @@ -21,6 +21,7 @@ #define RIPPLE_APP_PATHS_IMPL_STEP_CHECKS_H_INCLUDED #include +#include #include #include #include @@ -54,6 +55,26 @@ checkFreeze( } } + if (view.rules().enabled(fixFrozenLPTokenTransfer)) + { + if (auto const sleDst = view.read(keylet::account(dst)); + sleDst && sleDst->isFieldPresent(sfAMMID)) + { + auto const sleAmm = view.read(keylet::amm((*sleDst)[sfAMMID])); + if (!sleAmm) + return tecINTERNAL; // LCOV_EXCL_LINE + + if (isLPTokenFrozen( + view, + src, + (*sleAmm)[sfAsset].get(), + (*sleAmm)[sfAsset2].get())) + { + return terNO_LINE; + } + } + } + return tesSUCCESS; } diff --git a/src/xrpld/ledger/View.h b/src/xrpld/ledger/View.h index 74027752486..d626d79fd45 100644 --- a/src/xrpld/ledger/View.h +++ b/src/xrpld/ledger/View.h @@ -153,6 +153,13 @@ isFrozen(ReadView const& view, AccountID const& account, Asset const& asset) asset.value()); } +[[nodiscard]] bool +isLPTokenFrozen( + ReadView const& view, + AccountID const& account, + Issue const& asset, + Issue const& asset2); + // Returns the amount an account can spend without going into debt. // // <-- saAmount: amount of currency held by account. May be negative. diff --git a/src/xrpld/ledger/detail/View.cpp b/src/xrpld/ledger/detail/View.cpp index ebf307f1535..9b959601fbf 100644 --- a/src/xrpld/ledger/detail/View.cpp +++ b/src/xrpld/ledger/detail/View.cpp @@ -267,6 +267,17 @@ isFrozen( isIndividualFrozen(view, account, mptIssue); } +bool +isLPTokenFrozen( + ReadView const& view, + AccountID const& account, + Issue const& asset, + Issue const& asset2) +{ + return isFrozen(view, account, asset.currency, asset.account) || + isFrozen(view, account, asset2.currency, asset2.account); +} + STAmount accountHolds( ReadView const& view, @@ -284,17 +295,46 @@ accountHolds( // IOU: Return balance on trust line modulo freeze auto const sle = view.read(keylet::line(account, issuer, currency)); - if (!sle) - { - amount.clear(Issue{currency, issuer}); - } - else if ( - (zeroIfFrozen == fhZERO_IF_FROZEN) && - isFrozen(view, account, currency, issuer)) - { - amount.clear(Issue{currency, issuer}); - } - else + auto const allowBalance = [&]() { + if (!sle) + return false; + + if (zeroIfFrozen == fhZERO_IF_FROZEN) + { + if (isFrozen(view, account, currency, issuer)) + return false; + + // when fixFrozenLPTokenTransfer is enabled, if currency is lptoken, + // we need to check if the associated assets have been frozen + if (view.rules().enabled(fixFrozenLPTokenTransfer)) + { + auto const sleIssuer = view.read(keylet::account(issuer)); + if (!sleIssuer) + { + return false; // LCOV_EXCL_LINE + } + else if (sleIssuer->isFieldPresent(sfAMMID)) + { + auto const sleAmm = + view.read(keylet::amm((*sleIssuer)[sfAMMID])); + + if (!sleAmm || + isLPTokenFrozen( + view, + account, + (*sleAmm)[sfAsset].get(), + (*sleAmm)[sfAsset2].get())) + { + return false; + } + } + } + } + + return true; + }(); + + if (allowBalance) { amount = sle->getFieldAmount(sfBalance); if (account > issuer) @@ -304,7 +344,13 @@ accountHolds( } amount.setIssuer(issuer); } - JLOG(j.trace()) << "accountHolds:" << " account=" << to_string(account) + else + { + amount.clear(Issue{currency, issuer}); + } + + JLOG(j.trace()) << "accountHolds:" + << " account=" << to_string(account) << " amount=" << amount.getFullText(); return view.balanceHook(account, issuer, amount); @@ -453,7 +499,8 @@ xrpLiquid( STAmount const amount = (balance < reserve) ? STAmount{0} : balance - reserve; - JLOG(j.trace()) << "accountHolds:" << " account=" << to_string(id) + JLOG(j.trace()) << "accountHolds:" + << " account=" << to_string(id) << " amount=" << amount.getFullText() << " fullBalance=" << fullBalance.getFullText() << " balance=" << balance.getFullText()