Address remaining PR #720 IT/signing review comments (verified against live rippled develop)

- SponsorshipIT: extend testPreFundedFeeSponsorshipNoCosign, testSponsorshipTransferSingleSigneeSingleSponsor,
  and testSponsorshipTransferMultiSponseeMultiSponsor to verify on-ledger state (balances, Sponsorship.feeAmount,
  AccountRoot.sponsor/sponsoringAccountCount) instead of only asserting tesSUCCESS.
- SponsorshipIT: add testSponsorCreatedAccountPayment covering Payment.tfSponsorCreatedAccount, verified end-to-end
  against rippleci/xrpld:develop in standalone mode.
- BcDerivedKeySignatureServiceTest: add known-good signature byte assertions to sponsorSignEd/Ec and
  sponsorMultiSignEd/Ec, matching the existing sibling multiSignEc pattern.

All changes verified locally: 10/10 SponsorshipIT tests pass against rippleci/xrpld:develop (standalone),
36/36 BcDerivedKeySignatureServiceTest pass, full core suite (73473 tests) passes, checkstyle clean on
both modules.

Author: cybele-ripple

xrpl4j-core/src/test/java/org/xrpl/xrpl4j/crypto/signing/bc/BcDerivedKeySignatureServiceTest.java

@@ -1096,7 +1096,10 @@ void sponsorSignEd() {
     final Callable<Boolean> signedCallable = () -> {
       Signature signature = this.derivedKeySignatureService.sponsorSign(privateKeyReference, paymentTransaction);
       assertThat(signature).isNotNull();
-      assertThat(signature.base16Value()).isNotEmpty();
+      assertThat(signature.base16Value()).isEqualTo(
+        "F0968CC4FC05040788E3F5E28D8BFE21F34B059143D769B54F8668CBD805BDE5C7AAF748EC60DD877B193FD16CB32A91D9539" +
+          "C4C04851099C4B45E5FD1566401"
+      );
       // Verify signature is deterministic
       Signature signature2 = this.derivedKeySignatureService.sponsorSign(privateKeyReference, paymentTransaction);
       assertThat(signature.base16Value()).isEqualTo(signature2.base16Value());
@@ -1137,7 +1140,10 @@ void sponsorSignEc() {
     final Callable<Boolean> signedCallable = () -> {
       Signature signature = this.derivedKeySignatureService.sponsorSign(privateKeyReference, paymentTransaction);
       assertThat(signature).isNotNull();
-      assertThat(signature.base16Value()).isNotEmpty();
+      assertThat(signature.base16Value()).isEqualTo(
+        "3045022100CA3EE6AF48AA49EEF7964E4BF5E3FA879476FFE836F91740344415CD3B34A25B02205DCFC440B19BECBE3C5FF29F" +
+          "F0C662C33AE2DDD10AC4B1859C419D0BB32B8AC6"
+      );
       // Verify signature is deterministic for SECP256K1
       Signature signature2 = this.derivedKeySignatureService.sponsorSign(privateKeyReference, paymentTransaction);
       assertThat(signature.base16Value()).isEqualTo(signature2.base16Value());
@@ -1178,7 +1184,10 @@ void sponsorMultiSignEd() {
     final Callable<Boolean> signedCallable = () -> {
       Signature signature = this.derivedKeySignatureService.sponsorMultiSign(privateKeyReference, paymentTransaction);
       assertThat(signature).isNotNull();
-      assertThat(signature.base16Value()).isNotEmpty();
+      assertThat(signature.base16Value()).isEqualTo(
+        "8DFF4D545A289D7F0659DB61759C1EFDA36093432F1B2B6E99BA3B8A5EF4343125B6470441CE7579F42FD9B29BAC728E087BA" +
+          "8260E911583B3B3B6038FF5740D"
+      );
       // Verify signature is deterministic
       Signature signature2 = this.derivedKeySignatureService.sponsorMultiSign(privateKeyReference, paymentTransaction);
       assertThat(signature.base16Value()).isEqualTo(signature2.base16Value());
@@ -1219,7 +1228,10 @@ void sponsorMultiSignEc() {
     final Callable<Boolean> signedCallable = () -> {
       Signature signature = this.derivedKeySignatureService.sponsorMultiSign(privateKeyReference, paymentTransaction);
       assertThat(signature).isNotNull();
-      assertThat(signature.base16Value()).isNotEmpty();
+      assertThat(signature.base16Value()).isEqualTo(
+        "304502210088CBBE3DE6CCA7306072B28DF8785157E9D6A4037E6F895B7D93C4106C208EFF02204CE2EB8A9A1077358408201" +
+          "052D46EC7AB4BEA09CB981E2FEAB17812BBC52E96"
+      );
       // Verify signature is deterministic for SECP256K1
       Signature signature2 = this.derivedKeySignatureService.sponsorMultiSign(privateKeyReference, paymentTransaction);
       assertThat(signature.base16Value()).isEqualTo(signature2.base16Value());

xrpl4j-integration-tests/src/test/java/org/xrpl/xrpl4j/tests/SponsorshipIT.java

@@ -31,6 +31,7 @@
 import org.xrpl.xrpl4j.client.JsonRpcClientErrorException;
 import org.xrpl.xrpl4j.crypto.keys.KeyPair;
 import org.xrpl.xrpl4j.crypto.keys.PublicKey;
+import org.xrpl.xrpl4j.crypto.keys.Seed;
 import org.xrpl.xrpl4j.crypto.signing.MultiSignedTransaction;
 import org.xrpl.xrpl4j.crypto.signing.Signature;
 import org.xrpl.xrpl4j.crypto.signing.SingleSignedTransaction;
@@ -47,9 +48,11 @@
 import org.xrpl.xrpl4j.model.client.transactions.SubmitMultiSignedResult;
 import org.xrpl.xrpl4j.model.client.transactions.SubmitResult;
 import org.xrpl.xrpl4j.model.client.transactions.TransactionResult;
+import org.xrpl.xrpl4j.model.flags.PaymentFlags;
 import org.xrpl.xrpl4j.model.flags.SponsorFlags;
 import org.xrpl.xrpl4j.model.flags.SponsorshipSetFlags;
 import org.xrpl.xrpl4j.model.flags.SponsorshipTransferFlags;
+import org.xrpl.xrpl4j.model.ledger.AccountRootObject;
 import org.xrpl.xrpl4j.model.ledger.CheckObject;
 import org.xrpl.xrpl4j.model.ledger.SignerEntry;
 import org.xrpl.xrpl4j.model.ledger.SignerEntryWrapper;
@@ -252,13 +255,14 @@ void testPreFundedFeeSponsorshipNoCosign() throws JsonRpcClientErrorException, J
 
       // Sponsor creates SponsorshipSet without RequireSignForFee flag
       AccountInfoResult sponsorAccountInfo = scanForResult(() -> getValidatedAccountInfo(sponsorAddress));
+      XrpCurrencyAmount feeAmount = XrpCurrencyAmount.ofDrops(500000);
 
       SponsorshipSet sponsorshipSet = SponsorshipSet.builder()
         .account(sponsorAddress)
         .fee(feeResult.drops().openLedgerFee())
         .sequence(sponsorAccountInfo.accountData().sequence())
         .sponsee(sponseeAddress)
-        .feeAmount(XrpCurrencyAmount.ofDrops(500000))
+        .feeAmount(feeAmount)
         .signingPublicKey(sponsorKeyPair.publicKey())
         .build();
 
@@ -272,11 +276,13 @@ void testPreFundedFeeSponsorshipNoCosign() throws JsonRpcClientErrorException, J
 
       // Sponsee submits payment using pre-funded fee (no sponsor signature needed)
       AccountInfoResult sponseeAccountInfo = scanForResult(() -> getValidatedAccountInfo(sponseeAddress));
+      XrpCurrencyAmount sponseeInitialBalance = sponseeAccountInfo.accountData().balance();
+      XrpCurrencyAmount paymentAmount = XrpCurrencyAmount.ofDrops(50000);
 
       Payment payment = Payment.builder()
         .account(sponseeAddress)
         .destination(destAddress)
-        .amount(XrpCurrencyAmount.ofDrops(50000))
+        .amount(paymentAmount)
         .fee(feeResult.drops().openLedgerFee())
         .sequence(sponseeAccountInfo.accountData().sequence())
         .sponsor(sponsorAddress)
@@ -290,6 +296,72 @@ void testPreFundedFeeSponsorshipNoCosign() throws JsonRpcClientErrorException, J
 
       SubmitResult<Payment> paymentResult = xrplClient.submit(signedPayment);
       assertThat(paymentResult.engineResult()).isEqualTo(SUCCESS_STATUS);
+      scanForResult(() -> getValidatedTransaction(paymentResult.transactionResult().hash(), Payment.class));
+
+      // Assert the fee was paid from the pre-funded Sponsorship object, not the sponsee's own balance:
+      // the sponsee's balance drops only by the payment amount, and the Sponsorship's FeeAmount decreases
+      // by the network fee.
+      XrpCurrencyAmount sponseeFinalBalance = scanForResult(
+        () -> getValidatedAccountInfo(sponseeAddress)
+      ).accountData().balance();
+      XrpCurrencyAmount expectedSponseeBalance = XrpCurrencyAmount.ofDrops(
+        sponseeInitialBalance.value().longValue() - paymentAmount.value().longValue()
+      );
+      assertThat(sponseeFinalBalance).isEqualTo(expectedSponseeBalance);
+
+      SponsorshipObject updatedSponsorship = getSponsorshipObject(sponsorAddress, sponseeAddress);
+      XrpCurrencyAmount expectedFeeAmount = XrpCurrencyAmount.ofDrops(
+        feeAmount.value().longValue() - feeResult.drops().openLedgerFee().value().longValue()
+      );
+      assertThat(updatedSponsorship.feeAmount()).hasValue(expectedFeeAmount);
+    }
+
+    /**
+     * Test: {@code Payment.tfSponsorCreatedAccount} sponsors a brand-new destination account.
+     *
+     * <ol>
+     *   <li>Alice sends a Payment with {@code tfSponsorCreatedAccount} set to a fresh, never-before-seen
+     *       destination address, with an {@code Amount} below the normal account reserve requirement
+     *       (allowed per spec section 11.3 when this flag is enabled).</li>
+     *   <li>Assert the new account was created and its {@code AccountRoot.Sponsor} field points to Alice.</li>
+     * </ol>
+     */
+    @Test
+    void testSponsorCreatedAccountPayment() throws JsonRpcClientErrorException, JsonProcessingException {
+      KeyPair aliceKeyPair = createRandomAccountEd25519();
+      Address aliceAddress = aliceKeyPair.publicKey().deriveAddress();
+
+      // A fresh, never-funded keypair. This account does not yet exist on the ledger.
+      KeyPair newAccountKeyPair = Seed.ed25519Seed().deriveKeyPair();
+      Address newAccountAddress = newAccountKeyPair.publicKey().deriveAddress();
+
+      FeeResult feeResult = xrplClient.fee();
+      AccountInfoResult aliceAccountInfo = scanForResult(() -> getValidatedAccountInfo(aliceAddress));
+
+      Payment sponsoredAccountCreate = Payment.builder()
+        .account(aliceAddress)
+        .destination(newAccountAddress)
+        .amount(XrpCurrencyAmount.ofDrops(1)) // Below the normal reserve; allowed with this flag.
+        .fee(feeResult.drops().openLedgerFee())
+        .sequence(aliceAccountInfo.accountData().sequence())
+        .flags(PaymentFlags.builder().tfSponsorCreatedAccount(true).build())
+        .signingPublicKey(aliceKeyPair.publicKey())
+        .build();
+
+      SingleSignedTransaction<Payment> signedPayment = signatureService.sign(
+        aliceKeyPair.privateKey(), sponsoredAccountCreate
+      );
+      SubmitResult<Payment> paymentResult = xrplClient.submit(signedPayment);
+      assertThat(paymentResult.engineResult()).isEqualTo(SUCCESS_STATUS);
+      logInfo(sponsoredAccountCreate.transactionType(), paymentResult.transactionResult().hash());
+
+      scanForResult(() -> getValidatedTransaction(paymentResult.transactionResult().hash(), Payment.class));
+
+      // Assert the new account exists and is sponsored by Alice.
+      AccountRootObject newAccountData = scanForResult(
+        () -> getValidatedAccountInfo(newAccountAddress)
+      ).accountData();
+      assertThat(newAccountData.sponsor()).hasValue(aliceAddress);
     }
   }
 
@@ -694,6 +766,19 @@ void testSponsorshipTransferSingleSigneeSingleSponsor() throws JsonRpcClientErro
         () -> getValidatedTransaction(finalTx.hash(), SponsorshipTransfer.class)
       );
       assertThat(validatedTx.metadata().get().transactionResult()).isEqualTo(SUCCESS_STATUS);
+
+      // Assert the account-level reserve sponsorship was actually established on-ledger: the
+      // sponsee's AccountRoot now names the new sponsor, and the new sponsor's SponsoringAccountCount
+      // increased.
+      AccountRootObject sponseeAccountData = scanForResult(
+        () -> getValidatedAccountInfo(sponseeAddress)
+      ).accountData();
+      assertThat(sponseeAccountData.sponsor()).hasValue(newSponsorAddress);
+
+      AccountRootObject newSponsorAccountData = scanForResult(
+        () -> getValidatedAccountInfo(newSponsorAddress)
+      ).accountData();
+      assertThat(newSponsorAccountData.sponsoringAccountCount()).hasValue(UnsignedInteger.ONE);
     }
 
     /**
@@ -835,6 +920,19 @@ void testSponsorshipTransferMultiSponseeMultiSponsor() throws JsonRpcClientError
         () -> getValidatedTransaction(finalTx.hash(), SponsorshipTransfer.class)
       );
       assertThat(validatedTx.metadata().get().transactionResult()).isEqualTo(SUCCESS_STATUS);
+
+      // Assert the account-level reserve sponsorship was actually established on-ledger: the
+      // sponsee's AccountRoot now names the sponsor account, and the sponsor's SponsoringAccountCount
+      // increased.
+      AccountRootObject sponseeAccountData = scanForResult(
+        () -> getValidatedAccountInfo(sponseeAddress)
+      ).accountData();
+      assertThat(sponseeAccountData.sponsor()).hasValue(sponsorAddress);
+
+      AccountRootObject sponsorAccountData = scanForResult(
+        () -> getValidatedAccountInfo(sponsorAddress)
+      ).accountData();
+      assertThat(sponsorAccountData.sponsoringAccountCount()).hasValue(UnsignedInteger.ONE);
     }
   }