Skip to content

Commit

Permalink
Improve the ts-sdk testing setup (#448)
Browse files Browse the repository at this point in the history
* Improve the ts-sdk testing setup

* Remove unused files

* Lint
  • Loading branch information
wjthieme authored Nov 5, 2024
1 parent ed6ad5b commit bdbd6ad
Show file tree
Hide file tree
Showing 9 changed files with 659 additions and 564 deletions.
123 changes: 34 additions & 89 deletions ts-sdk/whirlpool/tests/e2e.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -7,87 +7,37 @@ import {
openFullRangePositionInstructions,
increaseLiquidityInstructions,
} from "../src/increaseLiquidity";
import {
TOKEN_MINT_1,
TOKEN_MINT_2,
sendTransaction,
rpc,
initPayer,
setAccount,
} from "./mockRpc";
import { setDefaultFunder, SPLASH_POOL_TICK_SPACING } from "../src/config";
import { sendTransaction, rpc } from "./utils/mockRpc";
import { SPLASH_POOL_TICK_SPACING } from "../src/config";
import { swapInstructions } from "../src/swap";
import type { Address, TransactionSigner } from "@solana/web3.js";
import type { Address } from "@solana/web3.js";
import { harvestPositionInstructions } from "../src/harvest";
import {
decreaseLiquidityInstructions,
closePositionInstructions,
} from "../src/decreaseLiquidity";
import {
AccountState,
fetchToken,
findAssociatedTokenPda,
getTokenEncoder,
TOKEN_PROGRAM_ADDRESS,
} from "@solana-program/token";
import { fetchToken } from "@solana-program/token";
import {
fetchPosition,
fetchWhirlpool,
getPositionAddress,
} from "@orca-so/whirlpools-client";
import assert from "assert";
import { setupAta, setupMint } from "./utils/token";
import { orderMints } from "../src/token";

describe("e2e", () => {
let mintA: Address;
let mintB: Address;
let ataA: Address;
let ataB: Address;
let payer: TransactionSigner;

beforeAll(async () => {
payer = await initPayer();
setDefaultFunder(payer);

[ataA, ataB] = await Promise.all([
findAssociatedTokenPda({
mint: TOKEN_MINT_1,
owner: payer.address,
tokenProgram: TOKEN_PROGRAM_ADDRESS,
}).then((x) => x[0]),
findAssociatedTokenPda({
mint: TOKEN_MINT_2,
owner: payer.address,
tokenProgram: TOKEN_PROGRAM_ADDRESS,
}).then((x) => x[0]),
]);

setAccount(
ataA,
getTokenEncoder().encode({
mint: TOKEN_MINT_1,
owner: payer.address,
amount: 500e9,
delegate: null,
state: AccountState.Initialized,
isNative: null,
delegatedAmount: 0,
closeAuthority: null,
}),
TOKEN_PROGRAM_ADDRESS,
);

setAccount(
ataB,
getTokenEncoder().encode({
mint: TOKEN_MINT_2,
owner: payer.address,
amount: 500e9,
delegate: null,
state: AccountState.Initialized,
isNative: null,
delegatedAmount: 0,
closeAuthority: null,
}),
TOKEN_PROGRAM_ADDRESS,
);
const mint1 = await setupMint({ decimals: 9 });
const mint2 = await setupMint({ decimals: 6 });
[mintA, mintB] = orderMints(mint1, mint2);
ataA = await setupAta(mintA, { amount: 500e9 });
ataB = await setupAta(mintB, { amount: 500e9 });
});

const fetchPositionByMint = async (positionMint: Address) => {
Expand All @@ -97,30 +47,25 @@ describe("e2e", () => {

const testInitSplashPool = async () => {
const { instructions: createPoolInstructions, poolAddress } =
await createSplashPoolInstructions(rpc, TOKEN_MINT_1, TOKEN_MINT_2);
await sendTransaction(createPoolInstructions, payer);
await createSplashPoolInstructions(rpc, mintA, mintB);
await sendTransaction(createPoolInstructions);

const pool = await fetchWhirlpool(rpc, poolAddress);
assert.strictEqual(pool.data.tokenMintA, TOKEN_MINT_1);
assert.strictEqual(pool.data.tokenMintB, TOKEN_MINT_2);
assert.strictEqual(pool.data.tokenMintA, mintA);
assert.strictEqual(pool.data.tokenMintB, mintB);
assert.strictEqual(pool.data.tickSpacing, SPLASH_POOL_TICK_SPACING);

return poolAddress;
};

const testInitConcentratedLiquidityPool = async () => {
const { instructions: createPoolInstructions, poolAddress } =
await createConcentratedLiquidityPoolInstructions(
rpc,
TOKEN_MINT_1,
TOKEN_MINT_2,
128,
);
await sendTransaction(createPoolInstructions, payer);
await createConcentratedLiquidityPoolInstructions(rpc, mintA, mintB, 128);
await sendTransaction(createPoolInstructions);

const pool = await fetchWhirlpool(rpc, poolAddress);
assert.strictEqual(pool.data.tokenMintA, TOKEN_MINT_1);
assert.strictEqual(pool.data.tokenMintB, TOKEN_MINT_2);
assert.strictEqual(pool.data.tokenMintA, mintA);
assert.strictEqual(pool.data.tokenMintB, mintB);
assert.strictEqual(pool.data.tickSpacing, 128);

return poolAddress;
Expand All @@ -134,7 +79,7 @@ describe("e2e", () => {
await openFullRangePositionInstructions(rpc, poolAddress, {
liquidity: 1000000000n,
});
await sendTransaction(instructions, payer);
await sendTransaction(instructions);

const positionAfter = await fetchPositionByMint(positionMint);
const tokenAAfter = await fetchToken(rpc, ataA);
Expand Down Expand Up @@ -162,7 +107,7 @@ describe("e2e", () => {
positionMint,
{ liquidity: 10000n },
);
await sendTransaction(instructions, payer);
await sendTransaction(instructions);

const positionAfter = await fetchPositionByMint(positionMint);
const tokenAAfter = await fetchToken(rpc, ataA);
Expand Down Expand Up @@ -191,7 +136,7 @@ describe("e2e", () => {
positionMint,
{ liquidity: 10000n },
);
await sendTransaction(instructions, payer);
await sendTransaction(instructions);

const positionAfter = await fetchPositionByMint(positionMint);
const tokenAAfter = await fetchToken(rpc, ataA);
Expand All @@ -218,7 +163,7 @@ describe("e2e", () => {
rpc,
positionMint,
);
await sendTransaction(instructions, payer);
await sendTransaction(instructions);

const tokenAAfter = await fetchToken(rpc, ataA);
const tokenBAfter = await fetchToken(rpc, ataB);
Expand All @@ -241,7 +186,7 @@ describe("e2e", () => {
positionMint,
{ liquidity: 1000000000n },
);
await sendTransaction(instructions, payer);
await sendTransaction(instructions);

const positionAfter = await rpc.getMultipleAccounts([positionMint]).send();
const tokenAAfter = await fetchToken(rpc, ataA);
Expand All @@ -263,10 +208,10 @@ describe("e2e", () => {

const { instructions, quote } = await swapInstructions(
rpc,
{ inputAmount: 100n, mint: TOKEN_MINT_1 },
{ inputAmount: 100n, mint: mintA },
poolAddress,
);
await sendTransaction(instructions, payer);
await sendTransaction(instructions);

const tokenAAfter = await fetchToken(rpc, ataA);
const tokenBAfter = await fetchToken(rpc, ataB);
Expand All @@ -287,10 +232,10 @@ describe("e2e", () => {

const { instructions, quote } = await swapInstructions(
rpc,
{ outputAmount: 100n, mint: TOKEN_MINT_1 },
{ outputAmount: 100n, mint: mintA },
poolAddress,
);
await sendTransaction(instructions, payer);
await sendTransaction(instructions);

const tokenAAfter = await fetchToken(rpc, ataA);
const tokenBAfter = await fetchToken(rpc, ataB);
Expand All @@ -311,10 +256,10 @@ describe("e2e", () => {

const { instructions, quote } = await swapInstructions(
rpc,
{ inputAmount: 100000n, mint: TOKEN_MINT_2 },
{ inputAmount: 100000n, mint: mintB },
poolAddress,
);
await sendTransaction(instructions, payer);
await sendTransaction(instructions);

const tokenAAfter = await fetchToken(rpc, ataA);
const tokenBAfter = await fetchToken(rpc, ataB);
Expand All @@ -335,10 +280,10 @@ describe("e2e", () => {

const { instructions, quote } = await swapInstructions(
rpc,
{ outputAmount: 100000n, mint: TOKEN_MINT_2 },
{ outputAmount: 100000n, mint: mintB },
poolAddress,
);
await sendTransaction(instructions, payer);
await sendTransaction(instructions);

const tokenAAfter = await fetchToken(rpc, ataA);
const tokenBAfter = await fetchToken(rpc, ataB);
Expand Down
90 changes: 87 additions & 3 deletions ts-sdk/whirlpool/tests/pool.test.ts
Original file line number Diff line number Diff line change
@@ -1,5 +1,89 @@
import { describe } from "vitest";
import { describe, it, beforeAll } from "vitest";
import {
fetchConcentratedLiquidityPool,
fetchSplashPool,
fetchWhirlpoolsByTokenPair,
} from "../src/pool";
import { rpc } from "./utils/mockRpc";
import assert from "assert";
import {
SPLASH_POOL_TICK_SPACING,
WHIRLPOOLS_CONFIG_ADDRESS,
} from "../src/config";
import type { Address } from "@solana/web3.js";
import { setupMint } from "./utils/token";
import { setupWhirlpool } from "./utils/program";
import { getWhirlpoolAddress } from "@orca-so/whirlpools-client";
import { orderMints } from "../src/token";

describe.skip("Fetch Pool", () => {
// TODO: <-
describe("Fetch Pool", () => {
let mintA: Address;
let mintB: Address;
let defaultPool: Address;
let concentratedPool: Address;
let splashPool: Address;

beforeAll(async () => {
const mint1 = await setupMint();
const mint2 = await setupMint();
[mintA, mintB] = orderMints(mint1, mint2);
concentratedPool = await setupWhirlpool(mintA, mintB, 64);
defaultPool = await getWhirlpoolAddress(
WHIRLPOOLS_CONFIG_ADDRESS,
mintA,
mintB,
128,
).then((x) => x[0]);
splashPool = await setupWhirlpool(mintA, mintB, SPLASH_POOL_TICK_SPACING);
});

it("Should be able to fetch a splash pool", async () => {
const pool = await fetchSplashPool(rpc, mintA, mintB);
assert.strictEqual(pool.initialized, true);
assert.strictEqual(pool.liquidity, 0n);
assert.strictEqual(pool.tickSpacing, SPLASH_POOL_TICK_SPACING);
assert.strictEqual(pool.address, splashPool);
assert.strictEqual(pool.tokenMintA, mintA);
assert.strictEqual(pool.tokenMintB, mintB);
assert.strictEqual(pool.feeRate, 1000);
assert.strictEqual(pool.protocolFeeRate, 100);
assert.strictEqual(pool.whirlpoolsConfig, WHIRLPOOLS_CONFIG_ADDRESS);
});

it("Should be able to fetch a concentrated liquidity pool", async () => {
const pool = await fetchConcentratedLiquidityPool(rpc, mintA, mintB, 64);
assert.strictEqual(pool.initialized, true);
assert.strictEqual(pool.liquidity, 0n);
assert.strictEqual(pool.tickSpacing, 64);
assert.strictEqual(pool.address, concentratedPool);
assert.strictEqual(pool.tokenMintA, mintA);
assert.strictEqual(pool.tokenMintB, mintB);
assert.strictEqual(pool.feeRate, 300);
assert.strictEqual(pool.protocolFeeRate, 100);
assert.strictEqual(pool.whirlpoolsConfig, WHIRLPOOLS_CONFIG_ADDRESS);
});

it("Should be able to try fetching a non-existent pool", async () => {
const pool = await fetchConcentratedLiquidityPool(rpc, mintA, mintB, 128);
assert.strictEqual(pool.initialized, false);
assert.strictEqual(pool.tickSpacing, 128);
assert.strictEqual(pool.address, defaultPool);
assert.strictEqual(pool.tokenMintA, mintA);
assert.strictEqual(pool.tokenMintB, mintB);
assert.strictEqual(pool.feeRate, 1000);
assert.strictEqual(pool.protocolFeeRate, 100);
assert.strictEqual(pool.whirlpoolsConfig, WHIRLPOOLS_CONFIG_ADDRESS);
});

// TODO: Enable this test once solana-bankrun exposes getProgramAccounts
it.skip("Should be able to fetch all pools for a pair", async () => {
const pools = await fetchWhirlpoolsByTokenPair(rpc, mintA, mintB);
assert.strictEqual(pools.length, 3);
assert.strictEqual(pools[0].initialized, true);
assert.strictEqual(pools[0].tickSpacing, 64);
assert.strictEqual(pools[1].initialized, true);
assert.strictEqual(pools[1].tickSpacing, SPLASH_POOL_TICK_SPACING);
assert.strictEqual(pools[2].initialized, false);
assert.strictEqual(pools[2].tickSpacing, 128);
});
});
50 changes: 47 additions & 3 deletions ts-sdk/whirlpool/tests/position.test.ts
Original file line number Diff line number Diff line change
@@ -1,5 +1,49 @@
import { describe } from "vitest";
import type { Address} from "@solana/web3.js";
import { generateKeyPairSigner } from "@solana/web3.js";
import { assert, beforeAll, describe, it } from "vitest";
import { setupAta, setupMint } from "./utils/token";
import {
setupPosition,
setupPositionBundle,
setupTEPosition,
setupWhirlpool,
} from "./utils/program";
import { SPLASH_POOL_TICK_SPACING } from "../src/config";
import { fetchPositionsForOwner } from "../src/position";
import { rpc, signer } from "./utils/mockRpc";
import { orderMints } from "../src/token";

describe.skip("Fetch Position", () => {
// TODO: <-
describe("Fetch Position", () => {
let mintA: Address;
let mintB: Address;
let pool: Address;
let splashPool: Address;

beforeAll(async () => {
const mint1 = await setupMint();
const mint2 = await setupMint();
[mintA, mintB] = orderMints(mint1, mint2);
await setupAta(mintA, { amount: 500e9 });
await setupAta(mintB, { amount: 500e9 });
pool = await setupWhirlpool(mintA, mintB, 128);
splashPool = await setupWhirlpool(mintA, mintB, SPLASH_POOL_TICK_SPACING);
await setupPosition(pool);
await setupPosition(splashPool);
await setupTEPosition(pool);
await setupPositionBundle(pool);
await setupPositionBundle(splashPool, [{}, {}]);
});

// TODO: enable this when solana-bankrun supports gpa
it.skip("Should fetch all positions for an address", async () => {
const positions = await fetchPositionsForOwner(rpc, signer.address);
assert.strictEqual(positions.length, 5);
});

// TODO: enable this when solana-bankrun supports gpa
it.skip("Should fetch no positions for a different address", async () => {
const other = await generateKeyPairSigner();
const positions = await fetchPositionsForOwner(rpc, other.address);
assert.strictEqual(positions.length, 0);
});
});
Loading

0 comments on commit bdbd6ad

Please sign in to comment.