fix(solana): read pool fee recipient at the deployed offset (#761)

Author: bmc08gt

FlipcashCore/Sources/FlipcashCore/Solana/Programs/CoinbaseStableSwapperProgram.PoolAccount.swift

@@ -9,16 +9,39 @@ extension CoinbaseStableSwapperProgram {
 
     /// The on-chain liquidity pool account.
     ///
-    /// Layout: `[8 discriminator][32 operations_authority][32 pause_authority][32 fee_recipient]...`
+    /// Layout, decoded from the live pool account `CrDL9SoCyW1tBgn8k7rgGSpWhnszneWDbvKvqPAU4PL9`
+    /// (owner `pqgqKahpG1y2wsgxFhzaAnkV1cL9vk8MSg9qm4q646F`):
+    /// ```
+    ///   0   [8]  discriminator            sha256("account:LiquidityPool")[0..8]
+    ///   8   [32] operations_authority
+    ///   40  [32] pause_authority
+    ///   72  [32] unnamed pubkey           <- not described by the published IDL
+    ///   104 [32] unnamed pubkey           <- not described by the published IDL
+    ///   136 [32] fee_recipient
+    ///   168      vec<pubkey> (length 2 on the live account), then supported_tokens,
+    ///            fee_rate, swaps_paused, liquidity_paused, bump — not parsed by this type
+    /// ```
+    /// The program's published Anchor IDL does not describe this struct. It lists three
+    /// pubkeys, then `supported_tokens`, which puts `fee_recipient` at offset 72; mainnet has
+    /// it at 136. Regenerating this layout from that IDL reintroduces the bug this type exists
+    /// to fix, and neither of the two pubkeys the IDL omits has a published name to give it.
     public struct PoolAccount: Equatable, Sendable {
 
-        public let feeRecipient: PublicKey
+        /// `sha256("account:LiquidityPool")[0..8]`, Anchor's account discriminator for this type.
+        private static let discriminator: [UInt8] = [66, 38, 17, 64, 188, 80, 68, 129]
+
+        private static let feeRecipientOffset = 8 + 32 + 32 + 32 + 32
 
-        private static let feeRecipientOffset = 8 + 32 + 32
+        public let feeRecipient: PublicKey
 
-        /// Parses the raw pool account data, returning `nil` when the data is
-        /// too short or the fee recipient bytes are not a valid public key.
+        /// Parses the raw pool account data, returning `nil` when the data is too short,
+        /// the leading discriminator doesn't match `LiquidityPool`, or the fee recipient
+        /// bytes are not a valid public key.
         public init?(accountData: Data) {
+            guard accountData.prefix(Self.discriminator.count).elementsEqual(Self.discriminator) else {
+                return nil
+            }
+
             var payload = accountData.tail(from: Self.feeRecipientOffset)
             guard let feeRecipient = try? PublicKey(payload.consume(PublicKey.length)) else {
                 return nil

FlipcashCore/Tests/FlipcashCoreTests/CoinbaseStableSwapperDepositTransactionTests.swift

@@ -0,0 +1,83 @@
+//
+//  CoinbaseStableSwapperDepositTransactionTests.swift
+//  FlipcashCoreTests
+//
+
+import Foundation
+import Testing
+@testable import FlipcashCore
+
+/// Pins the bytes an external-wallet USDC deposit puts on the wire, starting from the real
+/// pool account rather than a hand-written fee recipient.
+///
+/// The chain under test is the one the deep-link deposit runs: parse the pool account, take
+/// `fee_recipient` out of it, build the USDC→USDF swap against the VM deposit, encode. A wrong
+/// offset in `PoolAccount` yields a valid-looking `PublicKey` and a transaction that encodes
+/// fine, so only the end-to-end bytes catch it.
+///
+/// The fixture below was accepted by `simulateTransaction` on mainnet (no error, 68922 compute
+/// units, `Swapped 5000000 tokens`). Reading `fee_recipient` at the offset the published IDL
+/// implies instead fails the same simulation with `ConstraintAddress` (2012).
+@Suite("CoinbaseStableSwapper deposit transaction bytes")
+struct CoinbaseStableSwapperDepositTransactionTests {
+
+    // MARK: - Fixtures
+
+    /// Base64 of the first 168 bytes (discriminator through `fee_recipient`) of the real pool
+    /// account `CrDL9SoCyW1tBgn8k7rgGSpWhnszneWDbvKvqPAU4PL9`, captured from mainnet.
+    private static let poolAccountBase64 = """
+    QiYRQLxQRIEFHqE9vluQFKO1wbEwnd22aRe9qGrV03SIsz1AV7GqT/yEzcR/f+ALaKG4KMxbBfZ5dTNFPqxxZHMfbTqNfj6St0p++yObz2IILMcKsoko07O+oRSDek7YwzrH9TroL1+QbHdT/t9qpcq4Kyx8OPWZm79AIUM9UlN+X6ujF0hPgzT4z8SXtrVTfBhZj7LzSPTgCpHoi6cjfPqXvflOJvRB
+    """
+
+    /// A mainnet wallet with a USDC balance, so these bytes can be replayed through
+    /// `simulateTransaction` unchanged when the pool or the program moves.
+    private static let sender = try! PublicKey(base58: "13V7ou4zHHwDVaAGWxqHSwU2sVzRR4m62XWqCFxhA5fD")
+    private static let owner = try! PublicKey([UInt8](repeating: 7, count: 32))
+    private static let swapId = try! PublicKey([UInt8](repeating: 9, count: 32))
+    private static let blockhash = try! Hash([UInt8](repeating: 99, count: 32))
+    private static let amount: UInt64 = 5_000_000
+
+    /// Any change here is a wire-format change on the deposit path. Re-simulate before updating.
+    private static let expectedBase64 = """
+    AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAA8WAKL0PLpNizvAoz6QRhxwuE+0xI1gTXBS8xC2iFAT9YAIIEbBeYxANDSqQKEPw/bim+87xyfndOcR1Z8MXipwRQhN3zo5EjvB3buXfyApNPeiOya5xLRmU4amnmybe8G0ZvC2QXkvoK+rzDvts+c808FFOCj9M+Gw1VaTwlFFQuCIGuzkYUNbUsQHluSoCkWyRnCKUYxj6p9wIBIqXQISoIsQLEV0nZ6/A9+EnNdx0SgwdXMN9srCBKAsQrgkmUgy/UHEeoQ9iL75ZI2OJCdbgb8cuXN12zjqg9u576KCFfMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMGRm/lIRcy/+ytunLDm+e8jOW7xfcSayxDmzpAAAAABUpTUPhdyILWFKVWcniKKW3fHqur0KYGeIhJMvTu9qAGp9UXGSxcUSGMyUw9SvF/WNruCJuh/UTj29mKAAAAAAbd9uHXZaGT2cvhRs7reawctIXtX1s3kTqM9YV+/wCpDEFZLOrgP4XlL2Cp/OoiptfGnqhwN8d2wUpZw0Pc/EQPv+3THgl3KU5TYxzuZoU4rxDFSBlWplQ+ubexfVTLGBesefflfZmEQHRAN54c7gRVD3jN0yyu9XLWr5cM75ecK4oRckQvAxiEdzAHgKozCP7MPozCSuUSsn/Qt7oVRio0+M/El7a1U3wYWY+y80j04AqR6IunI3z6l735Tib0QT3TxICKPU+zn67Jy6SbWmNKUu3hFUj1JKog8s1G74BxjJclj04kifG7PRApFI4NgwtaE5na/xCEBI572Nvp+FmwC/Uf+cl7MpDUyy9l2C2TYANmRyEZdjSa69H06vFFtr1GKwT/p1DYV1ksSW6M2cODznxaflH16bTnFDZNvRkvxvp6877brTo9ZfNqq8l0MbG75MLS9uDkfKYCA0UvXWFjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjYwgIAAUCQA0DAAgACQPoAwAAAAAAABIHAAQAEQcLCgEBEgcABRQRBwsKAQESBwADABUHCwoBAQkAK2NHZkhpQzZLZ2czRnBGWnZnd0djc3dzQ1J0cDRhQlAyZnp1WFJRUGl6dU4MEBMODwECAwQGEBURAA0LEgcY+MaekeF1h8hAS0wAAAAAAEBLTAAAAAAACwMEBQAJA0BLTAAAAAAA
+    """
+
+    // MARK: - Tests
+
+    @Test("The real pool account yields the fee recipient the program enforces")
+    func poolAccount_parsesDeployedFeeRecipient() throws {
+        let data = try #require(Data(base64Encoded: Self.poolAccountBase64))
+        let pool = try #require(CoinbaseStableSwapperProgram.PoolAccount(accountData: data))
+        #expect(pool.feeRecipient == (try PublicKey(base58: "4ZnFXk7KyB5khDqjWSHqHBQH1nQCnmvkr1pRFivWcP7e")))
+    }
+
+    @Test("Pool bytes through to encoded transaction produce the simulated byte sequence")
+    func depositTransaction_encodesToFixture() throws {
+        let data = try #require(Data(base64Encoded: Self.poolAccountBase64))
+        let pool = try #require(CoinbaseStableSwapperProgram.PoolAccount(accountData: data))
+
+        let instructions = SwapInstructionBuilder.buildUsdcToUsdfSwapInstructions(
+            sender: Self.sender,
+            owner: Self.owner,
+            amount: Self.amount,
+            pool: .coinbaseStableSwapper(feeRecipient: pool.feeRecipient),
+            swapId: Self.swapId,
+            destination: .vmDeposit
+        )
+
+        let transaction = SolanaTransaction(
+            payer: Self.sender,
+            recentBlockhash: Self.blockhash,
+            instructions: instructions
+        )
+
+        #expect(instructions.count == 8)
+        #expect(transaction.encode() == (try #require(Data(base64Encoded: Self.expectedBase64))))
+    }
+
+    @Test("The encoded transaction fits in a single packet")
+    func depositTransaction_fitsPacketLimit() throws {
+        let data = try #require(Data(base64Encoded: Self.expectedBase64))
+        #expect(data.count <= 1232)
+    }
+}

FlipcashCore/Tests/FlipcashCoreTests/CoinbaseStableSwapperPoolAccountTests.swift

@@ -5,21 +5,36 @@ import Testing
 @Suite("CoinbaseStableSwapperProgram.PoolAccount")
 struct CoinbaseStableSwapperPoolAccountTests {
 
-    /// Minimum account length: 8 discriminator + 32 ops authority
-    /// + 32 pause authority + 32 fee recipient.
-    private static let minimumLength = 8 + 32 + 32 + 32
-
-    private static func accountData(feeRecipient: [UInt8], trailing: Int = 0) -> Data {
-        var data = Data(repeating: 0xAA, count: 8)          // discriminator
-        data.append(Data(repeating: 0xBB, count: 32))       // operations authority
-        data.append(Data(repeating: 0xCC, count: 32))       // pause authority
+    /// `sha256("account:LiquidityPool")[0..8]` — the real Anchor discriminator for this account.
+    private static let discriminator: [UInt8] = [66, 38, 17, 64, 188, 80, 68, 129]
+
+    /// Minimum account length: 8 discriminator + 32 operations authority + 32 pause authority
+    /// + 32 unnamed pubkey + 32 unnamed pubkey + 32 fee recipient.
+    private static let minimumLength = 8 + 32 + 32 + 32 + 32 + 32
+
+    /// Base64 of the first 168 bytes (discriminator through `fee_recipient`) of the real
+    /// pool account `CrDL9SoCyW1tBgn8k7rgGSpWhnszneWDbvKvqPAU4PL9`, captured from mainnet.
+    private static let realCapturedAccountDataBase64 = """
+    QiYRQLxQRIEFHqE9vluQFKO1wbEwnd22aRe9qGrV03SIsz1AV7GqT/yEzcR/f+ALaKG4KMxbBfZ5dTNFPqxxZHMfbTqNfj6St0p++yObz2IILMcKsoko07O+oRSDek7YwzrH9TroL1+QbHdT/t9qpcq4Kyx8OPWZm79AIUM9UlN+X6ujF0hPgzT4z8SXtrVTfBhZj7LzSPTgCpHoi6cjfPqXvflOJvRB
+    """
+
+    private static func accountData(
+        feeRecipient: [UInt8],
+        discriminator: [UInt8] = Self.discriminator,
+        trailing: Int = 0
+    ) -> Data {
+        var data = Data(discriminator)
+        data.append(Data(repeating: 0xBB, count: 32))       // operations_authority
+        data.append(Data(repeating: 0xCC, count: 32))       // pause_authority
+        data.append(Data(repeating: 0xEE, count: 32))       // unnamed pubkey (offset 72)
+        data.append(Data(repeating: 0xFA, count: 32))       // unnamed pubkey (offset 104)
         data.append(Data(feeRecipient))
         data.append(Data(repeating: 0xDD, count: trailing))
         return data
     }
 
     @Test(
-        "Parses the fee recipient at offset 72, with or without trailing fields",
+        "Parses the fee recipient at offset 136, with or without trailing fields",
         arguments: [0, 128]
     )
     func initAccountData_validLayout_parsesFeeRecipient(trailing: Int) throws {
@@ -32,10 +47,28 @@ struct CoinbaseStableSwapperPoolAccountTests {
         #expect(account.feeRecipient == (try PublicKey(feeRecipientBytes)))
     }
 
+    @Test("Decodes the real pool account and recovers the correct fee recipient")
+    func initAccountData_realCapturedAccount_parsesFeeRecipient() throws {
+        let data = try #require(Data(base64Encoded: Self.realCapturedAccountDataBase64))
+        let account = try #require(CoinbaseStableSwapperProgram.PoolAccount(accountData: data))
+        #expect(account.feeRecipient == (try PublicKey(base58: "4ZnFXk7KyB5khDqjWSHqHBQH1nQCnmvkr1pRFivWcP7e")))
+    }
+
     @Test("Rejects account data shorter than the fee recipient bounds")
     func initAccountData_shortData_returnsNil() {
-        let short = Data(repeating: 0xAA, count: Self.minimumLength - 1)
-        #expect(CoinbaseStableSwapperProgram.PoolAccount(accountData: short) == nil)
+        let short = Self.accountData(feeRecipient: [UInt8](repeating: 7, count: 32))
+            .prefix(Self.minimumLength - 1)
+        #expect(CoinbaseStableSwapperProgram.PoolAccount(accountData: Data(short)) == nil)
+    }
+
+    @Test("Rejects a discriminator that doesn't match LiquidityPool")
+    func initAccountData_mismatchedDiscriminator_returnsNil() {
+        let wrongDiscriminator = [UInt8](repeating: 0, count: 8)
+        let data = Self.accountData(
+            feeRecipient: [UInt8](repeating: 7, count: 32),
+            discriminator: wrongDiscriminator
+        )
+        #expect(CoinbaseStableSwapperProgram.PoolAccount(accountData: data) == nil)
     }
 
     @Test("Ignores slice offsets — parses relative to the data's start")

FlipcashTests/WalletConnectionPoolResolutionTests.swift

@@ -12,8 +12,16 @@ import FlipcashCore
 @Suite("WalletConnection.resolveFundSwapPool")
 struct WalletConnectionPoolResolutionTests {
 
+    /// `sha256("account:LiquidityPool")[0..8]` — the real Anchor discriminator for this
+    /// account. `PoolAccount` rejects data that doesn't start with these bytes.
+    private nonisolated static let poolAccountDiscriminator: [UInt8] = [66, 38, 17, 64, 188, 80, 68, 129]
+
+    /// Fee recipient sits at offset 136: discriminator (8) + operations_authority (32)
+    /// + pause_authority (32) + two unnamed pubkeys (32 each) that the published IDL
+    /// does not describe.
     private nonisolated static func poolAccountData(feeRecipient: [UInt8]) -> Data {
-        var data = Data(repeating: 0, count: 8 + 32 + 32)
+        var data = Data(Self.poolAccountDiscriminator)
+        data.append(Data(repeating: 0, count: 32 + 32 + 32 + 32))
         data.append(Data(feeRecipient))
         return data
     }