Fix core for CAP-0073

Author: sisuresh

src/transactions/InvokeHostFunctionOpFrame.cpp

@@ -659,7 +659,8 @@ class InvokeHostFunctionApplyHelper : virtual LedgerAccessHelper
         }
 
         // Check that each newly created ContractCode or ContractData entry also
-        // creates an ttlEntry
+        // creates a ttlEntry. Starting from protocol 26 (CAP-73), the Stellar
+        // Asset Contract can also create classic entries (ACCOUNT, TRUSTLINE).
         for (auto const& key : createdKeys)
         {
             if (isSorobanEntry(key))
@@ -668,6 +669,13 @@ class InvokeHostFunctionApplyHelper : virtual LedgerAccessHelper
                 releaseAssertOrThrow(createdKeys.find(ttlKey) !=
                                      createdKeys.end());
             }
+            else if (protocolVersionStartsFrom(getLedgerVersion(),
+                                               ProtocolVersion::V_26))
+            {
+                releaseAssertOrThrow(key.type() == TTL ||
+                                     key.type() == ACCOUNT ||
+                                     key.type() == TRUSTLINE);
+            }
             else
             {
                 releaseAssertOrThrow(key.type() == TTL);

src/transactions/test/InvokeHostFunctionTests.cpp

@@ -325,6 +325,37 @@ TEST_CASE_VERSIONS("Trustline stellar asset contract",
             checkSponsorship(ltx, acc, 0, nullptr, 1, 2, 0, 1);
             checkSponsorship(ltx, sponsor, 0, nullptr, 0, 2, 1, 0);
         }
+
+        // Test CAP-73: trust() creates a trustline via the SAC
+        if (protocolVersionStartsFrom(test.getLedgerVersion(),
+                                      ProtocolVersion::V_26))
+        {
+            auto trustAcc = root.create(
+                "trustAcc", app.getLedgerManager().getLastMinBalance(2));
+            // Account has no trustline for IDR yet
+            {
+                LedgerTxn ltx(app.getLedgerTxnRoot());
+                auto tlAsset = assetToTrustLineAsset(idr);
+                REQUIRE(
+                    !ltx.load(trustlineKey(trustAcc.getPublicKey(), tlAsset)));
+            }
+
+            REQUIRE(client.trust(trustAcc));
+
+            // Trustline should now exist with zero balance and max limit
+            {
+                LedgerTxn ltx(app.getLedgerTxnRoot());
+                auto tlAsset = assetToTrustLineAsset(idr);
+                auto tlEntry =
+                    ltx.load(trustlineKey(trustAcc.getPublicKey(), tlAsset));
+                REQUIRE(tlEntry);
+                REQUIRE(tlEntry.current().data.trustLine().balance == 0);
+                REQUIRE(tlEntry.current().data.trustLine().limit == INT64_MAX);
+            }
+
+            // Calling trust again should be a no-op (idempotent)
+            REQUIRE(client.trust(trustAcc));
+        }
     });
 }
 
@@ -427,6 +458,81 @@ TEST_CASE("Native stellar asset contract",
         checkSponsorship(ltx, root.getPublicKey(), 0, nullptr, 0, 2, 2, 0);
     }
 
+    // Test CAP-73: XLM transfer to non-existent account creates the account
+    if (protocolVersionStartsFrom(test.getLedgerVersion(),
+                                  ProtocolVersion::V_26))
+    {
+        auto newAccKey = SecretKey::pseudoRandomForTesting();
+        auto newAccPub = newAccKey.getPublicKey();
+        auto newAccAddr = makeAccountAddress(newAccPub);
+
+        // Account should not exist yet
+        REQUIRE(!doesAccountExist(app, newAccPub));
+
+        // Transfer 2 * base_reserve (minimum to create account) via SAC
+        auto baseReserve =
+            static_cast<int64_t>(app.getLedgerManager().getLastReserve());
+        auto createAmount = 2 * baseReserve;
+
+        // Construct the footprint manually since the destination account
+        // doesn't exist yet and client.transfer() would try to read its
+        // balance.
+        LedgerKey fromAccountKey(ACCOUNT);
+        fromAccountKey.account().accountID = a1.getPublicKey();
+        LedgerKey toAccountKey(ACCOUNT);
+        toAccountKey.account().accountID = newAccPub;
+
+        auto spec = client.defaultSpec().setReadWriteFootprint(
+            {fromAccountKey, toAccountKey});
+
+        SCVal fromVal(SCV_ADDRESS);
+        fromVal.address() = makeAccountAddress(a1.getPublicKey());
+        SCVal toVal(SCV_ADDRESS);
+        toVal.address() = newAccAddr;
+
+        auto invocation =
+            client.getContract()
+                .prepareInvocation(
+                    "transfer", {fromVal, toVal, makeI128(createAmount)}, spec)
+                .withAuthorizedTopCall();
+        REQUIRE(invocation.invoke(&a1));
+
+        // Account should now exist with the correct balance
+        REQUIRE(doesAccountExist(app, newAccPub));
+        {
+            LedgerTxn ltx(app.getLedgerTxnRoot());
+            auto entry = stellar::loadAccount(ltx, newAccPub);
+            REQUIRE(entry.current().data.account().balance == createAmount);
+        }
+
+        // Transferring below minimum should fail for a non-existent account
+        auto newAccKey2 = SecretKey::pseudoRandomForTesting();
+        auto newAccPub2 = newAccKey2.getPublicKey();
+        auto newAccAddr2 = makeAccountAddress(newAccPub2);
+
+        REQUIRE(!doesAccountExist(app, newAccPub2));
+
+        LedgerKey toAccountKey2(ACCOUNT);
+        toAccountKey2.account().accountID = newAccPub2;
+
+        auto specFail = client.defaultSpec().setReadWriteFootprint(
+            {fromAccountKey, toAccountKey2});
+
+        SCVal toVal2(SCV_ADDRESS);
+        toVal2.address() = newAccAddr2;
+
+        auto failInvocation =
+            client.getContract()
+                .prepareInvocation(
+                    "transfer", {fromVal, toVal2, makeI128(createAmount - 1)},
+                    specFail)
+                .withAuthorizedTopCall();
+        REQUIRE(!failInvocation.invoke(&a1));
+
+        // Account should still not exist
+        REQUIRE(!doesAccountExist(app, newAccPub2));
+    }
+
     // Test batch_transfer with 5 destinations (protocol 23+)
     if (app.getConfig().LEDGER_PROTOCOL_VERSION >= 23)
     {

src/transactions/test/SorobanTxTestUtils.cpp

@@ -1975,6 +1975,30 @@ AssetContractTestClient::clawback(TestAccount& admin, SCAddress const& fromAddr,
     return success;
 }
 
+bool
+AssetContractTestClient::trust(TestAccount& addr)
+{
+    auto addrSC = makeAccountAddress(addr.getPublicKey());
+
+    SCVal addrVal(SCV_ADDRESS);
+    addrVal.address() = addrSC;
+
+    LedgerKey trustlineKey(TRUSTLINE);
+    trustlineKey.trustLine().accountID = addr.getPublicKey();
+    trustlineKey.trustLine().asset = assetToTrustLineAsset(mAsset);
+
+    LedgerKey accountKey(ACCOUNT);
+    accountKey.account().accountID = addr.getPublicKey();
+
+    auto spec = defaultSpec()
+                    .setReadWriteFootprint({trustlineKey, accountKey})
+                    .extendReadOnlyFootprint({makeIssuerKey(mAsset)});
+
+    auto invocation = mContract.prepareInvocation("trust", {addrVal}, spec)
+                          .withAuthorizedTopCall();
+    return invocation.invoke(&addr);
+}
+
 ContractStorageTestClient::ContractStorageTestClient(
     SorobanTest& test, int64_t additionalRefundableFee)
     : mContract(test.deployWasmContract(

src/transactions/test/SorobanTxTestUtils.h

@@ -406,6 +406,7 @@ class AssetContractTestClient
     bool burn(TestAccount& from, int64_t amount);
     bool clawback(TestAccount& admin, SCAddress const& fromAddr,
                   int64_t amount);
+    bool trust(TestAccount& addr);
     TestContract const& getContract() const;
     std::optional<ContractEvent> lastEvent() const;