Skip to content

[ENG-1188] Move parent subaccount transfer filtering to SQL to respect limit parameter #3234

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 6 commits into
base: main
Choose a base branch
from
Open

[ENG-1188] Move parent subaccount transfer filtering to SQL to respect limit parameter #3234

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
f01efaa
New SQL query for parentSubaccount transfer endpoint
davidli1997 Oct 30, 2025
100d95a
Add transfer table tests
davidli1997 Oct 30, 2025
c6c2278
Merge remote-tracking branch 'origin' into davidli/transfers_endpoint
davidli1997 Oct 31, 2025
27a2ba6
New transfer parentSubaccountNumber endpoint
davidli1997 Nov 5, 2025
33ba5b4
Done testing in staging
davidli1997 Nov 5, 2025
1e63100
Remove unused definition
davidli1997 Nov 5, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
354 changes: 354 additions & 0 deletions indexer/packages/postgres/__tests__/stores/transfer-table.test.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,6 +14,7 @@ import { seedData } from '../helpers/mock-generators';
import {
createdDateTime,
createdHeight,
defaultAddress,
defaultAsset,
defaultAsset2,
defaultDeposit,
Expand All @@ -29,6 +30,7 @@ import {
defaultTransfer3,
defaultWalletAddress,
defaultWithdrawal,
isolatedSubaccountId,
} from '../helpers/constants';
import Big from 'big.js';
import { CheckViolationError } from 'objection';
Expand Down Expand Up @@ -661,4 +663,356 @@ describe('Transfer store', () => {
expect(netTransfers).toEqual('0');
});
});

describe('findAllToOrFromParentSubaccount', () => {
beforeEach(async () => {
await seedData();
});

beforeAll(async () => {
await migrate();
});

afterEach(async () => {
await clearData();
});

afterAll(async () => {
await teardown();
});

it('Successfully excludes transfers between child subaccounts of the same parent', async () => {
// defaultSubaccount (subaccount 0) -> isolatedSubaccount (subaccount 128)
// Both have parent subaccount 0 (0 % 128 = 0, 128 % 128 = 0)
const sameParentTransfer: TransferCreateObject = {
senderSubaccountId: defaultSubaccountId,
recipientSubaccountId: isolatedSubaccountId,
assetId: defaultAsset.id,
size: '100',
eventId: defaultTendermintEventId,
transactionHash: '',
createdAt: createdDateTime.toISO(),
createdAtHeight: createdHeight,
};

// defaultSubaccount (parent 0) -> defaultSubaccount2 (parent 1)
const differentParentTransfer: TransferCreateObject = {
senderSubaccountId: defaultSubaccountId,
recipientSubaccountId: defaultSubaccountId2,
assetId: defaultAsset.id,
size: '200',
eventId: defaultTendermintEventId2,
transactionHash: '',
createdAt: createdDateTime.toISO(),
createdAtHeight: createdHeight,
};

await Promise.all([
TransferTable.create(sameParentTransfer),
TransferTable.create(differentParentTransfer),
]);

const subaccountIds = [defaultSubaccountId, isolatedSubaccountId];

const { results: transfers } = await TransferTable.findAllToOrFromParentSubaccount(
{
subaccountId: subaccountIds,
address: defaultAddress,
parentSubaccountNumber: 0,
limit: 100,
},
[],
);

expect(transfers.length).toEqual(1);
expect(transfers[0]).toEqual(expect.objectContaining(differentParentTransfer));
});

it('Successfully includes transfers from different addresses', async () => {
const crossAddressTransfer: TransferCreateObject = {
senderSubaccountId: defaultSubaccountId2,
recipientSubaccountId: defaultSubaccountId,
assetId: defaultAsset.id,
size: '150',
eventId: defaultTendermintEventId,
transactionHash: '',
createdAt: createdDateTime.toISO(),
createdAtHeight: createdHeight,
};

await TransferTable.create(crossAddressTransfer);

const { results: transfers } = await TransferTable.findAllToOrFromParentSubaccount(
{
subaccountId: [defaultSubaccountId],
address: defaultAddress,
parentSubaccountNumber: 0,
limit: 100,
},
[],
);

expect(transfers.length).toEqual(1);
expect(transfers[0]).toEqual(expect.objectContaining(crossAddressTransfer));
});

it('Successfully includes deposits to child subaccounts', async () => {
await WalletTable.create({
address: defaultWalletAddress,
totalTradingRewards: '0',
totalVolume: '0',
});

const deposit: TransferCreateObject = {
senderWalletAddress: defaultWalletAddress,
recipientSubaccountId: isolatedSubaccountId,
assetId: defaultAsset.id,
size: '500',
eventId: defaultTendermintEventId,
transactionHash: '',
createdAt: createdDateTime.toISO(),
createdAtHeight: createdHeight,
};

await TransferTable.create(deposit);

const { results: transfers } = await TransferTable.findAllToOrFromParentSubaccount(
{
subaccountId: [isolatedSubaccountId],
address: defaultAddress,
parentSubaccountNumber: 0,
limit: 100,
},
[],
);

expect(transfers.length).toEqual(1);
expect(transfers[0]).toEqual(expect.objectContaining(deposit));
});

it('Successfully includes withdrawals from child subaccounts', async () => {
await WalletTable.create({
address: defaultWalletAddress,
totalTradingRewards: '0',
totalVolume: '0',
});

const withdrawal: TransferCreateObject = {
senderSubaccountId: isolatedSubaccountId,
recipientWalletAddress: defaultWalletAddress,
assetId: defaultAsset.id,
size: '300',
eventId: defaultTendermintEventId,
transactionHash: '',
createdAt: createdDateTime.toISO(),
createdAtHeight: createdHeight,
};

await TransferTable.create(withdrawal);

const { results: transfers } = await TransferTable.findAllToOrFromParentSubaccount(
{
subaccountId: [isolatedSubaccountId],
address: defaultAddress,
parentSubaccountNumber: 0,
limit: 100,
},
[],
);

expect(transfers.length).toEqual(1);
expect(transfers[0]).toEqual(expect.objectContaining(withdrawal));
});

// it('Successfully respects limit parameter', async () => {
// const transfers: TransferCreateObject[] = [];
// for (let i = 0; i < 5; i++) {
// const eventIdBuffer = Buffer.from(defaultTendermintEventId);
// eventIdBuffer.writeUInt32BE(i, eventIdBuffer.length - 4);

// transfers.push({
// senderSubaccountId: defaultSubaccountId,
// recipientSubaccountId: defaultSubaccountId2,
// assetId: defaultAsset.id,
// size: `${i + 1}`,
// eventId: eventIdBuffer,
// transactionHash: `hash${i}`,
// createdAt: createdDateTime.plus({ minutes: i }).toISO(),
// createdAtHeight: (parseInt(createdHeight, 10) + i).toString(),
// });
// }

// await Promise.all(transfers.map((t) => TransferTable.create(t)));

// const { results: resultTransfers } = await TransferTable.findAllToOrFromParentSubaccount(
// {
// subaccountId: [defaultSubaccountId],
// address: defaultAddress,
// parentSubaccountNumber: 0,
// limit: 3,
// },
// [],
// );

// expect(resultTransfers.length).toEqual(3);
// });

// it('Successfully finds all transfers to and from parent subaccount using pagination', async () => {
// const transfers: TransferCreateObject[] = [];
// for (let i = 0; i < 4; i++) {
// const eventIdBuffer = Buffer.from(defaultTendermintEventId);
// eventIdBuffer.writeUInt32BE(i, eventIdBuffer.length - 4);

// transfers.push({
// senderSubaccountId: defaultSubaccountId,
// recipientSubaccountId: defaultSubaccountId2,
// assetId: defaultAsset.id,
// size: `${i + 1}`,
// eventId: eventIdBuffer,
// transactionHash: `hash${i}`,
// createdAt: createdDateTime.plus({ minutes: i }).toISO(),
// createdAtHeight: (parseInt(createdHeight, 10) + i).toString(),
// });
// }

// await Promise.all(transfers.map((t) => TransferTable.create(t)));

// const responsePageOne = await TransferTable.findAllToOrFromParentSubaccount(
// {
// subaccountId: [defaultSubaccountId],
// address: defaultAddress,
// parentSubaccountNumber: 0,
// limit: 2,
// page: 1,
// },
// [],
// { orderBy: [[TransferColumns.id, Ordering.ASC]] },
// );

// expect(responsePageOne.results.length).toEqual(2);
// expect(responsePageOne.offset).toEqual(0);
// expect(responsePageOne.total).toEqual(4);
// expect(responsePageOne.limit).toEqual(2);

// const responsePageTwo = await TransferTable.findAllToOrFromParentSubaccount(
// {
// subaccountId: [defaultSubaccountId],
// address: defaultAddress,
// parentSubaccountNumber: 0,
// limit: 2,
// page: 2,
// },
// [],
// { orderBy: [[TransferColumns.id, Ordering.ASC]] },
// );

// expect(responsePageTwo.results.length).toEqual(2);
// expect(responsePageTwo.offset).toEqual(2);
// expect(responsePageTwo.total).toEqual(4);
// expect(responsePageTwo.limit).toEqual(2);
// });

it('Successfully finds all transfers before or at the height', async () => {
const transfer1: TransferCreateObject = {
senderSubaccountId: defaultSubaccountId,
recipientSubaccountId: defaultSubaccountId2,
assetId: defaultAsset.id,
size: '100',
eventId: defaultTendermintEventId,
transactionHash: '',
createdAt: createdDateTime.toISO(),
createdAtHeight: '10',
};

const transfer2: TransferCreateObject = {
senderSubaccountId: defaultSubaccountId,
recipientSubaccountId: defaultSubaccountId2,
assetId: defaultAsset.id,
size: '200',
eventId: defaultTendermintEventId2,
transactionHash: '',
createdAt: createdDateTime.plus({ minutes: 1 }).toISO(),
createdAtHeight: '20',
};

await Promise.all([
TransferTable.create(transfer1),
TransferTable.create(transfer2),
]);

const { results: transfers } = await TransferTable.findAllToOrFromParentSubaccount(
{
subaccountId: [defaultSubaccountId],
address: defaultAddress,
parentSubaccountNumber: 0,
limit: 100,
createdBeforeOrAtHeight: '10',
},
[],
);

expect(transfers.length).toEqual(1);
expect(transfers[0]).toEqual(expect.objectContaining(transfer1));
});

it('Successfully finds all transfers before or at the time', async () => {
const createdAt1 = '2000-01-01T00:00:00.000Z';
const createdAt2 = '2000-01-02T00:00:00.000Z';

const transfer1: TransferCreateObject = {
senderSubaccountId: defaultSubaccountId,
recipientSubaccountId: defaultSubaccountId2,
assetId: defaultAsset.id,
size: '100',
eventId: defaultTendermintEventId,
transactionHash: '',
createdAt: createdAt1,
createdAtHeight: createdHeight,
};

const transfer2: TransferCreateObject = {
senderSubaccountId: defaultSubaccountId,
recipientSubaccountId: defaultSubaccountId2,
assetId: defaultAsset.id,
size: '200',
eventId: defaultTendermintEventId2,
transactionHash: '',
createdAt: createdAt2,
createdAtHeight: (parseInt(createdHeight, 10) + 1).toString(),
};

await Promise.all([
TransferTable.create(transfer1),
TransferTable.create(transfer2),
]);

const { results: transfers } = await TransferTable.findAllToOrFromParentSubaccount(
{
subaccountId: [defaultSubaccountId],
address: defaultAddress,
parentSubaccountNumber: 0,
limit: 100,
createdBeforeOrAt: createdAt1,
},
[],
);

expect(transfers.length).toEqual(1);
expect(transfers[0]).toEqual(expect.objectContaining(transfer1));
});

it('Successfully returns empty results when no transfers match criteria', async () => {
const { results: transfers } = await TransferTable.findAllToOrFromParentSubaccount(
{
subaccountId: [defaultSubaccountId],
address: defaultAddress,
parentSubaccountNumber: 0,
limit: 100,
},
[],
);

expect(transfers.length).toEqual(0);
});
});
});
Loading
Loading