[TON]: Return non-bounceable address by default (BREAKING CHANGES) (#…

…3925) * [TON]: Return non-bounceable address by default * [TON]: `TWTONAddressConverterFromBoc` returns bounceable address * [TON]: Add `TWTONAddressConverterToUserFriendly` function * [TON]: `TWTONAddressConverterFromBoc` returns non-bounceable address * Fix tests * [TON]: Add `TWStoredKeyUpdateAddress` function to update address for a chain * [TON]: Fix generation error
trustwallet · Jul 4, 2024 · ca05821 · ca05821
1 parent 6ee73c8
commit ca05821
Show file tree

Hide file tree

Showing 19 changed files with 282 additions and 35 deletions.
diff --git a/...p/src/androidTest/java/com/trustwallet/core/app/blockchains/CoinAddressDerivationTests.kt b/...p/src/androidTest/java/com/trustwallet/core/app/blockchains/CoinAddressDerivationTests.kt
@@ -122,7 +122,7 @@ class CoinAddressDerivationTests {
         NATIVEEVMOS -> assertEquals("evmos13u6g7vqgw074mgmf2ze2cadzvkz9snlwstd20d", address)
         NERVOS -> assertEquals("ckb1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqdtyq04tvp02wectaumxn0664yw2jd53lqk4mxg3", address)
         EVERSCALE -> assertEquals("0:0c39661089f86ec5926ea7d4ee4223d634ba4ed6dcc2e80c7b6a8e6d59f79b04", address)
-        TON -> assertEquals("EQDgEMqToTacHic7SnvnPFmvceG5auFkCcAw0mSCvzvKUfk9", address)
+        TON -> assertEquals("UQDgEMqToTacHic7SnvnPFmvceG5auFkCcAw0mSCvzvKUaT4", address)
         APTOS -> assertEquals("0x7968dab936c1bad187c60ce4082f307d030d780e91e694ae03aef16aba73f30", address)
         NEBL -> assertEquals("NgDVaXAwNgBwb88xLiFKomfBmPkEh9F2d7", address)
         SUI -> assertEquals("0xada112cfb90b44ba889cc5d39ac2bf46281e4a91f7919c693bcd9b8323e81ed2", address)

diff --git a/...est/java/com/trustwallet/core/app/blockchains/theopennetwork/TestTheOpenNetworkAddress.kt b/...est/java/com/trustwallet/core/app/blockchains/theopennetwork/TestTheOpenNetworkAddress.kt
@@ -22,28 +22,44 @@ class TestTheOpenNetworkAddress {
         val publicKey = privateKey.getPublicKeyEd25519()
         val address = AnyAddress(publicKey, CoinType.TON)
         assertEquals(publicKey.data().toHex(), "0xf42c77f931bea20ec5d0150731276bbb2e2860947661245b2319ef8133ee8d41")
-        assertEquals(address.description(), "EQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts90Q")
+        assertEquals(address.description(), "UQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts4DV")
     }
 
     @Test
     fun testAddressFromPublicKey() {
         val publicKey = PublicKey("f42c77f931bea20ec5d0150731276bbb2e2860947661245b2319ef8133ee8d41".toHexByteArray(), PublicKeyType.ED25519)
         val address = AnyAddress(publicKey, CoinType.TON)
-        assertEquals(address.description(), "EQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts90Q")
+        assertEquals(address.description(), "UQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts4DV")
     }
 
     @Test
     fun testAddressFromRawString() {
         val addressString = "0:66fbe3c5c03bf5c82792f904c9f8bf28894a6aa3d213d41c20569b654aadedb3"
         val address = AnyAddress(addressString, CoinType.TON)
-        assertEquals(address.description(), "EQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts90Q")
+        assertEquals(address.description(), "UQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts4DV")
     }
 
     @Test
-    fun testAddressFromUserFriendlyString() {
+    fun testAddressFromBounceableString() {
         val addressString = "EQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts90Q"
         val address = AnyAddress(addressString, CoinType.TON)
-        assertEquals(address.description(), "EQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts90Q")
+        assertEquals(address.description(), "UQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts4DV")
+    }
+
+    @Test
+    fun testAddressFromUserFriendlyString() {
+        val addressString = "UQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts4DV"
+        val address = AnyAddress(addressString, CoinType.TON)
+        assertEquals(address.description(), "UQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts4DV")
+    }
+
+    @Test
+    fun testAddressToBounceable() {
+        val addressString = "UQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts4DV"
+        val bounceable = true
+        val testnet = false
+        val address = TONAddressConverter.toUserFriendly(addressString, bounceable, testnet)
+        assertEquals(address, "EQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts90Q")
     }
 
     @Test

diff --git a/include/TrustWalletCore/TWStoredKey.h b/include/TrustWalletCore/TWStoredKey.h
@@ -295,6 +295,17 @@ TWData* _Nullable TWStoredKeyExportJSON(struct TWStoredKey* _Nonnull key);
 TW_EXPORT_METHOD
 bool TWStoredKeyFixAddresses(struct TWStoredKey* _Nonnull key, TWData* _Nonnull password);
 
+/// Re-derives address and public key for the specified chain.
+/// It can be used to update the address if the default address format for the given chain has been changed.
+/// This method needs the encryption password to re-write address.
+///
+/// \param key Non-null pointer to a stored key
+/// \param password Non-null block of data, password of the stored key
+/// \param coin Coin type for which to update the address and public key
+/// \return `false` if the password is incorrect or there is no data for the specified chain, true otherwise.
+TW_EXPORT_METHOD
+bool TWStoredKeyUpdateAddress(struct TWStoredKey* _Nonnull key, TWData* _Nonnull password, enum TWCoinType coin);
+
 /// Retrieve stored key encoding parameters, as JSON string.
 ///
 /// \param key Non-null pointer to a stored key

diff --git a/include/TrustWalletCore/TWTONAddressConverter.h b/include/TrustWalletCore/TWTONAddressConverter.h
@@ -31,4 +31,12 @@ TWString *_Nullable TWTONAddressConverterToBoc(TWString *_Nonnull address);
 TW_EXPORT_STATIC_METHOD
 TWString *_Nullable TWTONAddressConverterFromBoc(TWString *_Nonnull boc);
 
+/// Converts any TON address format to user friendly with the given parameters.
+///
+/// \param address raw or user-friendly address to be converted.
+/// \param bounceable whether the result address should be bounceable.
+/// \param testnet whether the result address should be testnet.
+TW_EXPORT_STATIC_METHOD
+TWString *_Nullable TWTONAddressConverterToUserFriendly(TWString *_Nonnull address, bool bounceable, bool testnet);
+
 TW_EXTERN_C_END
diff --git a/...core-kotlin/src/commonTest/kotlin/com/trustwallet/core/test/CoinAddressDerivationTests.kt b/...core-kotlin/src/commonTest/kotlin/com/trustwallet/core/test/CoinAddressDerivationTests.kt
@@ -115,7 +115,7 @@ class CoinAddressDerivationTests {
         NativeEvmos -> "evmos13u6g7vqgw074mgmf2ze2cadzvkz9snlwstd20d"
         Nervos -> "ckb1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqdtyq04tvp02wectaumxn0664yw2jd53lqk4mxg3"
         Everscale -> "0:0c39661089f86ec5926ea7d4ee4223d634ba4ed6dcc2e80c7b6a8e6d59f79b04"
-        TON -> "EQDgEMqToTacHic7SnvnPFmvceG5auFkCcAw0mSCvzvKUfk9"
+        TON -> "UQDgEMqToTacHic7SnvnPFmvceG5auFkCcAw0mSCvzvKUaT4"
         Aptos -> "0x7968dab936c1bad187c60ce4082f307d030d780e91e694ae03aef16aba73f30"
         Nebl -> "NgDVaXAwNgBwb88xLiFKomfBmPkEh9F2d7"
         Sui -> "0xada112cfb90b44ba889cc5d39ac2bf46281e4a91f7919c693bcd9b8323e81ed2"

diff --git a/src/Keystore/StoredKey.cpp b/src/Keystore/StoredKey.cpp
@@ -155,6 +155,12 @@ Account StoredKey::fillAddressIfMissing(Account& account, const HDWallet<>* wall
     return account;
 }
 
+void StoredKey::updateAddressForAccount(const PrivateKey& privKey, Account& account) {
+    const auto pubKey = privKey.getPublicKey(TW::publicKeyType(account.coin));
+    account.address = TW::deriveAddress(account.coin, pubKey, account.derivation);
+    account.publicKey = hex(pubKey.bytes);
+}
+
 std::optional<const Account> StoredKey::account(TWCoinType coin, const HDWallet<>* wallet) {
     const auto account = getDefaultAccountOrAny(coin, wallet);
     if (account.has_value()) {
@@ -269,9 +275,7 @@ void StoredKey::fixAddresses(const Data& password) {
             }
             const auto& derivationPath = account.derivationPath;
             const auto key = wallet.getKey(account.coin, derivationPath);
-            const auto pubKey = key.getPublicKey(TW::publicKeyType(account.coin));
-            account.address = TW::deriveAddress(account.coin, pubKey, account.derivation);
-            account.publicKey = hex(pubKey.bytes);
+            updateAddressForAccount(key, account);
         }
     } break;
 
@@ -282,14 +286,37 @@ void StoredKey::fixAddresses(const Data& password) {
                 TW::validateAddress(account.coin, account.address)) {
                 continue;
             }
-            const auto pubKey = key.getPublicKey(TW::publicKeyType(account.coin));
-            account.address = TW::deriveAddress(account.coin, pubKey, account.derivation);
-            account.publicKey = hex(pubKey.bytes);
+            updateAddressForAccount(key, account);
         }
     } break;
     }
 }
 
+bool StoredKey::updateAddress(TWCoinType coin, const Data& password) {
+    auto account = std::find_if(accounts.begin(), accounts.end(), [coin](const auto &account) {
+        return account.coin == coin;
+    });
+    if (account == accounts.end()) {
+        return false;
+    }
+
+    switch (type) {
+        case StoredKeyType::mnemonicPhrase: {
+            const auto wallet = this->wallet(password);
+            const auto& derivationPath = account->derivationPath;
+            const auto key = wallet.getKey(account->coin, derivationPath);
+            updateAddressForAccount(key, *account);
+        } break;
+
+        case StoredKeyType::privateKey: {
+            auto key = PrivateKey(payload.decrypt(password));
+            updateAddressForAccount(key, *account);
+        } break;
+    }
+
+    return true;
+}
+
 // -----------------
 // Encoding/Decoding
 // -----------------

diff --git a/src/Keystore/StoredKey.h b/src/Keystore/StoredKey.h
@@ -144,6 +144,12 @@ class StoredKey {
     /// the encryption password to re-derive addresses from private keys.
     void fixAddresses(const Data& password);
 
+    /// Re-derives address and public key for the specified chain.
+    ///
+    /// Use when address format for the given chain has been changed. This method needs
+    /// the encryption password to re-derive addresses from private keys.
+    bool updateAddress(TWCoinType coin, const Data& password);
+
 private:
     /// Default constructor, private
     StoredKey() : type(StoredKeyType::mnemonicPhrase) {}
@@ -169,6 +175,9 @@ class StoredKey {
 
     /// Re-derive account address if missing
     Account fillAddressIfMissing(Account& account, const HDWallet<>* wallet) const;
+
+    /// Re-derives public key and address for the specified account.
+    static void updateAddressForAccount(const PrivateKey& privKey, Account& account);
 };
 
 } // namespace TW::Keystore

diff --git a/src/TheOpenNetwork/Address.h b/src/TheOpenNetwork/Address.h
@@ -48,7 +48,7 @@ class Address {
     /// Initializes an address with its parts
     explicit Address(
         int8_t workchainId, std::array<byte, AddressData::size> hash,
-        bool userFriendly = true, bool bounceable = true, bool testOnly = false
+        bool userFriendly = true, bool bounceable = false, bool testOnly = false
     ) : addressData(workchainId, hash),
         isUserFriendly(userFriendly),
         isBounceable(bounceable),

diff --git a/src/TheOpenNetwork/Entry.cpp b/src/TheOpenNetwork/Entry.cpp
@@ -17,7 +17,7 @@ bool Entry::validateAddress([[maybe_unused]] TWCoinType coin, [[maybe_unused]] c
 }
 
 std::string Entry::normalizeAddress([[maybe_unused]] TWCoinType coin, const std::string& address) const {
-    return Address(address).string(true, true, false);
+    return Address(address).string(true, false, false);
 }
 
 std::string Entry::deriveAddress([[maybe_unused]] TWCoinType coin, const PublicKey& publicKey, [[maybe_unused]] TWDerivation derivation, [[maybe_unused]] const PrefixVariant& addressPrefix) const {

diff --git a/src/interface/TWStoredKey.cpp b/src/interface/TWStoredKey.cpp
@@ -224,6 +224,15 @@ bool TWStoredKeyFixAddresses(struct TWStoredKey* _Nonnull key, TWData* _Nonnull
     }
 }
 
+bool TWStoredKeyUpdateAddress(struct TWStoredKey* _Nonnull key, TWData* _Nonnull password, enum TWCoinType coin) {
+    try {
+        const auto passwordData = TW::data(TWDataBytes(password), TWDataSize(password));
+        return key->impl.updateAddress(coin, passwordData);
+    } catch (...) {
+        return false;
+    }
+}
+
 TWString* _Nullable TWStoredKeyEncryptionParameters(struct TWStoredKey* _Nonnull key) {
     if (!key->impl.id) {
         return nullptr;

diff --git a/src/interface/TWTONAddressConverter.cpp b/src/interface/TWTONAddressConverter.cpp
@@ -11,13 +11,14 @@ using namespace TW;
 
 TWString *_Nullable TWTONAddressConverterToBoc(TWString *_Nonnull address) {
     auto& addressString = *reinterpret_cast<const std::string*>(address);
-    if (!TheOpenNetwork::Address::isValid(addressString)) {
+
+    try {
+        const TheOpenNetwork::Address addressTon(addressString);
+        auto bocEncoded = addressTon.toBoc();
+        return TWStringCreateWithUTF8Bytes(bocEncoded.c_str());
+    } catch (...) {
         return nullptr;
     }
-
-    const TheOpenNetwork::Address addressTon(addressString);
-    auto bocEncoded = addressTon.toBoc();
-    return TWStringCreateWithUTF8Bytes(bocEncoded.c_str());
 }
 
 TWString *_Nullable TWTONAddressConverterFromBoc(TWString *_Nonnull boc) {
@@ -38,3 +39,18 @@ TWString *_Nullable TWTONAddressConverterFromBoc(TWString *_Nonnull boc) {
         return nullptr;
     }
 }
+
+TWString *_Nullable TWTONAddressConverterToUserFriendly(TWString *_Nonnull address, bool bounceable, bool testnet) {
+    auto& addressString = *reinterpret_cast<const std::string*>(address);
+
+    try {
+        const TheOpenNetwork::Address addressTon(addressString);
+
+        auto userFriendly = true;
+        const auto addressFormatted = addressTon.string(userFriendly, bounceable, testnet);
+
+        return TWStringCreateWithUTF8Bytes(addressFormatted.c_str());
+    } catch (...) {
+        return nullptr;
+    }
+}
diff --git a/swift/Tests/Blockchains/TheOpenNetworkTests.swift b/swift/Tests/Blockchains/TheOpenNetworkTests.swift
@@ -11,26 +11,38 @@ class TheOpenNetworkTests: XCTestCase {
         let privateKey = PrivateKey(data: data!)!
         let publicKey = privateKey.getPublicKeyEd25519()
         let address = AnyAddress(publicKey: publicKey, coin: .ton)
-        XCTAssertEqual(address.description, "EQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts90Q")
+        XCTAssertEqual(address.description, "UQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts4DV")
     }
 
     func testAddressFromPublicKey() {
         let data = Data(hexString: "f42c77f931bea20ec5d0150731276bbb2e2860947661245b2319ef8133ee8d41")
         let publicKey = PublicKey(data: data!, type: PublicKeyType.ed25519)!
         let address = AnyAddress(publicKey: publicKey, coin: .ton)
-        XCTAssertEqual(address.description, "EQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts90Q")
+        XCTAssertEqual(address.description, "UQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts4DV")
     }
 
     func testAddressFromRawString() {
         let addressString = "0:66fbe3c5c03bf5c82792f904c9f8bf28894a6aa3d213d41c20569b654aadedb3"
         let address = AnyAddress(string: addressString, coin: .ton)
-        XCTAssertEqual(address!.description, "EQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts90Q")
+        XCTAssertEqual(address!.description, "UQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts4DV")
     }
 
-    func testAddressFromUserFriendlyString() {
+    func testAddressFromBounceableString() {
         let addressString = "EQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts90Q"
         let address = AnyAddress(string: addressString, coin: .ton)
-        XCTAssertEqual(address!.description, "EQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts90Q")
+        XCTAssertEqual(address!.description, "UQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts4DV")
+    }
+
+    func testAddressFromUserFriendlyString() {
+        let addressString = "UQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts4DV"
+        let address = AnyAddress(string: addressString, coin: .ton)
+        XCTAssertEqual(address!.description, "UQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts4DV")
+    }
+
+    func testAddressToBounceable() {
+        let addressString = "UQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts4DV"
+        let address = TONAddressConverter.toUserFriendly(address: addressString, bounceable: true, testnet: false)
+        XCTAssertEqual(address, "EQBm--PFwDv1yCeS-QTJ-L8oiUpqo9IT1BwgVptlSq3ts90Q")
     }
 
     func testGenerateJettonAddress() {

diff --git a/swift/Tests/CoinAddressDerivationTests.swift b/swift/Tests/CoinAddressDerivationTests.swift
@@ -308,7 +308,7 @@ class CoinAddressDerivationTests: XCTestCase {
                     let expectedResult = "0:0c39661089f86ec5926ea7d4ee4223d634ba4ed6dcc2e80c7b6a8e6d59f79b04";
                     assertCoinDerivation(coin, expectedResult, derivedAddress, address)
                 case .ton:
-                    let expectedResult = "EQDgEMqToTacHic7SnvnPFmvceG5auFkCcAw0mSCvzvKUfk9";
+                    let expectedResult = "UQDgEMqToTacHic7SnvnPFmvceG5auFkCcAw0mSCvzvKUaT4";
                     assertCoinDerivation(coin, expectedResult, derivedAddress, address)
                 case .aptos:
                     let expectedResult = "0x7968dab936c1bad187c60ce4082f307d030d780e91e694ae03aef16aba73f30";

diff --git a/tests/chains/TheOpenNetwork/AddressTests.cpp b/tests/chains/TheOpenNetwork/AddressTests.cpp
@@ -102,7 +102,7 @@ TEST(TheOpenNetworkAddress, FromPrivateKeyV4R2) {
     WalletV4R2 wallet(publicKey, WorkchainType::Basechain);
     const auto address = wallet.getAddress();
 
-    ASSERT_EQ(address.string(), "EQCKhieGGl3ZbJ2zzggHsSLaXtRzk0znVopbSxw2HLsorkdl");
+    ASSERT_EQ(address.string(), "UQCKhieGGl3ZbJ2zzggHsSLaXtRzk0znVopbSxw2HLsorhqg");
 }
 
 TEST(TheOpenNetworkAddress, FromPublicKeyV4R2) {
@@ -111,7 +111,7 @@ TEST(TheOpenNetworkAddress, FromPublicKeyV4R2) {
     WalletV4R2 wallet(publicKey, WorkchainType::Basechain);
     const auto address = wallet.getAddress();
 
-    ASSERT_EQ(address.string(), "EQCKhieGGl3ZbJ2zzggHsSLaXtRzk0znVopbSxw2HLsorkdl");
+    ASSERT_EQ(address.string(), "UQCKhieGGl3ZbJ2zzggHsSLaXtRzk0znVopbSxw2HLsorhqg");
 }
 
 TEST(TheOpenNetworkAddress, GetJettonNotcoinAddress) {
@@ -180,4 +180,58 @@ TEST(TheOpenNetworkAddress, FromBocError) {
     ASSERT_EQ(TWTONAddressConverterFromBoc(boc4.get()), nullptr);
 }
 
+TEST(TheOpenNetworkAddress, ToUserFriendly) {
+    auto rawAddress = "0:8a8627861a5dd96c9db3ce0807b122da5ed473934ce7568a5b4b1c361cbb28ae";
+    auto bounceable = "EQCKhieGGl3ZbJ2zzggHsSLaXtRzk0znVopbSxw2HLsorkdl";
+    auto nonBounceable = "UQCKhieGGl3ZbJ2zzggHsSLaXtRzk0znVopbSxw2HLsorhqg";
+    auto bounceableTestnet = "kQCKhieGGl3ZbJ2zzggHsSLaXtRzk0znVopbSxw2HLsorvzv";
+    auto nonBounceableTestnet = "0QCKhieGGl3ZbJ2zzggHsSLaXtRzk0znVopbSxw2HLsorqEq";
+
+    // Raw to user friendly.
+    assertStringsEqual(
+        WRAPS(TWTONAddressConverterToUserFriendly(STRING(rawAddress).get(), true, false)),
+        bounceable
+    );
+    assertStringsEqual(
+        WRAPS(TWTONAddressConverterToUserFriendly(STRING(rawAddress).get(), false, false)),
+        nonBounceable
+    );
+    assertStringsEqual(
+        WRAPS(TWTONAddressConverterToUserFriendly(STRING(rawAddress).get(), true, true)),
+        bounceableTestnet
+    );
+    assertStringsEqual(
+        WRAPS(TWTONAddressConverterToUserFriendly(STRING(rawAddress).get(), false, true)),
+        nonBounceableTestnet
+    );
+
+    // Bounceable to non-bounceable.
+    assertStringsEqual(
+        WRAPS(TWTONAddressConverterToUserFriendly(STRING(bounceable).get(), false, false)),
+        nonBounceable
+    );
+
+    // Non-bounceable to bounceable.
+    assertStringsEqual(
+        WRAPS(TWTONAddressConverterToUserFriendly(STRING(nonBounceable).get(), true, false)),
+        bounceable
+    );
+
+    // Non-bounceable to non-bounceable.
+    assertStringsEqual(
+        WRAPS(TWTONAddressConverterToUserFriendly(STRING(nonBounceable).get(), false, false)),
+        nonBounceable
+    );
+}
+
+TEST(TheOpenNetworkAddress, ToUserFriendlyError) {
+    // No "0:" prefix.
+    auto invalid1 = STRING("8a8627861a5dd96c9db3ce0807b122da5ed473934ce7568a5b4b1c361cbb28ae");
+    ASSERT_EQ(TWTONAddressConverterToUserFriendly(invalid1.get(), true, false), nullptr);
+
+    // Too short.
+    auto invalid2 = STRING("EQCKhieGGl3ZbJ2zzggHsSLaXtRzk0znVopbSxw2HLsor");
+    ASSERT_EQ(TWTONAddressConverterToUserFriendly(invalid1.get(), false, false), nullptr);
+}
+
 } // namespace TW::TheOpenNetwork::tests
diff --git a/tests/chains/TheOpenNetwork/TWAnyAddressTests.cpp b/tests/chains/TheOpenNetwork/TWAnyAddressTests.cpp
@@ -25,7 +25,7 @@ TEST(TWTheOpenNetwork, Address) {
     const auto address = WRAP(TWAnyAddress, TWAnyAddressCreateWithPublicKey(publicKey.get(), TWCoinTypeTON));
     const auto addressStr = WRAPS(TWAnyAddressDescription(address.get()));
 
-    assertStringsEqual(addressStr, "EQDYW_1eScJVxtitoBRksvoV9cCYo4uKGWLVNIHB1JqRR3n0");
+    assertStringsEqual(addressStr, "UQDYW_1eScJVxtitoBRksvoV9cCYo4uKGWLVNIHB1JqRRyQx");
 }
 
 } // namespace TW::TheOpenNetwork::tests