@exponent-labs/exponent-sdk 0.9.0 → 0.9.2

package/src/exponentVaults/vaultTransactionBuilder.test.ts

@@ -0,0 +1,349 @@
+import { describe, expect, it, jest, beforeEach } from "@jest/globals"
+import {
+  AddressLookupTableAccount,
+  ComputeBudgetProgram,
+  Keypair,
+  PublicKey,
+  TransactionInstruction,
+  VersionedTransaction,
+} from "@solana/web3.js"
+
+import { VaultTransactionBuilder, type VaultTransactionBuilderConfig } from "./vaultTransactionBuilder"
+import type { LoopscalePreparedTransaction } from "./loopscale"
+
+jest.mock("./loopscale", () => ({
+  LoopscaleClient: jest.fn(),
+}))
+
+jest.mock("./vault-interaction", () => ({
+  buildSetupStatePriceRefreshInstructions: jest.fn(),
+  createVaultSyncTransactions: jest.fn(),
+  createVaultSyncTransaction: jest.fn(),
+  createStrategySetupContext: jest.fn(),
+}))
+
+const { LoopscaleClient: mockLoopscaleClient } = jest.requireMock("./loopscale") as {
+  LoopscaleClient: jest.Mock
+}
+const {
+  buildSetupStatePriceRefreshInstructions: mockBuildSetupStatePriceRefreshInstructions,
+  createVaultSyncTransactions: mockCreateVaultSyncTransactions,
+  createVaultSyncTransaction: mockCreateVaultSyncTransaction,
+  createStrategySetupContext: mockCreateStrategySetupContext,
+} = jest.requireMock("./vault-interaction") as {
+  buildSetupStatePriceRefreshInstructions: jest.Mock
+  createVaultSyncTransactions: jest.Mock
+  createVaultSyncTransaction: jest.Mock
+  createStrategySetupContext: jest.Mock
+}
+
+type LoopscaleResponseOptions = Parameters<VaultTransactionBuilder["addLoopscaleResponse"]>[1]
+const validLoopscaleOptions: LoopscaleResponseOptions = { label: "loopscale-step" }
+// @ts-expect-error Loopscale builder steps only accept label metadata.
+const invalidLoopscaleOptions: LoopscaleResponseOptions = { priorityFee: 123 }
+void invalidLoopscaleOptions
+
+function pk(seed: number): PublicKey {
+  return new PublicKey(Uint8Array.from({ length: 32 }, () => seed))
+}
+
+function ix(programId: PublicKey, dataSeed: number): TransactionInstruction {
+  return new TransactionInstruction({
+    programId,
+    keys: [],
+    data: Buffer.from([dataSeed]),
+  })
+}
+
+function createVault(overrides: Partial<VaultTransactionBuilderConfig> = {}): VaultTransactionBuilderConfig {
+  return {
+    vault: {
+      selfAddress: pk(10),
+      programId: pk(11),
+      state: {
+        addressLookupTable: pk(12),
+        squadsVault: pk(21),
+      },
+    } as any,
+    connection: {
+      getAddressLookupTable: jest.fn(async () => ({ value: null })),
+      getLatestBlockhash: jest.fn(async () => ({
+        blockhash: PublicKey.default.toBase58(),
+        lastValidBlockHeight: 123,
+      })),
+      sendTransaction: jest.fn(async () => "sig-123"),
+      confirmTransaction: jest.fn(async () => ({ value: { err: null } })),
+      getSlot: jest.fn(),
+    } as any,
+    signer: pk(20),
+    computeUnitLimit: 987_654,
+    heapFrameBytes: 256 * 1024,
+    ...overrides,
+  }
+}
+
+describe("VaultTransactionBuilder Loopscale integration", () => {
+  beforeEach(() => {
+    mockLoopscaleClient.mockClear()
+    const mockPrepareVaultTransactions = jest.fn()
+    const mockCoSign = jest.fn()
+    mockLoopscaleClient.mockImplementation((config) => ({
+      config,
+      prepareVaultTransactions: mockPrepareVaultTransactions,
+      coSign: mockCoSign,
+    }))
+    ;(mockLoopscaleClient as any).mockPrepareVaultTransactions = mockPrepareVaultTransactions
+    ;(mockLoopscaleClient as any).mockCoSign = mockCoSign
+    mockBuildSetupStatePriceRefreshInstructions.mockReset()
+    mockCreateVaultSyncTransactions.mockReset()
+    mockCreateVaultSyncTransaction.mockReset()
+    mockCreateStrategySetupContext.mockReset()
+    mockCreateStrategySetupContext.mockReturnValue({ kind: "shared-setup-context" })
+  })
+
+  it("narrows Loopscale step options to label-only metadata", () => {
+    expect(validLoopscaleOptions).toEqual({ label: "loopscale-step" })
+  })
+
+  it("uses builder defaults and injects price refresh only into local Loopscale-derived vault transactions", async () => {
+    const config = createVault()
+    const refreshIx = ix(config.vault.programId, 200)
+    const vaultSetupIx = ix(config.vault.programId, 1)
+    const localVaultIx = ix(config.vault.programId, 2)
+    const plainSetupIx = ix(pk(30), 3)
+    const coSignedIx = ix(pk(31), 4)
+    const rawAlt = pk(32)
+
+    const preparedTransactions: LoopscalePreparedTransaction[] = [
+      {
+        setupInstructions: [vaultSetupIx],
+        instructions: [localVaultIx],
+        signers: [],
+        addressLookupTableAddresses: [rawAlt],
+        requiresLoopscaleCoSign: false,
+      },
+      {
+        setupInstructions: [plainSetupIx],
+        instructions: [coSignedIx],
+        signers: [],
+        addressLookupTableAddresses: [rawAlt],
+        requiresLoopscaleCoSign: true,
+      },
+    ]
+
+    const mockPrepareVaultTransactions = (mockLoopscaleClient as any).mockPrepareVaultTransactions as jest.Mock
+    mockPrepareVaultTransactions.mockImplementation(async () => preparedTransactions)
+    mockBuildSetupStatePriceRefreshInstructions.mockImplementation(async () => [refreshIx])
+
+    const result = await VaultTransactionBuilder
+      .create(config)
+      .addLoopscaleResponse({ message: "", signatures: [] } as any, { label: "loop" })
+      .build()
+
+    expect(mockLoopscaleClient).toHaveBeenCalledTimes(1)
+    expect(mockLoopscaleClient).toHaveBeenCalledWith({
+      connection: config.connection,
+      userWallet: config.vault.state.squadsVault,
+      baseUrl: undefined,
+      debug: undefined,
+    })
+
+    expect(result.labels).toEqual(["loop-1-setup", "loop-1", "loop-2-setup", "loop-2"])
+
+    const firstSetup = result.transactionSets[0]!
+    expect(firstSetup.instructions).toEqual([
+      ComputeBudgetProgram.setComputeUnitLimit({ units: 987_654 }),
+      refreshIx,
+      vaultSetupIx,
+    ])
+    expect(firstSetup.addressLookupTableAddresses).toEqual([config.vault.state.addressLookupTable])
+    expect(firstSetup.coSignWithLoopscale).toBe(false)
+
+    const firstMain = result.transactionSets[1]!
+    expect(firstMain.instructions).toEqual([refreshIx, localVaultIx])
+    expect(firstMain.addressLookupTableAddresses).toEqual([rawAlt, config.vault.state.addressLookupTable])
+    expect(firstMain.coSignWithLoopscale).toBe(false)
+
+    const secondSetup = result.transactionSets[2]!
+    expect(secondSetup.instructions).toEqual([
+      ComputeBudgetProgram.setComputeUnitLimit({ units: 987_654 }),
+      plainSetupIx,
+    ])
+    expect(secondSetup.addressLookupTableAddresses).toEqual([config.vault.state.addressLookupTable])
+    expect(secondSetup.coSignWithLoopscale).toBe(false)
+
+    const secondMain = result.transactionSets[3]!
+    expect(secondMain.instructions).toEqual([coSignedIx])
+    expect(secondMain.addressLookupTableAddresses).toEqual([rawAlt])
+    expect(secondMain.coSignWithLoopscale).toBe(true)
+  })
+
+  it("only co-signs flagged transactions and forwards loopscale client config to build and send paths", async () => {
+    const payer = Keypair.generate()
+    const persistentAlt = pk(50)
+    const config = createVault({
+      vault: {
+        selfAddress: pk(10),
+        programId: pk(11),
+        state: {
+          addressLookupTable: persistentAlt,
+          squadsVault: pk(51),
+        },
+      } as any,
+      loopscale: {
+        baseUrl: "https://loopscale.test",
+        debug: true,
+      },
+    })
+
+    const localIx = ix(pk(40), 1)
+    const coSignedIx = ix(pk(41), 2)
+    const persistentAltAccount = new AddressLookupTableAccount({
+      key: persistentAlt,
+      state: {
+        deactivationSlot: 0n,
+        lastExtendedSlot: 0,
+        lastExtendedSlotStartIndex: 0,
+        authority: payer.publicKey,
+        addresses: [config.signer, localIx.programId, coSignedIx.programId],
+      },
+    })
+    ;(config.connection.getAddressLookupTable as jest.Mock).mockImplementation(async (address: PublicKey) => ({
+      value: address.equals(persistentAlt) ? persistentAltAccount : null,
+    }))
+
+    const mockPrepareVaultTransactions = (mockLoopscaleClient as any).mockPrepareVaultTransactions as jest.Mock
+    const mockCoSign = (mockLoopscaleClient as any).mockCoSign as jest.Mock
+    mockPrepareVaultTransactions.mockImplementation(async () => [
+      {
+        setupInstructions: [],
+        instructions: [localIx],
+        signers: [],
+        addressLookupTableAddresses: [],
+        requiresLoopscaleCoSign: false,
+      },
+      {
+        setupInstructions: [],
+        instructions: [coSignedIx],
+        signers: [],
+        addressLookupTableAddresses: [],
+        requiresLoopscaleCoSign: true,
+      },
+    ] satisfies LoopscalePreparedTransaction[])
+    mockBuildSetupStatePriceRefreshInstructions.mockImplementation(async () => [])
+    mockCoSign.mockImplementation(async (transaction: VersionedTransaction) => transaction)
+
+    const result = await VaultTransactionBuilder
+      .create(config)
+      .addLoopscaleResponse({ message: "", signatures: [] } as any, { label: "loop" })
+      .build()
+
+    const sendResult = await result.send({ signers: [payer] })
+
+    expect(mockLoopscaleClient).toHaveBeenNthCalledWith(1, {
+      connection: config.connection,
+      userWallet: config.vault.state.squadsVault,
+      baseUrl: "https://loopscale.test",
+      debug: true,
+    })
+    expect(mockLoopscaleClient).toHaveBeenNthCalledWith(2, {
+      connection: config.connection,
+      userWallet: config.vault.state.squadsVault,
+      baseUrl: "https://loopscale.test",
+      debug: true,
+    })
+    expect(mockCoSign).toHaveBeenCalledTimes(1)
+    expect((config.connection.sendTransaction as jest.Mock)).toHaveBeenCalledTimes(2)
+    expect(sendResult.signatures).toEqual(["sig-123", "sig-123"])
+    expect(sendResult.ephemeralAlt).toBeNull()
+  })
+})
+
+describe("VaultTransactionBuilder smart Kamino Vault withdraw fan-out", () => {
+  beforeEach(() => {
+    mockBuildSetupStatePriceRefreshInstructions.mockReset()
+    mockCreateVaultSyncTransactions.mockReset()
+    mockCreateStrategySetupContext.mockReset()
+    mockCreateStrategySetupContext.mockReturnValue({ kind: "shared-setup-context" })
+  })
+
+  it("splits a single instruction step into multiple sequential transaction sets when the sync helper returns chunks", async () => {
+    const config = createVault()
+    const refreshIx = ix(config.vault.programId, 90)
+    const setupIx = ix(config.vault.programId, 91)
+    const firstPreIx = ix(pk(60), 92)
+    const firstSyncIx = ix(pk(61), 93)
+    const secondSyncIx = ix(pk(62), 94)
+    const secondPostIx = ix(pk(63), 95)
+    const firstAlt = pk(64)
+    const secondAlt = pk(65)
+
+    mockBuildSetupStatePriceRefreshInstructions.mockImplementation(async () => [refreshIx])
+    mockCreateVaultSyncTransactions.mockImplementation(async () => [
+      {
+        setupInstructions: [setupIx],
+        preInstructions: [firstPreIx],
+        instruction: firstSyncIx,
+        postInstructions: [],
+        signers: [],
+        addressLookupTableAddresses: [firstAlt],
+      },
+      {
+        setupInstructions: [],
+        preInstructions: [],
+        instruction: secondSyncIx,
+        postInstructions: [secondPostIx],
+        signers: [],
+        addressLookupTableAddresses: [secondAlt],
+      },
+    ])
+
+    const result = await VaultTransactionBuilder
+      .create(config)
+      .addActions([{ action: "KAMINO_VAULT_WITHDRAW" } as any], { label: "withdraw" })
+      .build()
+
+    expect(mockCreateVaultSyncTransactions).toHaveBeenCalledTimes(1)
+    expect(result.labels).toEqual(["withdraw-1-setup", "withdraw-1", "withdraw-2"])
+
+    expect(result.transactionSets[0]).toEqual({
+      label: "withdraw-1-setup",
+      instructions: [
+        ComputeBudgetProgram.setComputeUnitLimit({ units: 987_654 }),
+        refreshIx,
+        setupIx,
+      ],
+      signers: [],
+      addressLookupTableAddresses: [firstAlt, config.vault.state.addressLookupTable],
+      coSignWithLoopscale: false,
+    })
+
+    expect(result.transactionSets[1]).toEqual({
+      label: "withdraw-1",
+      instructions: [
+        ComputeBudgetProgram.setComputeUnitLimit({ units: 987_654 }),
+        ComputeBudgetProgram.requestHeapFrame({ bytes: 256 * 1024 }),
+        refreshIx,
+        firstPreIx,
+        firstSyncIx,
+      ],
+      signers: [],
+      addressLookupTableAddresses: [firstAlt, config.vault.state.addressLookupTable],
+      coSignWithLoopscale: false,
+    })
+
+    expect(result.transactionSets[2]).toEqual({
+      label: "withdraw-2",
+      instructions: [
+        ComputeBudgetProgram.setComputeUnitLimit({ units: 987_654 }),
+        ComputeBudgetProgram.requestHeapFrame({ bytes: 256 * 1024 }),
+        refreshIx,
+        secondSyncIx,
+        secondPostIx,
+      ],
+      signers: [],
+      addressLookupTableAddresses: [secondAlt, config.vault.state.addressLookupTable],
+      coSignWithLoopscale: false,
+    })
+  })
+})