From b29ea2a15c2006112a4a80a8ea36da562e7a075e Mon Sep 17 00:00:00 2001 From: rabi-siddique Date: Fri, 13 Dec 2024 10:20:24 +0500 Subject: [PATCH 01/16] test: update tests --- src/mappings/constants.ts | 14 +++++++------- src/mappings/events/vaults.ts | 1 + src/mappings/mappingHandlers.ts | 3 +++ src/test/mappingHandlers.test.ts | 24 +++++++++++++----------- 4 files changed, 24 insertions(+), 18 deletions(-) diff --git a/src/mappings/constants.ts b/src/mappings/constants.ts index fcf843a6..97b9d91b 100644 --- a/src/mappings/constants.ts +++ b/src/mappings/constants.ts @@ -31,13 +31,13 @@ export const VAULT_STATES = { LIQUIDATED_CLOSED: 'liquidatedClosed', }; -export const VALUE_KEY = b64encode('value'); -export const STORE_KEY = b64encode('store'); -export const VSTORAGE_VALUE = b64encode('vstorage'); -export const KEY_KEY = b64encode('key'); -export const STORE_NAME_KEY = b64encode('store_name'); -export const SUBKEY_KEY = b64encode('store_subkey'); -export const UNPROVED_VALUE_KEY = b64encode('unproved_value'); +export const VALUE_KEY = 'value'; +export const STORE_KEY = 'store'; +export const VSTORAGE_VALUE = 'vstorage'; +export const KEY_KEY = 'key'; +export const STORE_NAME_KEY = 'store_name'; +export const SUBKEY_KEY = 'store_subkey'; +export const UNPROVED_VALUE_KEY = 'unproved_value'; export const PACKET_DATA_KEY = 'packet_data'; export const PACKET_SRC_CHANNEL_KEY = 'packet_src_channel'; export const PACKET_DST_CHANNEL_KEY = 'packet_dst_channel'; diff --git a/src/mappings/events/vaults.ts b/src/mappings/events/vaults.ts index 0528aa8d..70c241d8 100644 --- a/src/mappings/events/vaults.ts +++ b/src/mappings/events/vaults.ts @@ -34,6 +34,7 @@ export const vaultsEventKit = (block: any, data: any, module: string, path: stri } async function saveWallets(payload: any): Promise[]> { + logger.info(`PAYLOAD: ${JSON.stringify(payload)}`); const promises: Promise[] = []; const address = path.split('.')[2]; const wallet = new Wallet(path, BigInt(data.blockHeight), block.block.header.time as any, address); diff --git a/src/mappings/mappingHandlers.ts b/src/mappings/mappingHandlers.ts index 34978131..460e5e96 100644 --- a/src/mappings/mappingHandlers.ts +++ b/src/mappings/mappingHandlers.ts @@ -156,6 +156,9 @@ export async function handleBundleInstallMessage(message: CosmosMessage): Promis export async function handleStateChangeEvent(cosmosEvent: CosmosEvent): Promise { const { event, block } = cosmosEvent as CosmosEvent & { event: tendermint37.Event }; + logger.info(`EVENT ${JSON.stringify(event)}`); + logger.info(`EVENT TYPE:${event.type}`); + if (event.type != EVENT_TYPES.STATE_CHANGE) { logger.warn('Not valid state_change event.'); return; diff --git a/src/test/mappingHandlers.test.ts b/src/test/mappingHandlers.test.ts index ceb45065..c0697a51 100644 --- a/src/test/mappingHandlers.test.ts +++ b/src/test/mappingHandlers.test.ts @@ -4,26 +4,28 @@ import { StateChangeEvent, Wallet } from '../types'; // FIXME observed in A3P:latest but not passing tests subqlTest( - 'Wallet and StateChangeEvent in state_change at block 627', + 'StateChangeEvent in state_change at block 627', 627, // block height to process - [], // dependent entities + // dependent entities + [], [ new Wallet( - 'published.wallet.agoric1ee9hr0jyrxhy999y755mp862ljgycmwyp4pl7q', + 'published.wallet.agoric1rwwley550k9mmk6uq6mm6z4udrg8kyuyvfszjk.current', BigInt(627), - new Date('"2024-12-09T23:09:55.9Z"'), - 'agoric1ee9hr0jyrxhy999y755mp862ljgycmwyp4pl7q', + new Date('2024-12-09T23:07:18.273Z'), + 'agoric1rwwley550k9mmk6uq6mm6z4udrg8kyuyvfszjk', ), new StateChangeEvent( - '627:37:1', + '627:39:3', BigInt(627), - new Date('2024-12-09T23:09:55.9Z'), + new Date('2024-12-09T23:07:18.273Z'), 'published.wallet', - 'published.wallet.agoric1ee9hr0jyrxhy999y755mp862ljgycmwyp4pl7q', - 0, - '["board0257"]', - '{"status":{"id":"closeVault-1733785795438","invitationSpec":{"invitationMakerName":"CloseVault","previousOffer":"openVault-1733785785382","source":"continuing"},"numWantsSatisfied":1,"proposal":{"give":{"Minted":{"brand":"$0.Alleged: IST brand","value":"+5750000","__brand":"IST","__value":"5750000"}},"want":{}},"result":"your vault is closed, thank you for your business"},"updated":"offerStatus"}', + 'published.wallet.agoric1rwwley550k9mmk6uq6mm6z4udrg8kyuyvfszjk.current', + 3, + '["board05557","board0257","board0074",null,"board05815","board00360"]', + '{"liveOffers":[["openVault-1733785637736",{"id":"openVault-1733785637736","invitationSpec":{"callPipe":[["getCollateralManager",["$0.Alleged: ATOM brand"]],["makeVaultInvitation"]],"instancePath":["VaultFactory"],"source":"agoricContract"},"proposal":{"give":{"Collateral":{"brand":"$0","value":"+583000000","__brand":"ATOM","__value":"583000000"}},"want":{"Minted":{"brand":"$1.Alleged: IST brand","value":"+3489000000","__brand":"IST","__value":"3489000000"}}}}]],"offerToPublicSubscriberPaths":[["openVault-1733785637736",{"vault":"published.vaultFactory.managers.manager0.vaults.vault4"}]],"offerToUsedInvitation":[["openVault-1733785637736",{"brand":"$2.Alleged: Zoe Invitation brand","value":[{"description":"manager0: MakeVault","handle":"$3.Alleged: InvitationHandle","installation":"$4.Alleged: BundleIDInstallation","instance":"$5.Alleged: InstanceHandle","__handle":"InvitationHandle","__installation":"BundleIDInstallation","__instance":"InstanceHandle"}],"__brand":"Zoe Invitation"}]],"purses":[{"balance":{"brand":"$2","value":[],"__brand":"Zoe Invitation"},"brand":"$2","__brand":"Zoe Invitation"}]}', ), ], + 'handleStateChangeEvent', ); From 0970e1f2beb3e8d698cb2016dc45bd6f8c8398fe Mon Sep 17 00:00:00 2001 From: rabi-siddique Date: Fri, 13 Dec 2024 15:54:07 +0500 Subject: [PATCH 02/16] chore: remove encoding/decoding --- .github/workflows/pr.yaml | 2 +- docker-compose.yml | 2 +- package.json | 2 +- src/mappings/constants.ts | 16 +++++++--------- src/mappings/events/vaults.ts | 1 - src/mappings/mappingHandlers.ts | 11 ++--------- yarn.lock | 4 ++-- 7 files changed, 14 insertions(+), 24 deletions(-) diff --git a/.github/workflows/pr.yaml b/.github/workflows/pr.yaml index b3cb790e..7e5e2084 100644 --- a/.github/workflows/pr.yaml +++ b/.github/workflows/pr.yaml @@ -7,7 +7,7 @@ jobs: runs-on: ubuntu-latest services: a3p: - image: ghcr.io/agoric/agoric-3-proposals:latest + image: ghcr.io/agoric/agoric-3-proposals@sha256:644e09bf041e5588570ff9a49e6129cc468e9c8458417541027e8532cb91083b ports: - 26657:26657 postgres: diff --git a/docker-compose.yml b/docker-compose.yml index abe34630..ddd67f4f 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -16,7 +16,7 @@ services: retries: 5 subquery-node: - image: subquerynetwork/subql-node-cosmos:v3.12.0 + image: subquerynetwork/subql-node-cosmos:v4.2.1 depends_on: 'postgres': condition: service_healthy diff --git a/package.json b/package.json index fb463d05..2811b755 100644 --- a/package.json +++ b/package.json @@ -25,7 +25,7 @@ "devDependencies": { "@cosmjs/stargate": "^0.28.9", "@subql/cli": "^5.4.0", - "@subql/node-cosmos": "^4.2.1", + "@subql/node-cosmos": "4.2.1", "@subql/testing": "latest", "prettier": "^3.4.2", "starknet": "6.11.0", diff --git a/src/mappings/constants.ts b/src/mappings/constants.ts index 97b9d91b..61e630d7 100644 --- a/src/mappings/constants.ts +++ b/src/mappings/constants.ts @@ -1,5 +1,3 @@ -import { b64encode } from './utils'; - export const EVENT_TYPES = { ACTIVE_PROPOSAL: 'active_proposal', BURN: 'burn', @@ -43,11 +41,11 @@ export const PACKET_SRC_CHANNEL_KEY = 'packet_src_channel'; export const PACKET_DST_CHANNEL_KEY = 'packet_dst_channel'; export const PACKET_SRC_PORT_KEY = 'packet_src_port'; export const PACKET_DST_PORT_KEY = 'packet_dst_port'; -export const ACTION_KEY = b64encode('action'); -export const IBC_MESSAGE_TRANSFER_VALUE = b64encode('/ibc.applications.transfer.v1.MsgTransfer'); -export const IBC_MESSAGE_RECEIVE_PACKET_VALUE = b64encode('/ibc.core.channel.v1.MsgRecvPacket'); -export const RECEPIENT_KEY = b64encode('recipient'); -export const SENDER_KEY = b64encode('sender'); -export const RECEIVER_KEY = b64encode('receiver'); -export const AMOUNT_KEY = b64encode('amount'); +export const ACTION_KEY = 'action'; +export const IBC_MESSAGE_TRANSFER_VALUE = '/ibc.applications.transfer.v1.MsgTransfer'; +export const IBC_MESSAGE_RECEIVE_PACKET_VALUE = '/ibc.core.channel.v1.MsgRecvPacket'; +export const RECEPIENT_KEY = 'recipient'; +export const SENDER_KEY = 'sender'; +export const RECEIVER_KEY = 'receiver'; +export const AMOUNT_KEY = 'amount'; export const TRANSFER_PORT_VALUE = 'transfer'; diff --git a/src/mappings/events/vaults.ts b/src/mappings/events/vaults.ts index 70c241d8..0528aa8d 100644 --- a/src/mappings/events/vaults.ts +++ b/src/mappings/events/vaults.ts @@ -34,7 +34,6 @@ export const vaultsEventKit = (block: any, data: any, module: string, path: stri } async function saveWallets(payload: any): Promise[]> { - logger.info(`PAYLOAD: ${JSON.stringify(payload)}`); const promises: Promise[] = []; const address = path.split('.')[2]; const wallet = new Wallet(path, BigInt(data.blockHeight), block.block.header.time as any, address); diff --git a/src/mappings/mappingHandlers.ts b/src/mappings/mappingHandlers.ts index 460e5e96..17ff2ee7 100644 --- a/src/mappings/mappingHandlers.ts +++ b/src/mappings/mappingHandlers.ts @@ -156,9 +156,6 @@ export async function handleBundleInstallMessage(message: CosmosMessage): Promis export async function handleStateChangeEvent(cosmosEvent: CosmosEvent): Promise { const { event, block } = cosmosEvent as CosmosEvent & { event: tendermint37.Event }; - logger.info(`EVENT ${JSON.stringify(event)}`); - logger.info(`EVENT TYPE:${event.type}`); - if (event.type != EVENT_TYPES.STATE_CHANGE) { logger.warn('Not valid state_change event.'); return; @@ -183,8 +180,7 @@ export async function handleStateChangeEvent(cosmosEvent: CosmosEvent): Promise< let data = Object(); try { - const decodedValue = - valueAttr.key === UNPROVED_VALUE_KEY ? b64decode(b64decode(valueAttr.value)) : b64decode(valueAttr.value); + const decodedValue = valueAttr.key === UNPROVED_VALUE_KEY ? b64decode(valueAttr.value) : valueAttr.value; data = JSON.parse(decodedValue); } catch (e) { return; @@ -195,10 +191,7 @@ export async function handleStateChangeEvent(cosmosEvent: CosmosEvent): Promise< return; } - const decodedKey = - keyAttr.key === SUBKEY_KEY - ? b64decode(b64decode(keyAttr.value)).replaceAll('\u0000', '\x00') - : b64decode(keyAttr.value); + const decodedKey = keyAttr.key === SUBKEY_KEY ? b64decode(keyAttr.value).replaceAll('\u0000', '\x00') : keyAttr.value; const path = extractStoragePath(decodedKey); const module = getStateChangeModule(path); diff --git a/yarn.lock b/yarn.lock index af4f2afb..4c0e2d2d 100644 --- a/yarn.lock +++ b/yarn.lock @@ -3305,7 +3305,7 @@ __metadata: languageName: node linkType: hard -"@subql/node-cosmos@npm:^4.2.1": +"@subql/node-cosmos@npm:4.2.1": version: 4.2.1 resolution: "@subql/node-cosmos@npm:4.2.1" dependencies: @@ -4107,7 +4107,7 @@ __metadata: dependencies: "@cosmjs/stargate": "npm:^0.28.9" "@subql/cli": "npm:^5.4.0" - "@subql/node-cosmos": "npm:^4.2.1" + "@subql/node-cosmos": "npm:4.2.1" "@subql/testing": "npm:latest" "@subql/types-cosmos": "npm:^4.0.0" "@subql/utils": "npm:^2.17.0" From f9d7d2d200d39b9fd62a88e9ccb5c66d49d8c861 Mon Sep 17 00:00:00 2001 From: rabi-siddique Date: Mon, 16 Dec 2024 17:53:20 +0500 Subject: [PATCH 03/16] test: add tests for vault and reserve entities --- src/test/mappingHandlers.test.ts | 158 ++++++++++++++++++++++++++++++- 1 file changed, 155 insertions(+), 3 deletions(-) diff --git a/src/test/mappingHandlers.test.ts b/src/test/mappingHandlers.test.ts index c0697a51..971be57f 100644 --- a/src/test/mappingHandlers.test.ts +++ b/src/test/mappingHandlers.test.ts @@ -1,12 +1,22 @@ /** @file test against agoric-3-proposals:latest */ import { subqlTest } from '@subql/testing'; -import { StateChangeEvent, Wallet } from '../types'; +import { + ReserveAllocationMetrics, + ReserveAllocationMetricsDaily, + ReserveMetrics, + StateChangeEvent, + Vault, + VaultManagerGovernance, + VaultManagerMetrics, + VaultManagerMetricsDaily, + VaultStatesDaily, + Wallet, +} from '../types'; // FIXME observed in A3P:latest but not passing tests subqlTest( 'StateChangeEvent in state_change at block 627', - 627, // block height to process - // dependent entities + 627, [], [ new Wallet( @@ -29,3 +39,145 @@ subqlTest( 'handleStateChangeEvent', ); + +const vault = new Vault( + 'published.vaultFactory.managers.manager0.vaults.vault6', + BigInt(742), + new Date('2024-12-09 23:13:19.186'), + 'published.wallet.agoric1ee9hr0jyrxhy999y755mp862ljgycmwyp4pl7q.current', +); + +vault.balance = BigInt(788000000); +vault.lockedValue = BigInt(788000000); +vault.coin = 'ATOM'; +vault.denom = 'ATOM'; +vault.debt = BigInt(4745610000); +vault.state = 'active'; + +subqlTest( + 'Vault and VaultStateDailies at height 742', + 742, + [], + [ + vault, + new VaultStatesDaily( + '20241209', + BigInt(742), + new Date('2024-12-09 23:13:19.186'), + BigInt(1), + BigInt(0), + BigInt(0), + BigInt(0), + BigInt(0), + ), + ], + + 'handleStateChangeEvent', +); + +const reserveAllocationMetricsDaily = new ReserveAllocationMetricsDaily( + 'IST:20241216', + 'IST', + 20241216, + BigInt(1212), + new Date('2024-12-16T11:42:27.000Z'), +); + +reserveAllocationMetricsDaily.denom = 'IST'; +reserveAllocationMetricsDaily.key = 'Fee'; +reserveAllocationMetricsDaily.valueLast = BigInt(184980868); +reserveAllocationMetricsDaily.metricsCount = BigInt(1); + +const vaultManagerMetricsDaily = new VaultManagerMetricsDaily( + 'published.vaultFactory.managers.manager1.metrics:20241216', + 'published.vaultFactory.managers.manager1.metrics', + 20241216, + BigInt(1212), + new Date('2024-12-16 11:42:27.202'), +); + +vaultManagerMetricsDaily.liquidatingCollateralBrand = 'stATOM'; +vaultManagerMetricsDaily.liquidatingDebtBrand = 'IST'; +vaultManagerMetricsDaily.liquidatingCollateralValueLast = BigInt(0); +vaultManagerMetricsDaily.liquidatingDebtValueLast = BigInt(0); +vaultManagerMetricsDaily.lockedQuoteDenominatorLast = BigInt(0); +vaultManagerMetricsDaily.lockedQuoteNumeratorLast = BigInt(0); +vaultManagerMetricsDaily.numActiveVaultsLast = BigInt(0); +vaultManagerMetricsDaily.numLiquidatingVaultsLast = BigInt(0); +vaultManagerMetricsDaily.numLiquidationsAbortedLast = BigInt(0); +vaultManagerMetricsDaily.numLiquidationsCompletedLast = BigInt(0); +vaultManagerMetricsDaily.retainedCollateralLast = BigInt(0); +vaultManagerMetricsDaily.totalCollateralLast = BigInt(0); +vaultManagerMetricsDaily.totalCollateralSoldLast = BigInt(0); +vaultManagerMetricsDaily.totalDebtLast = BigInt(0); +vaultManagerMetricsDaily.totalOverageReceivedLast = BigInt(0); +vaultManagerMetricsDaily.totalProceedsReceivedLast = BigInt(0); +vaultManagerMetricsDaily.totalShortfallReceivedLast = BigInt(0); +vaultManagerMetricsDaily.metricsCount = BigInt(1); + +subqlTest( + 'VaultManagerGovernance, VaultManagerMetrics, VaultManagerMetricsDaily, ReserveMetrics, \ + ReserveAllocationMetrics, and ReserveAllocationMetricsDaily at block height 1212', + 1212, + [], + [ + new VaultManagerGovernance( + 'published.vaultFactory.managers.manager1.governance', + BigInt(1212), + new Date('2024-12-16 11:42:27.202'), + BigInt(1000000000), + BigInt(100), + BigInt(1), + BigInt(100), + BigInt(150), + BigInt(100), + BigInt(25), + BigInt(100), + BigInt(1), + BigInt(10000), + BigInt(50), + ), + new VaultManagerMetrics( + 'published.vaultFactory.managers.manager1.metrics', + BigInt(1212), + new Date('2024-12-16 11:42:27.202'), + 'stATOM', + BigInt(0), + 'IST', + BigInt(0), + BigInt(0), + BigInt(0), + BigInt(0), + BigInt(0), + BigInt(0), + BigInt(0), + BigInt(0), + BigInt(0), + BigInt(0), + BigInt(0), + BigInt(0), + BigInt(0), + BigInt(0), + ), + vaultManagerMetricsDaily, + new ReserveMetrics( + 'published.reserve.metrics', + BigInt(1212), + new Date('2024-12-16T11:42:27.202Z'), + BigInt(0), + BigInt(0), + BigInt(0), + ), + new ReserveAllocationMetrics( + 'IST', + BigInt(1212), + new Date('2024-12-16T11:42:27.202Z'), + 'IST', + 'Fee', + BigInt(184980868), + 'published.reserve.metrics', + ), + reserveAllocationMetricsDaily, + ], + 'handleStateChangeEvent', +); From 349741a16c1437ea0138cd076453e479afb1febb Mon Sep 17 00:00:00 2001 From: rabi-siddique Date: Mon, 16 Dec 2024 19:06:44 +0500 Subject: [PATCH 04/16] test: add tests for boardaux, oraclePriceDaily and PsmMetricsDaily --- src/test/mappingHandlers.test.ts | 80 ++++++++++++++++++++++++++++++++ 1 file changed, 80 insertions(+) diff --git a/src/test/mappingHandlers.test.ts b/src/test/mappingHandlers.test.ts index 971be57f..990e1f7b 100644 --- a/src/test/mappingHandlers.test.ts +++ b/src/test/mappingHandlers.test.ts @@ -1,6 +1,9 @@ /** @file test against agoric-3-proposals:latest */ import { subqlTest } from '@subql/testing'; import { + BoardAux, + OraclePriceDaily, + PsmMetricsDaily, ReserveAllocationMetrics, ReserveAllocationMetricsDaily, ReserveMetrics, @@ -181,3 +184,80 @@ subqlTest( ], 'handleStateChangeEvent', ); + +subqlTest( + 'BoardAux at block 643', + 643, + [], + [ + new BoardAux( + 'published.boardAux.board0074', + BigInt(643), + new Date('2024-12-09T23:07:37.423Z'), + 'Zoe Invitation', + 'set', + 0, + ), + new BoardAux( + 'published.boardAux.board01744', + BigInt(643), + new Date('2024-12-09T23:07:37.423Z'), + 'USDT_axl', + 'nat', + 6, + ), + new BoardAux('published.boardAux.board0257', BigInt(643), new Date('2024-12-09T23:07:37.423Z'), 'IST', 'nat', 6), + new BoardAux( + 'published.boardAux.board03040', + BigInt(643), + new Date('2024-12-09T23:07:37.423Z'), + 'USDC_axl', + 'nat', + 6, + ), + ], + + 'handleStateChangeEvent', +); + +const oraclePriceDaily = new OraclePriceDaily( + 'ATOM-USD:20241209', + 20241209, + BigInt(506), + new Date('2024-12-09T23:03:17.000Z'), +); + +oraclePriceDaily.typeInAmountLast = BigInt(1000000); +oraclePriceDaily.typeInAmountSum = BigInt(1000000); +oraclePriceDaily.typeOutAmountLast = BigInt(12010000); +oraclePriceDaily.typeOutAmountSum = BigInt(12010000); +oraclePriceDaily.typeInName = 'ATOM'; +oraclePriceDaily.typeOutName = 'USD'; +oraclePriceDaily.metricsCount = BigInt(1); + +subqlTest( + 'oraclePriceDaily at block 506', + 506, + [], + [oraclePriceDaily], + + 'handleStateChangeEvent', +); + +const psmMetricsDaily = new PsmMetricsDaily( + 'published.psm.IST.USDC_axl.metrics:20241207', + 'published.psm.IST.USDC_axl.metrics', + 20241207, + BigInt(35), + new Date('2024-12-07T02:03:32.000Z'), +); + +psmMetricsDaily.denom = 'USDC_axl'; +psmMetricsDaily.anchorPoolBalanceLast = BigInt(0); +psmMetricsDaily.feePoolBalanceLast = BigInt(0); +psmMetricsDaily.mintedPoolBalanceLast = BigInt(0); +psmMetricsDaily.totalAnchorProvidedLast = BigInt(0); +psmMetricsDaily.totalMintedProvidedLast = BigInt(0); +psmMetricsDaily.metricsCount = BigInt(1); + +subqlTest('psmMetricsDaily at block 35', 35, [], [psmMetricsDaily], 'handleStateChangeEvent'); From 217c4f5a368346732122aadd686cfbbdd969a5b7 Mon Sep 17 00:00:00 2001 From: Fraz Arshad Date: Mon, 16 Dec 2024 20:48:01 +0500 Subject: [PATCH 05/16] test: bundle install test --- src/test/installBundleHandler.test.ts | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 src/test/installBundleHandler.test.ts diff --git a/src/test/installBundleHandler.test.ts b/src/test/installBundleHandler.test.ts new file mode 100644 index 00000000..698a52a9 --- /dev/null +++ b/src/test/installBundleHandler.test.ts @@ -0,0 +1,21 @@ +import { subqlTest } from '@subql/testing'; +import { BundleInstall } from '../types'; + +subqlTest( + 'BundleInstall event is present at 1146', + 1146, + [], + [ + new BundleInstall( + 'E0A1EFC56623C04FD6532902A382A54F90F289622637F4E556EB386AA02850F6', + BigInt(1146), + new Date('2024-12-09T23:25:30.033Z'), + BigInt(1849813), + '', + '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', + 'agoric1ee9hr0jyrxhy999y755mp862ljgycmwyp4pl7q', + ), + ], + + 'handleBundleInstallMessage', +); \ No newline at end of file From 5d6b053b8515142ad108d786c258d7b6b241b8b6 Mon Sep 17 00:00:00 2001 From: Fraz Arshad Date: Tue, 17 Dec 2024 11:34:23 +0500 Subject: [PATCH 06/16] test: psmMetrics, psmGovernance, oraclePrice tests added --- src/test/mappingHandlers.test.ts | 48 ++++++++++++++++++++++++++++++-- 1 file changed, 45 insertions(+), 3 deletions(-) diff --git a/src/test/mappingHandlers.test.ts b/src/test/mappingHandlers.test.ts index 990e1f7b..dcf78751 100644 --- a/src/test/mappingHandlers.test.ts +++ b/src/test/mappingHandlers.test.ts @@ -2,7 +2,10 @@ import { subqlTest } from '@subql/testing'; import { BoardAux, + OraclePrice, OraclePriceDaily, + PsmGovernance, + PsmMetrics, PsmMetricsDaily, ReserveAllocationMetrics, ReserveAllocationMetricsDaily, @@ -235,11 +238,22 @@ oraclePriceDaily.typeInName = 'ATOM'; oraclePriceDaily.typeOutName = 'USD'; oraclePriceDaily.metricsCount = BigInt(1); +const oraclePrice = new OraclePrice( + 'ATOM-USD', + BigInt(506), + new Date('2024-12-09T23:03:17.564Z'), + 'ATOM-USD', + BigInt(1000000), + BigInt(12010000), + 'ATOM', + 'USD', +) + subqlTest( - 'oraclePriceDaily at block 506', + 'oraclePrice at block 506', 506, [], - [oraclePriceDaily], + [oraclePriceDaily, oraclePrice], 'handleStateChangeEvent', ); @@ -260,4 +274,32 @@ psmMetricsDaily.totalAnchorProvidedLast = BigInt(0); psmMetricsDaily.totalMintedProvidedLast = BigInt(0); psmMetricsDaily.metricsCount = BigInt(1); -subqlTest('psmMetricsDaily at block 35', 35, [], [psmMetricsDaily], 'handleStateChangeEvent'); +const psmMetrics = new PsmMetrics( + 'published.psm.IST.USDC_axl.metrics', + BigInt(35), + new Date('2024-12-07T02:03:32.920Z'), + 'USDC_axl', + 'USDC_axl', + BigInt(0), + BigInt(0), + BigInt(0), + BigInt(0), + BigInt(0), +); + +subqlTest('psmMetrics at block 35', 35, [], [psmMetricsDaily, psmMetrics], 'handleStateChangeEvent'); + +const psmGovernance = new PsmGovernance( + 'published.psm.IST.USDT_axl.governance', + BigInt(35), + new Date('2024-12-07T02:03:32.920Z'), + 'USDT_axl', + 'USDT_axl', + BigInt(1000000000), + BigInt(10000), + BigInt(0), + BigInt(10000), + BigInt(0), +); + +subqlTest('psmGovernance at block 35', 35, [], [psmGovernance], 'handleStateChangeEvent'); From c43ad5184c735c56ed29208db9b738c4b3136f0f Mon Sep 17 00:00:00 2001 From: Fraz Arshad Date: Tue, 17 Dec 2024 12:09:15 +0500 Subject: [PATCH 07/16] fix: casting value to bigint --- src/mappings/events/vaults.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/mappings/events/vaults.ts b/src/mappings/events/vaults.ts index 0528aa8d..2c36af01 100644 --- a/src/mappings/events/vaults.ts +++ b/src/mappings/events/vaults.ts @@ -126,9 +126,9 @@ export const vaultsEventKit = (block: any, data: any, module: string, path: stri vault.coin = payload?.locked?.__brand; vault.denom = payload?.locked?.__brand; - vault.debt = payload?.debtSnapshot?.debt?.__value; - vault.balance = payload?.locked?.__value; - vault.lockedValue = payload?.locked?.__value; + vault.debt = BigInt(payload?.debtSnapshot?.debt?.__value); + vault.balance = BigInt(payload?.locked?.__value); + vault.lockedValue = BigInt(payload?.locked?.__value); vault.state = payload?.vaultState; let liquidation: Promise = Promise.resolve(); From 04681fa248eafe51d7f0a221c746b230458a04d9 Mon Sep 17 00:00:00 2001 From: Fraz Arshad Date: Tue, 17 Dec 2024 12:22:49 +0500 Subject: [PATCH 08/16] chore: prettier --- src/test/installBundleHandler.test.ts | 2 +- src/test/mappingHandlers.test.ts | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/test/installBundleHandler.test.ts b/src/test/installBundleHandler.test.ts index 698a52a9..32d88f09 100644 --- a/src/test/installBundleHandler.test.ts +++ b/src/test/installBundleHandler.test.ts @@ -18,4 +18,4 @@ subqlTest( ], 'handleBundleInstallMessage', -); \ No newline at end of file +); diff --git a/src/test/mappingHandlers.test.ts b/src/test/mappingHandlers.test.ts index dcf78751..91effab5 100644 --- a/src/test/mappingHandlers.test.ts +++ b/src/test/mappingHandlers.test.ts @@ -247,7 +247,7 @@ const oraclePrice = new OraclePrice( BigInt(12010000), 'ATOM', 'USD', -) +); subqlTest( 'oraclePrice at block 506', From 1d07784c1d9c9985f74c7b78feb0920ef897bb5c Mon Sep 17 00:00:00 2001 From: Fraz Arshad Date: Tue, 17 Dec 2024 12:35:32 +0500 Subject: [PATCH 09/16] test: disabled vault manager tests --- src/test/mappingHandlers.test.ts | 133 ++++++++++++++++--------------- 1 file changed, 67 insertions(+), 66 deletions(-) diff --git a/src/test/mappingHandlers.test.ts b/src/test/mappingHandlers.test.ts index 91effab5..c9b68d7d 100644 --- a/src/test/mappingHandlers.test.ts +++ b/src/test/mappingHandlers.test.ts @@ -121,72 +121,73 @@ vaultManagerMetricsDaily.totalProceedsReceivedLast = BigInt(0); vaultManagerMetricsDaily.totalShortfallReceivedLast = BigInt(0); vaultManagerMetricsDaily.metricsCount = BigInt(1); -subqlTest( - 'VaultManagerGovernance, VaultManagerMetrics, VaultManagerMetricsDaily, ReserveMetrics, \ - ReserveAllocationMetrics, and ReserveAllocationMetricsDaily at block height 1212', - 1212, - [], - [ - new VaultManagerGovernance( - 'published.vaultFactory.managers.manager1.governance', - BigInt(1212), - new Date('2024-12-16 11:42:27.202'), - BigInt(1000000000), - BigInt(100), - BigInt(1), - BigInt(100), - BigInt(150), - BigInt(100), - BigInt(25), - BigInt(100), - BigInt(1), - BigInt(10000), - BigInt(50), - ), - new VaultManagerMetrics( - 'published.vaultFactory.managers.manager1.metrics', - BigInt(1212), - new Date('2024-12-16 11:42:27.202'), - 'stATOM', - BigInt(0), - 'IST', - BigInt(0), - BigInt(0), - BigInt(0), - BigInt(0), - BigInt(0), - BigInt(0), - BigInt(0), - BigInt(0), - BigInt(0), - BigInt(0), - BigInt(0), - BigInt(0), - BigInt(0), - BigInt(0), - ), - vaultManagerMetricsDaily, - new ReserveMetrics( - 'published.reserve.metrics', - BigInt(1212), - new Date('2024-12-16T11:42:27.202Z'), - BigInt(0), - BigInt(0), - BigInt(0), - ), - new ReserveAllocationMetrics( - 'IST', - BigInt(1212), - new Date('2024-12-16T11:42:27.202Z'), - 'IST', - 'Fee', - BigInt(184980868), - 'published.reserve.metrics', - ), - reserveAllocationMetricsDaily, - ], - 'handleStateChangeEvent', -); +// DISABLED because the timestamp for these entities is changed on each run of the a3p container +// subqlTest( +// 'VaultManagerGovernance, VaultManagerMetrics, VaultManagerMetricsDaily, ReserveMetrics, \ +// ReserveAllocationMetrics, and ReserveAllocationMetricsDaily at block height 1212', +// 1212, +// [], +// [ +// new VaultManagerGovernance( +// 'published.vaultFactory.managers.manager1.governance', +// BigInt(1212), +// new Date('2024-12-16 11:42:27.202'), +// BigInt(1000000000), +// BigInt(100), +// BigInt(1), +// BigInt(100), +// BigInt(150), +// BigInt(100), +// BigInt(25), +// BigInt(100), +// BigInt(1), +// BigInt(10000), +// BigInt(50), +// ), +// new VaultManagerMetrics( +// 'published.vaultFactory.managers.manager1.metrics', +// BigInt(1212), +// new Date('2024-12-16 11:42:27.202'), +// 'stATOM', +// BigInt(0), +// 'IST', +// BigInt(0), +// BigInt(0), +// BigInt(0), +// BigInt(0), +// BigInt(0), +// BigInt(0), +// BigInt(0), +// BigInt(0), +// BigInt(0), +// BigInt(0), +// BigInt(0), +// BigInt(0), +// BigInt(0), +// BigInt(0), +// ), +// vaultManagerMetricsDaily, +// new ReserveMetrics( +// 'published.reserve.metrics', +// BigInt(1212), +// new Date('2024-12-16T11:42:27.202Z'), +// BigInt(0), +// BigInt(0), +// BigInt(0), +// ), +// new ReserveAllocationMetrics( +// 'IST', +// BigInt(1212), +// new Date('2024-12-16T11:42:27.202Z'), +// 'IST', +// 'Fee', +// BigInt(184980868), +// 'published.reserve.metrics', +// ), +// reserveAllocationMetricsDaily, +// ], +// 'handleStateChangeEvent', +// ); subqlTest( 'BoardAux at block 643', From 42c4eaaa09558521bb79628e581dd3f656c5044e Mon Sep 17 00:00:00 2001 From: rabi-siddique Date: Tue, 17 Dec 2024 13:59:24 +0500 Subject: [PATCH 10/16] ci: initial setup for liquidation testing --- .github/workflows/liquidation.yml | 29 +++++++++++++++++++++++++++++ package.json | 1 + 2 files changed, 30 insertions(+) create mode 100644 .github/workflows/liquidation.yml diff --git a/.github/workflows/liquidation.yml b/.github/workflows/liquidation.yml new file mode 100644 index 00000000..60b82b6e --- /dev/null +++ b/.github/workflows/liquidation.yml @@ -0,0 +1,29 @@ +name: Liquidation Testing +on: + pull_request: + +jobs: + test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Start A3P container + run: docker run -d -p 26657:26657 -p 1317:1317 -p 9090:9090 --name a3p ghcr.io/agoric/agoric-3-proposals:latest + + - run: corepack enable + shell: bash + + - name: Setup Node.js environment + uses: actions/setup-node@v4 + with: + node-version: 18 + cache: yarn + + - name: Install dependencies + run: yarn install + + - name: Start subql indexer + run: yarn dev:ci + env: + AGORIC_NET: docker diff --git a/package.json b/package.json index 2811b755..49b376ea 100644 --- a/package.json +++ b/package.json @@ -8,6 +8,7 @@ "codegen": "subql codegen", "start:docker": "docker-compose pull && docker-compose up --remove-orphans", "dev": "subql codegen && subql build && docker-compose pull && docker-compose up --remove-orphans", + "dev:ci": "subql codegen && subql build && docker compose pull && docker compose up --remove-orphans --detach", "prepack": "rm -rf dist && npm run build", "test": "subql build && subql-node-cosmos test", "prettier:check": "prettier --list-different . --print-width 120", From 6f38c10e7715ddc4106a7a5c23c2437ce14e2542 Mon Sep 17 00:00:00 2001 From: rabi-siddique Date: Tue, 17 Dec 2024 14:30:41 +0500 Subject: [PATCH 11/16] ci: set ATOM price and create vaults --- .github/actions/createVault/action.yml | 48 ++++++++++++++++++++++++++ .github/workflows/liquidation.yml | 36 +++++++++++++++++-- package.json | 2 +- 3 files changed, 83 insertions(+), 3 deletions(-) create mode 100644 .github/actions/createVault/action.yml diff --git a/.github/actions/createVault/action.yml b/.github/actions/createVault/action.yml new file mode 100644 index 00000000..d0f4eea0 --- /dev/null +++ b/.github/actions/createVault/action.yml @@ -0,0 +1,48 @@ +name: 'Create Vault' +description: 'Creates a vault and broadcasts an offer within an A3P container' +inputs: + wantMinted: + description: 'Amount of currency to be minted by the vault' + required: true + giveCollateral: + description: 'Collateral amount to secure the minted currency' + required: true + userKey: + description: 'User key to authenticate the transaction' + required: true + agoricNet: + description: 'Agoric network configuration' + required: true + commandTimeout: + description: 'Maximum time in seconds for the command to complete' + required: true + containerName: + description: 'Name of the Docker container where the commands will be executed' + required: true + +runs: + using: 'composite' + steps: + - name: Create Vault + shell: bash + run: | + createVaultCommand="/usr/src/agoric-sdk/packages/agoric-cli/bin/agops vaults open --wantMinted \"${{ inputs.wantMinted }}\" --giveCollateral \"${{ inputs.giveCollateral }}\" > /tmp/want-ist.json" + echo "Executing create vault command in the container..." + output=$(docker exec ${{ inputs.containerName }} /bin/bash -c "env AGORIC_NET=${{ inputs.agoricNet }} timeout ${{ inputs.commandTimeout }} $createVaultCommand") + + if echo "$output" | grep -q 'Error'; then + echo "Error found during vault creation: $output" + exit 1 + fi + - name: Broadcast Offer + shell: bash + run: | + broadcastCommand="/usr/src/agoric-sdk/packages/agoric-cli/bin/agops perf satisfaction --executeOffer /tmp/want-ist.json --from \"${{ inputs.userKey }}\" --keyring-backend=test" + echo "Executing broadcast command in the container..." + output=$(docker exec ${{ inputs.containerName }} /bin/bash -c "env AGORIC_NET=${{ inputs.agoricNet }} timeout ${{ inputs.commandTimeout }} $broadcastCommand") + + if echo "$output" | grep -q 'Error'; then + echo "Error found during broadcast: $output" + exit 1 + else + echo "Broadcast successful: $output" diff --git a/.github/workflows/liquidation.yml b/.github/workflows/liquidation.yml index 60b82b6e..b4b3b56a 100644 --- a/.github/workflows/liquidation.yml +++ b/.github/workflows/liquidation.yml @@ -25,5 +25,37 @@ jobs: - name: Start subql indexer run: yarn dev:ci - env: - AGORIC_NET: docker + + - name: Set ATOM Price to 12.34 + run: | + docker exec a3p /usr/src/agoric-sdk/packages/agoric-cli/bin/agops oracle setPrice --keys gov1,gov2 --pair ATOM.USD --price 12.34 --keyring-backend=test + + - name: Create Vault with 100 Minted and 15 Collateral + uses: ./.github/actions/createVault + with: + wantMinted: '100' + giveCollateral: '15' + userKey: 'user1' + agoricNet: 'local' + commandTimeout: '120' + containerName: 'a3p' + + - name: Create Vault with 103 Minted and 15 Collateral + uses: ./.github/actions/createVault + with: + wantMinted: '103' + giveCollateral: '15' + userKey: 'user1' + agoricNet: 'local' + commandTimeout: '120' + containerName: 'a3p' + + - name: Create Vault with 105 Minted and 15 Collateral + uses: ./.github/actions/createVault + with: + wantMinted: '105' + giveCollateral: '15' + userKey: 'user1' + agoricNet: 'local' + commandTimeout: '120' + containerName: 'a3p' diff --git a/package.json b/package.json index 49b376ea..e9c7ec51 100644 --- a/package.json +++ b/package.json @@ -8,7 +8,7 @@ "codegen": "subql codegen", "start:docker": "docker-compose pull && docker-compose up --remove-orphans", "dev": "subql codegen && subql build && docker-compose pull && docker-compose up --remove-orphans", - "dev:ci": "subql codegen && subql build && docker compose pull && docker compose up --remove-orphans --detach", + "dev:ci": "AGORIC_NET=docker subql codegen && subql build && docker compose pull && docker compose up --remove-orphans --detach", "prepack": "rm -rf dist && npm run build", "test": "subql build && subql-node-cosmos test", "prettier:check": "prettier --list-different . --print-width 120", From 09b09ed750963fcee92361e117e8d65a72694a9d Mon Sep 17 00:00:00 2001 From: rabi-siddique Date: Tue, 17 Dec 2024 15:07:49 +0500 Subject: [PATCH 12/16] ci: place bids and set ATOM price to 9.99 --- .github/actions/createVault/action.yml | 14 ++------ .github/actions/placeBid/action.yml | 40 +++++++++++++++++++++++ .github/workflows/liquidation.yml | 45 +++++++++++++++++++++++--- 3 files changed, 84 insertions(+), 15 deletions(-) create mode 100644 .github/actions/placeBid/action.yml diff --git a/.github/actions/createVault/action.yml b/.github/actions/createVault/action.yml index d0f4eea0..3460914a 100644 --- a/.github/actions/createVault/action.yml +++ b/.github/actions/createVault/action.yml @@ -28,21 +28,13 @@ runs: run: | createVaultCommand="/usr/src/agoric-sdk/packages/agoric-cli/bin/agops vaults open --wantMinted \"${{ inputs.wantMinted }}\" --giveCollateral \"${{ inputs.giveCollateral }}\" > /tmp/want-ist.json" echo "Executing create vault command in the container..." - output=$(docker exec ${{ inputs.containerName }} /bin/bash -c "env AGORIC_NET=${{ inputs.agoricNet }} timeout ${{ inputs.commandTimeout }} $createVaultCommand") - if echo "$output" | grep -q 'Error'; then - echo "Error found during vault creation: $output" - exit 1 - fi + docker exec ${{ inputs.containerName }} /bin/bash -c "env AGORIC_NET=${{ inputs.agoricNet }} timeout ${{ inputs.commandTimeout }} $createVaultCommand" + - name: Broadcast Offer shell: bash run: | broadcastCommand="/usr/src/agoric-sdk/packages/agoric-cli/bin/agops perf satisfaction --executeOffer /tmp/want-ist.json --from \"${{ inputs.userKey }}\" --keyring-backend=test" echo "Executing broadcast command in the container..." - output=$(docker exec ${{ inputs.containerName }} /bin/bash -c "env AGORIC_NET=${{ inputs.agoricNet }} timeout ${{ inputs.commandTimeout }} $broadcastCommand") - if echo "$output" | grep -q 'Error'; then - echo "Error found during broadcast: $output" - exit 1 - else - echo "Broadcast successful: $output" + docker exec ${{ inputs.containerName }} /bin/bash -c "env AGORIC_NET=${{ inputs.agoricNet }} timeout ${{ inputs.commandTimeout }} $broadcastCommand" diff --git a/.github/actions/placeBid/action.yml b/.github/actions/placeBid/action.yml new file mode 100644 index 00000000..b8375a35 --- /dev/null +++ b/.github/actions/placeBid/action.yml @@ -0,0 +1,40 @@ +name: 'Place Bids' +description: 'Place bids by price or discount' +inputs: + fromAddress: + description: 'Address from which the bid is made' + required: true + giveAmount: + description: 'Amount to offer in the bid' + required: true + priceOrDiscount: + description: 'Price or discount to apply to the bid' + required: true + commandType: + description: 'Type of command to execute (by-price or by-discount)' + required: true + agoricNet: + description: 'Agoric network configuration' + required: true + commandTimeout: + description: 'Maximum time in seconds for the command to complete' + required: true + containerName: + description: 'Name of the Docker container where the commands will be executed' + required: true + +runs: + using: 'composite' + steps: + - name: Place Bid + shell: bash + run: | + if [ "${{ inputs.commandType }}" == "by-price" ]; then + commandType="bid by-price --price" + elif [ "${{ inputs.commandType }}" == "by-discount" ]; then + commandType="bid by-discount --discount" + fi + + command="/usr/src/agoric-sdk/packages/agoric-cli/bin/agops inter ${commandType} \"${{ inputs.priceOrDiscount }}\" --from \"${{ inputs.fromAddress }}\" --give \"${{ inputs.giveAmount }}\" --keyring-backend=test" + echo "Executing command in the container..." + docker exec ${{ inputs.containerName }} /bin/bash -c "env AGORIC_NET=${{ inputs.agoricNet }} timeout ${{ inputs.commandTimeout }} $command" diff --git a/.github/workflows/liquidation.yml b/.github/workflows/liquidation.yml index b4b3b56a..8247f147 100644 --- a/.github/workflows/liquidation.yml +++ b/.github/workflows/liquidation.yml @@ -1,4 +1,4 @@ -name: Liquidation Testing +name: Liquidation Indexing on: pull_request: @@ -35,7 +35,7 @@ jobs: with: wantMinted: '100' giveCollateral: '15' - userKey: 'user1' + userKey: 'gov3' agoricNet: 'local' commandTimeout: '120' containerName: 'a3p' @@ -45,7 +45,7 @@ jobs: with: wantMinted: '103' giveCollateral: '15' - userKey: 'user1' + userKey: 'gov3' agoricNet: 'local' commandTimeout: '120' containerName: 'a3p' @@ -55,7 +55,44 @@ jobs: with: wantMinted: '105' giveCollateral: '15' - userKey: 'user1' + userKey: 'gov3' agoricNet: 'local' commandTimeout: '120' containerName: 'a3p' + + - name: Place bid for 90IST + uses: ./.github/actions/placeBid + with: + fromAddress: 'gov1' + giveAmount: '90IST' + priceOrDiscount: '9' + commandType: 'by-price' + agoricNet: 'local' + commandTimeout: '120' + containerName: 'a3p' + + - name: Place bid for 80IST + uses: ./.github/actions/placeBid + with: + fromAddress: 'gov1' + giveAmount: '80IST' + priceOrDiscount: '10' + commandType: 'by-discount' + agoricNet: 'local' + commandTimeout: '120' + containerName: 'a3p' + + - name: Place bid for 150IST + uses: ./.github/actions/placeBid + with: + fromAddress: 'gov1' + giveAmount: '150IST' + priceOrDiscount: '15' + commandType: 'by-discount' + agoricNet: 'local' + commandTimeout: '120' + containerName: 'a3p' + + - name: Set ATOM Price to 9.99 + run: | + docker exec a3p /usr/src/agoric-sdk/packages/agoric-cli/bin/agops oracle setPrice --keys gov1,gov2 --pair ATOM.USD --price 9.99 --keyring-backend=test From dbb6c056a46a29399a2165154fad254c6844694b Mon Sep 17 00:00:00 2001 From: rabi-siddique Date: Tue, 17 Dec 2024 16:34:51 +0500 Subject: [PATCH 13/16] ci: get active vaults --- .github/actions/createVault/action.yml | 40 -------- .github/actions/placeBid/action.yml | 40 -------- .github/scripts/changePrice.mjs | 36 +++++++ .github/scripts/createVault.mjs | 37 +++++++ .github/scripts/getActiveVaults.mjs | 55 ++++++++++ .github/scripts/placeBid.mjs | 47 +++++++++ .github/workflows/liquidation.yml | 80 ++++++++++----- docker-compose.yml | 34 +++++-- package.json | 4 +- project.ts | 6 ++ yarn.lock | 136 +++++++++++++++++++++++++ 11 files changed, 400 insertions(+), 115 deletions(-) delete mode 100644 .github/actions/createVault/action.yml delete mode 100644 .github/actions/placeBid/action.yml create mode 100644 .github/scripts/changePrice.mjs create mode 100644 .github/scripts/createVault.mjs create mode 100644 .github/scripts/getActiveVaults.mjs create mode 100644 .github/scripts/placeBid.mjs diff --git a/.github/actions/createVault/action.yml b/.github/actions/createVault/action.yml deleted file mode 100644 index 3460914a..00000000 --- a/.github/actions/createVault/action.yml +++ /dev/null @@ -1,40 +0,0 @@ -name: 'Create Vault' -description: 'Creates a vault and broadcasts an offer within an A3P container' -inputs: - wantMinted: - description: 'Amount of currency to be minted by the vault' - required: true - giveCollateral: - description: 'Collateral amount to secure the minted currency' - required: true - userKey: - description: 'User key to authenticate the transaction' - required: true - agoricNet: - description: 'Agoric network configuration' - required: true - commandTimeout: - description: 'Maximum time in seconds for the command to complete' - required: true - containerName: - description: 'Name of the Docker container where the commands will be executed' - required: true - -runs: - using: 'composite' - steps: - - name: Create Vault - shell: bash - run: | - createVaultCommand="/usr/src/agoric-sdk/packages/agoric-cli/bin/agops vaults open --wantMinted \"${{ inputs.wantMinted }}\" --giveCollateral \"${{ inputs.giveCollateral }}\" > /tmp/want-ist.json" - echo "Executing create vault command in the container..." - - docker exec ${{ inputs.containerName }} /bin/bash -c "env AGORIC_NET=${{ inputs.agoricNet }} timeout ${{ inputs.commandTimeout }} $createVaultCommand" - - - name: Broadcast Offer - shell: bash - run: | - broadcastCommand="/usr/src/agoric-sdk/packages/agoric-cli/bin/agops perf satisfaction --executeOffer /tmp/want-ist.json --from \"${{ inputs.userKey }}\" --keyring-backend=test" - echo "Executing broadcast command in the container..." - - docker exec ${{ inputs.containerName }} /bin/bash -c "env AGORIC_NET=${{ inputs.agoricNet }} timeout ${{ inputs.commandTimeout }} $broadcastCommand" diff --git a/.github/actions/placeBid/action.yml b/.github/actions/placeBid/action.yml deleted file mode 100644 index b8375a35..00000000 --- a/.github/actions/placeBid/action.yml +++ /dev/null @@ -1,40 +0,0 @@ -name: 'Place Bids' -description: 'Place bids by price or discount' -inputs: - fromAddress: - description: 'Address from which the bid is made' - required: true - giveAmount: - description: 'Amount to offer in the bid' - required: true - priceOrDiscount: - description: 'Price or discount to apply to the bid' - required: true - commandType: - description: 'Type of command to execute (by-price or by-discount)' - required: true - agoricNet: - description: 'Agoric network configuration' - required: true - commandTimeout: - description: 'Maximum time in seconds for the command to complete' - required: true - containerName: - description: 'Name of the Docker container where the commands will be executed' - required: true - -runs: - using: 'composite' - steps: - - name: Place Bid - shell: bash - run: | - if [ "${{ inputs.commandType }}" == "by-price" ]; then - commandType="bid by-price --price" - elif [ "${{ inputs.commandType }}" == "by-discount" ]; then - commandType="bid by-discount --discount" - fi - - command="/usr/src/agoric-sdk/packages/agoric-cli/bin/agops inter ${commandType} \"${{ inputs.priceOrDiscount }}\" --from \"${{ inputs.fromAddress }}\" --give \"${{ inputs.giveAmount }}\" --keyring-backend=test" - echo "Executing command in the container..." - docker exec ${{ inputs.containerName }} /bin/bash -c "env AGORIC_NET=${{ inputs.agoricNet }} timeout ${{ inputs.commandTimeout }} $command" diff --git a/.github/scripts/changePrice.mjs b/.github/scripts/changePrice.mjs new file mode 100644 index 00000000..707293b2 --- /dev/null +++ b/.github/scripts/changePrice.mjs @@ -0,0 +1,36 @@ +import { execa } from 'execa'; +import assert from 'assert'; + +const agops = '/usr/src/agoric-sdk/packages/agoric-cli/bin/agops'; + +const amount = process.env.amount; +const containerName = process.env.containerName; +const agoricNet = process.env.agoricNet; + +if (!amount || !containerName || !agoricNet) { + console.error('Error: Missing one or more required parameters:'); + if (!amount) console.error('Missing amount'); + if (!containerName) console.error('Missing containerName'); + if (!agoricNet) console.error('Missing agoricNet'); + process.exit(1); +} + +const setAtomPrice = async (amount, containerName, agoricNet) => { + try { + console.log(`Initiating price change to ${amount} for ATOM...`); + + const env = { + AGORIC_NET: agoricNet, + }; + + const command = `${agops} oracle setPrice --keys gov1,gov2 --pair ATOM.USD --price ${amount} --keyring-backend=test`; + const { stdout, stderr } = await execa('docker', ['exec', containerName, command], { env, shell: true }); + + assert.strictEqual(stderr, '', `Expected stderr to be empty, but received: '${stderr}'`); + console.log('Standard output:', stdout); + } catch (error) { + console.error('Error:', error); + } +}; + +setAtomPrice(amount, containerName, agoricNet); diff --git a/.github/scripts/createVault.mjs b/.github/scripts/createVault.mjs new file mode 100644 index 00000000..ad0bbff8 --- /dev/null +++ b/.github/scripts/createVault.mjs @@ -0,0 +1,37 @@ +import { execa } from 'execa'; +import assert from 'assert'; + +const agops = '/usr/src/agoric-sdk/packages/agoric-cli/bin/agops'; + +const createVault = async (containerName, agoricNet, userKey, wantMinted, giveCollateral) => { + console.log('Starting the vault creation process...'); + + try { + const env = { + AGORIC_NET: agoricNet, + }; + + const command = `${agops} vaults open --wantMinted ${wantMinted} --giveCollateral ${giveCollateral} > /tmp/want-ist.json`; + await execa('docker', ['exec', containerName, `bash -c "${command}"`], { env, shell: true }); + + const broadCastCommand = `${agops} perf satisfaction --executeOffer /tmp/want-ist.json --from ${userKey} --keyring-backend=test`; + const { stdout } = await execa('docker', ['exec', containerName, broadCastCommand], { + env, + shell: true, + }); + + assert.ok(!stdout.includes('Error'), `Expected 'stdout' not to contain 'Error'`); + console.log('Standard output:', stdout); + } catch (error) { + console.error('Error during vault creation:', error); + process.exit(1); + } +}; + +const containerName = process.env.containerName; +const agoricNet = process.env.agoricNet; +const userKey = process.env.userKey; +const wantMinted = process.env.wantMinted; +const giveCollateral = process.env.giveCollateral; + +createVault(containerName, agoricNet, userKey, wantMinted, giveCollateral); diff --git a/.github/scripts/getActiveVaults.mjs b/.github/scripts/getActiveVaults.mjs new file mode 100644 index 00000000..a62f48f9 --- /dev/null +++ b/.github/scripts/getActiveVaults.mjs @@ -0,0 +1,55 @@ +import fetch from 'node-fetch'; + +const delay = (ms) => { + return new Promise((resolve) => setTimeout(resolve, ms)); +}; +const getActiveVaults = async (apiUrl, expectedVaults) => { + console.log('Fetching the number of active vaults...'); + const maxRetries = 5; + let retries = 0; + + while (retries < maxRetries) { + try { + const graphqlQuery = { + query: `query { vaults(filter: {state: {equalTo: "active"}}) { totalCount } }`, + }; + + const response = await fetch(apiUrl, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + Accept: 'application/json', + }, + body: JSON.stringify(graphqlQuery), + }); + + const jsonResponse = await response.json(); + const activeVaults = jsonResponse.data.vaults.totalCount; + + console.log(`Attempt ${retries + 1}: Active vaults: ${activeVaults}`); + + if (activeVaults === expectedVaults) { + console.log(`Assertion passed: ${activeVaults} active vaults match the expected count.`); + return; + } + + console.log( + `Assertion failed on attempt ${retries + 1}: Expected ${expectedVaults} active vaults, but found ${activeVaults}. Retrying...`, + ); + retries++; + await delay(5000); + } catch (error) { + console.error(`Error on attempt ${retries + 1} fetching active vaults:`, error); + retries++; + await delay(5000); + } + } + + console.error('Maximum retry attempts reached. Exiting...'); + process.exit(1); +}; + +const apiUrl = process.env.apiUrl; +const expectedVaults = parseInt(process.env.expectedVaults, 10); + +getActiveVaults(apiUrl, expectedVaults); diff --git a/.github/scripts/placeBid.mjs b/.github/scripts/placeBid.mjs new file mode 100644 index 00000000..100081c5 --- /dev/null +++ b/.github/scripts/placeBid.mjs @@ -0,0 +1,47 @@ +import { execa } from 'execa'; +import assert from 'assert'; + +const agops = '/usr/src/agoric-sdk/packages/agoric-cli/bin/agops'; + +const placeBid = async ({ fromAddress, giveAmount, priceOrDiscount, commandType, agoricNet, containerName }) => { + console.log('Starting the bidding process...'); + + try { + const env = { + AGORIC_NET: agoricNet, + }; + + let commandTypeOption; + if (commandType === 'by-price') { + commandTypeOption = 'by-price --price'; + } else if (commandType === 'by-discount') { + commandTypeOption = 'by-discount --discount'; + } + + const command = `${agops} inter bid ${commandTypeOption} ${priceOrDiscount} --from ${fromAddress} --give ${giveAmount} --keyring-backend=test`; + + console.log('Executing command in the container...'); + const { stdout } = await execa('docker', ['exec', containerName, `bash -c "${command}"`], { + env, + shell: true, + }); + + assert.ok(stdout.includes('Your bid has been accepted')); + console.log('Standard output:', stdout); + } catch (error) { + console.error('Error during bid placement:', error); + process.exit(1); + } +}; + +const bidInfo = { + fromAddress: process.env.fromAddress, + giveAmount: process.env.giveAmount, + priceOrDiscount: process.env.priceOrDiscount, + commandType: process.env.commandType, + agoricNet: process.env.agoricNet, + commandTimeout: process.env.commandTimeout, + containerName: process.env.containerName, +}; + +placeBid(bidInfo); diff --git a/.github/workflows/liquidation.yml b/.github/workflows/liquidation.yml index 8247f147..cb0f38d8 100644 --- a/.github/workflows/liquidation.yml +++ b/.github/workflows/liquidation.yml @@ -9,7 +9,7 @@ jobs: - uses: actions/checkout@v4 - name: Start A3P container - run: docker run -d -p 26657:26657 -p 1317:1317 -p 9090:9090 --name a3p ghcr.io/agoric/agoric-3-proposals:latest + run: docker compose --profile ci up -d a3p - run: corepack enable shell: bash @@ -24,75 +24,101 @@ jobs: run: yarn install - name: Start subql indexer - run: yarn dev:ci + env: + AGORIC_NET: ci + run: yarn dev - - name: Set ATOM Price to 12.34 + - name: Print initial logs of all containers run: | - docker exec a3p /usr/src/agoric-sdk/packages/agoric-cli/bin/agops oracle setPrice --keys gov1,gov2 --pair ATOM.USD --price 12.34 --keyring-backend=test + echo "Fetching initial logs for all containers..." + containers=$(docker ps --format '{{.ID}}') + for container in $containers; do + echo "Fetching initial logs for container $container..." + docker logs $container + done + + - name: Set ATOM Price to 12.34 + run: node .github/scripts/changePrice.mjs + env: + amount: 12.34 + containerName: agd + agoricNet: local + + - name: Get active vaults + run: node .github/scripts/getActiveVaults.mjs + env: + apiUrl: 'http://localhost:3000/' + expectedVaults: '7' - name: Create Vault with 100 Minted and 15 Collateral - uses: ./.github/actions/createVault - with: + run: node .github/scripts/createVault.mjs + env: wantMinted: '100' giveCollateral: '15' userKey: 'gov3' agoricNet: 'local' commandTimeout: '120' - containerName: 'a3p' + containerName: 'agd' - name: Create Vault with 103 Minted and 15 Collateral - uses: ./.github/actions/createVault - with: + run: node .github/scripts/createVault.mjs + env: wantMinted: '103' giveCollateral: '15' userKey: 'gov3' agoricNet: 'local' commandTimeout: '120' - containerName: 'a3p' + containerName: 'agd' - name: Create Vault with 105 Minted and 15 Collateral - uses: ./.github/actions/createVault - with: + run: node .github/scripts/createVault.mjs + env: wantMinted: '105' giveCollateral: '15' userKey: 'gov3' agoricNet: 'local' commandTimeout: '120' - containerName: 'a3p' + containerName: 'agd' + + - name: Get active vaults + run: node .github/scripts/getActiveVaults.mjs + env: + apiUrl: 'http://localhost:3000/' + expectedVaults: 10 - name: Place bid for 90IST - uses: ./.github/actions/placeBid - with: + run: node .github/scripts/placeBid.mjs + env: fromAddress: 'gov1' giveAmount: '90IST' priceOrDiscount: '9' commandType: 'by-price' agoricNet: 'local' - commandTimeout: '120' - containerName: 'a3p' + containerName: 'agd' - name: Place bid for 80IST - uses: ./.github/actions/placeBid - with: + run: node .github/scripts/placeBid.mjs + env: fromAddress: 'gov1' giveAmount: '80IST' priceOrDiscount: '10' commandType: 'by-discount' agoricNet: 'local' - commandTimeout: '120' - containerName: 'a3p' + containerName: 'agd' - name: Place bid for 150IST - uses: ./.github/actions/placeBid - with: + run: node .github/scripts/placeBid.mjs + env: fromAddress: 'gov1' giveAmount: '150IST' priceOrDiscount: '15' commandType: 'by-discount' agoricNet: 'local' - commandTimeout: '120' - containerName: 'a3p' + containerName: 'agd' - name: Set ATOM Price to 9.99 - run: | - docker exec a3p /usr/src/agoric-sdk/packages/agoric-cli/bin/agops oracle setPrice --keys gov1,gov2 --pair ATOM.USD --price 9.99 --keyring-backend=test + run: node .github/scripts/changePrice.mjs + env: + amount: 9.99 + containerName: agd + agoricNet: local diff --git a/docker-compose.yml b/docker-compose.yml index ddd67f4f..e2ecc711 100644 --- a/docker-compose.yml +++ b/docker-compose.yml @@ -14,11 +14,14 @@ services: interval: 5s timeout: 5s retries: 5 + profiles: + - default + - ci subquery-node: image: subquerynetwork/subql-node-cosmos:v4.2.1 depends_on: - 'postgres': + postgres: condition: service_healthy restart: always environment: @@ -30,27 +33,28 @@ services: volumes: - ./:/app command: - - ${SUB_COMMAND:-} # set SUB_COMMAND env variable to "test" to run tests + - ${SUB_COMMAND:-} - -f=/app - --db-schema=app - --workers=4 - --batch-size=30 - # - --log-level=debug - # - --unfinalized-blocks=true healthcheck: test: ['CMD', 'curl', '-f', 'http://subquery-node:3000/ready'] interval: 3s timeout: 5s retries: 10 + profiles: + - default + - ci graphql-engine: image: onfinality/subql-query:v2.13.0 ports: - 3000:3000 depends_on: - 'postgres': + postgres: condition: service_healthy - 'subquery-node': + subquery-node: condition: service_healthy restart: always environment: @@ -63,3 +67,21 @@ services: - --name=app - --playground - --indexer=http://subquery-node:3000 + profiles: + - default + - ci + + a3p: + image: ghcr.io/agoric/agoric-3-proposals:latest + container_name: agd + ports: + - 26657:26657 + - 1317:1317 + - 9090:9090 + restart: always + profiles: + - ci + +networks: + default: + driver: bridge diff --git a/package.json b/package.json index e9c7ec51..4f8f205b 100644 --- a/package.json +++ b/package.json @@ -7,8 +7,7 @@ "build": "subql build", "codegen": "subql codegen", "start:docker": "docker-compose pull && docker-compose up --remove-orphans", - "dev": "subql codegen && subql build && docker-compose pull && docker-compose up --remove-orphans", - "dev:ci": "AGORIC_NET=docker subql codegen && subql build && docker compose pull && docker compose up --remove-orphans --detach", + "dev": "subql codegen && subql build && docker compose pull && docker compose --profile default up --remove-orphans --detach", "prepack": "rm -rf dist && npm run build", "test": "subql build && subql-node-cosmos test", "prettier:check": "prettier --list-different . --print-width 120", @@ -28,6 +27,7 @@ "@subql/cli": "^5.4.0", "@subql/node-cosmos": "4.2.1", "@subql/testing": "latest", + "execa": "^9.5.2", "prettier": "^3.4.2", "starknet": "6.11.0", "typescript": "^5.7.2" diff --git a/project.ts b/project.ts index a26e2303..5ed79c5d 100644 --- a/project.ts +++ b/project.ts @@ -44,6 +44,12 @@ const networkConfig = { chaintypes: chainTypesU18, startBlock: 1, }, + ci: { + chainId: 'agoriclocal', + endpoint: ['http://a3p:26657'], + chaintypes: chainTypesU18, + startBlock: 1, + }, main: { chainId: 'agoric-3', endpoint: ['https://main-a.rpc.agoric.net:443'], diff --git a/yarn.lock b/yarn.lock index 4c0e2d2d..c75cf26d 100644 --- a/yarn.lock +++ b/yarn.lock @@ -3156,6 +3156,13 @@ __metadata: languageName: node linkType: hard +"@sec-ant/readable-stream@npm:^0.4.1": + version: 0.4.1 + resolution: "@sec-ant/readable-stream@npm:0.4.1" + checksum: 10c0/64e9e9cf161e848067a5bf60cdc04d18495dc28bb63a8d9f8993e4dd99b91ad34e4b563c85de17d91ffb177ec17a0664991d2e115f6543e73236a906068987af + languageName: node + linkType: hard + "@sinclair/typebox@npm:^0.24.1": version: 0.24.51 resolution: "@sinclair/typebox@npm:0.24.51" @@ -3170,6 +3177,13 @@ __metadata: languageName: node linkType: hard +"@sindresorhus/merge-streams@npm:^4.0.0": + version: 4.0.0 + resolution: "@sindresorhus/merge-streams@npm:4.0.0" + checksum: 10c0/482ee543629aa1933b332f811a1ae805a213681ecdd98c042b1c1b89387df63e7812248bb4df3910b02b3cc5589d3d73e4393f30e197c9dde18046ccd471fc6b + languageName: node + linkType: hard + "@starknet-io/types-js@npm:^0.7.7, starknet-types-07@npm:@starknet-io/types-js@^0.7.7": version: 0.7.10 resolution: "@starknet-io/types-js@npm:0.7.10" @@ -4113,6 +4127,7 @@ __metadata: "@subql/utils": "npm:^2.17.0" "@types/node": "npm:^17.0.21" bech32: "npm:^2.0.0" + execa: "npm:^9.5.2" js-sha256: "npm:^0.11.0" pino: "npm:^7.8.0" prettier: "npm:^3.4.2" @@ -5892,6 +5907,26 @@ __metadata: languageName: node linkType: hard +"execa@npm:^9.5.2": + version: 9.5.2 + resolution: "execa@npm:9.5.2" + dependencies: + "@sindresorhus/merge-streams": "npm:^4.0.0" + cross-spawn: "npm:^7.0.3" + figures: "npm:^6.1.0" + get-stream: "npm:^9.0.0" + human-signals: "npm:^8.0.0" + is-plain-obj: "npm:^4.1.0" + is-stream: "npm:^4.0.1" + npm-run-path: "npm:^6.0.0" + pretty-ms: "npm:^9.0.0" + signal-exit: "npm:^4.1.0" + strip-final-newline: "npm:^4.0.0" + yoctocolors: "npm:^2.0.0" + checksum: 10c0/94782a6282e03253224406c29068d18f9095cc251a45d1f19ac3d8f2a9db2cbe32fb8ceb039db1451d8fce3531135a6c0c559f76d634f85416268fc4a6995365 + languageName: node + linkType: hard + "exponential-backoff@npm:^3.1.1": version: 3.1.1 resolution: "exponential-backoff@npm:3.1.1" @@ -6047,6 +6082,15 @@ __metadata: languageName: node linkType: hard +"figures@npm:^6.1.0": + version: 6.1.0 + resolution: "figures@npm:6.1.0" + dependencies: + is-unicode-supported: "npm:^2.0.0" + checksum: 10c0/9159df4264d62ef447a3931537de92f5012210cf5135c35c010df50a2169377581378149abfe1eb238bd6acbba1c0d547b1f18e0af6eee49e30363cedaffcfe4 + languageName: node + linkType: hard + "file-uri-to-path@npm:1.0.0": version: 1.0.0 resolution: "file-uri-to-path@npm:1.0.0" @@ -6307,6 +6351,16 @@ __metadata: languageName: node linkType: hard +"get-stream@npm:^9.0.0": + version: 9.0.1 + resolution: "get-stream@npm:9.0.1" + dependencies: + "@sec-ant/readable-stream": "npm:^0.4.1" + is-stream: "npm:^4.0.1" + checksum: 10c0/d70e73857f2eea1826ac570c3a912757dcfbe8a718a033fa0c23e12ac8e7d633195b01710e0559af574cbb5af101009b42df7b6f6b29ceec8dbdf7291931b948 + languageName: node + linkType: hard + "glob-parent@npm:^5.1.2": version: 5.1.2 resolution: "glob-parent@npm:5.1.2" @@ -6604,6 +6658,13 @@ __metadata: languageName: node linkType: hard +"human-signals@npm:^8.0.0": + version: 8.0.0 + resolution: "human-signals@npm:8.0.0" + checksum: 10c0/e4dac4f7d3eb791ed04129fc6a85bd454a9102d3e3b76c911d0db7057ebd60b2956b435b5b5712aec18960488ede3c21ef7c56e42cdd70760c0d84d3c05cd92e + languageName: node + linkType: hard + "humanize-number@npm:0.0.2": version: 0.0.2 resolution: "humanize-number@npm:0.0.2" @@ -6913,6 +6974,13 @@ __metadata: languageName: node linkType: hard +"is-plain-obj@npm:^4.1.0": + version: 4.1.0 + resolution: "is-plain-obj@npm:4.1.0" + checksum: 10c0/32130d651d71d9564dc88ba7e6fda0e91a1010a3694648e9f4f47bb6080438140696d3e3e15c741411d712e47ac9edc1a8a9de1fe76f3487b0d90be06ac9975e + languageName: node + linkType: hard + "is-plain-object@npm:^2.0.4": version: 2.0.4 resolution: "is-plain-object@npm:2.0.4" @@ -6929,6 +6997,13 @@ __metadata: languageName: node linkType: hard +"is-stream@npm:^4.0.1": + version: 4.0.1 + resolution: "is-stream@npm:4.0.1" + checksum: 10c0/2706c7f19b851327ba374687bc4a3940805e14ca496dc672b9629e744d143b1ad9c6f1b162dece81c7bfbc0f83b32b61ccc19ad2e05aad2dd7af347408f60c7f + languageName: node + linkType: hard + "is-typedarray@npm:^1.0.0": version: 1.0.0 resolution: "is-typedarray@npm:1.0.0" @@ -6943,6 +7018,13 @@ __metadata: languageName: node linkType: hard +"is-unicode-supported@npm:^2.0.0": + version: 2.1.0 + resolution: "is-unicode-supported@npm:2.1.0" + checksum: 10c0/a0f53e9a7c1fdbcf2d2ef6e40d4736fdffff1c9f8944c75e15425118ff3610172c87bf7bc6c34d3903b04be59790bb2212ddbe21ee65b5a97030fc50370545a5 + languageName: node + linkType: hard + "is-wsl@npm:^2.2.0": version: 2.2.0 resolution: "is-wsl@npm:2.2.0" @@ -8007,6 +8089,16 @@ __metadata: languageName: node linkType: hard +"npm-run-path@npm:^6.0.0": + version: 6.0.0 + resolution: "npm-run-path@npm:6.0.0" + dependencies: + path-key: "npm:^4.0.0" + unicorn-magic: "npm:^0.3.0" + checksum: 10c0/b223c8a0dcd608abf95363ea5c3c0ccc3cd877daf0102eaf1b0f2390d6858d8337fbb7c443af2403b067a7d2c116d10691ecd22ab3c5273c44da1ff8d07753bd + languageName: node + linkType: hard + "object-assign@npm:^4, object-assign@npm:^4.0.1, object-assign@npm:^4.1.1": version: 4.1.1 resolution: "object-assign@npm:4.1.1" @@ -8179,6 +8271,13 @@ __metadata: languageName: node linkType: hard +"parse-ms@npm:^4.0.0": + version: 4.0.0 + resolution: "parse-ms@npm:4.0.0" + checksum: 10c0/a7900f4f1ebac24cbf5e9708c16fb2fd482517fad353aecd7aefb8c2ba2f85ce017913ccb8925d231770404780df46244ea6fec598b3bde6490882358b4d2d16 + languageName: node + linkType: hard + "parse-package-name@npm:1.0.0": version: 1.0.0 resolution: "parse-package-name@npm:1.0.0" @@ -8224,6 +8323,13 @@ __metadata: languageName: node linkType: hard +"path-key@npm:^4.0.0": + version: 4.0.0 + resolution: "path-key@npm:4.0.0" + checksum: 10c0/794efeef32863a65ac312f3c0b0a99f921f3e827ff63afa5cb09a377e202c262b671f7b3832a4e64731003fa94af0263713962d317b9887bd1e0c48a342efba3 + languageName: node + linkType: hard + "path-parse@npm:^1.0.7": version: 1.0.7 resolution: "path-parse@npm:1.0.7" @@ -8481,6 +8587,15 @@ __metadata: languageName: node linkType: hard +"pretty-ms@npm:^9.0.0": + version: 9.2.0 + resolution: "pretty-ms@npm:9.2.0" + dependencies: + parse-ms: "npm:^4.0.0" + checksum: 10c0/ab6d066f90e9f77020426986e1b018369f41575674544c539aabec2e63a20fec01166d8cf6571d0e165ad11cfe5a8134a2a48a36d42ab291c59c6deca5264cbb + languageName: node + linkType: hard + "proc-log@npm:^5.0.0": version: 5.0.0 resolution: "proc-log@npm:5.0.0" @@ -9552,6 +9667,13 @@ __metadata: languageName: node linkType: hard +"strip-final-newline@npm:^4.0.0": + version: 4.0.0 + resolution: "strip-final-newline@npm:4.0.0" + checksum: 10c0/b0cf2b62d597a1b0e3ebc42b88767f0a0d45601f89fd379a928a1812c8779440c81abba708082c946445af1d6b62d5f16e2a7cf4f30d9d6587b89425fae801ff + languageName: node + linkType: hard + "strip-json-comments@npm:~2.0.1": version: 2.0.1 resolution: "strip-json-comments@npm:2.0.1" @@ -10043,6 +10165,13 @@ __metadata: languageName: node linkType: hard +"unicorn-magic@npm:^0.3.0": + version: 0.3.0 + resolution: "unicorn-magic@npm:0.3.0" + checksum: 10c0/0a32a997d6c15f1c2a077a15b1c4ca6f268d574cf5b8975e778bb98e6f8db4ef4e86dfcae4e158cd4c7e38fb4dd383b93b13eefddc7f178dea13d3ac8a603271 + languageName: node + linkType: hard + "unique-filename@npm:^4.0.0": version: 4.0.0 resolution: "unique-filename@npm:4.0.0" @@ -10664,6 +10793,13 @@ __metadata: languageName: node linkType: hard +"yoctocolors@npm:^2.0.0": + version: 2.1.1 + resolution: "yoctocolors@npm:2.1.1" + checksum: 10c0/85903f7fa96f1c70badee94789fade709f9d83dab2ec92753d612d84fcea6d34c772337a9f8914c6bed2f5fc03a428ac5d893e76fab636da5f1236ab725486d0 + languageName: node + linkType: hard + "zen-observable-ts@npm:^1.2.5": version: 1.2.5 resolution: "zen-observable-ts@npm:1.2.5" From 9715149e0a6c1414dab666f4d41bf17aaa4a5e57 Mon Sep 17 00:00:00 2001 From: rabi-siddique Date: Wed, 18 Dec 2024 16:24:12 +0500 Subject: [PATCH 14/16] ci: validate liquidating vaults --- .github/scripts/changePrice.mjs | 36 --- .github/scripts/createVault.mjs | 37 --- .github/scripts/placeBid.mjs | 47 --- .github/workflows/liquidation.yml | 49 +-- .github/workflows/pr.yaml | 2 +- package.json | 3 +- scripts/changePrice.mjs | 22 ++ scripts/checkLiquidation.mjs | 121 +++++++ {.github/scripts => scripts}/ci.package.json | 0 {.github/scripts => scripts}/ci.tsconfig.json | 0 .../scripts => scripts}/copy-ts-config.sh | 0 scripts/createVault.mjs | 31 ++ .../scripts => scripts}/getActiveVaults.mjs | 3 +- scripts/placeBid.mjs | 37 +++ yarn.lock | 302 ++++++++++++++++-- 15 files changed, 518 insertions(+), 172 deletions(-) delete mode 100644 .github/scripts/changePrice.mjs delete mode 100644 .github/scripts/createVault.mjs delete mode 100644 .github/scripts/placeBid.mjs create mode 100644 scripts/changePrice.mjs create mode 100644 scripts/checkLiquidation.mjs rename {.github/scripts => scripts}/ci.package.json (100%) rename {.github/scripts => scripts}/ci.tsconfig.json (100%) rename {.github/scripts => scripts}/copy-ts-config.sh (100%) create mode 100644 scripts/createVault.mjs rename {.github/scripts => scripts}/getActiveVaults.mjs (97%) create mode 100644 scripts/placeBid.mjs diff --git a/.github/scripts/changePrice.mjs b/.github/scripts/changePrice.mjs deleted file mode 100644 index 707293b2..00000000 --- a/.github/scripts/changePrice.mjs +++ /dev/null @@ -1,36 +0,0 @@ -import { execa } from 'execa'; -import assert from 'assert'; - -const agops = '/usr/src/agoric-sdk/packages/agoric-cli/bin/agops'; - -const amount = process.env.amount; -const containerName = process.env.containerName; -const agoricNet = process.env.agoricNet; - -if (!amount || !containerName || !agoricNet) { - console.error('Error: Missing one or more required parameters:'); - if (!amount) console.error('Missing amount'); - if (!containerName) console.error('Missing containerName'); - if (!agoricNet) console.error('Missing agoricNet'); - process.exit(1); -} - -const setAtomPrice = async (amount, containerName, agoricNet) => { - try { - console.log(`Initiating price change to ${amount} for ATOM...`); - - const env = { - AGORIC_NET: agoricNet, - }; - - const command = `${agops} oracle setPrice --keys gov1,gov2 --pair ATOM.USD --price ${amount} --keyring-backend=test`; - const { stdout, stderr } = await execa('docker', ['exec', containerName, command], { env, shell: true }); - - assert.strictEqual(stderr, '', `Expected stderr to be empty, but received: '${stderr}'`); - console.log('Standard output:', stdout); - } catch (error) { - console.error('Error:', error); - } -}; - -setAtomPrice(amount, containerName, agoricNet); diff --git a/.github/scripts/createVault.mjs b/.github/scripts/createVault.mjs deleted file mode 100644 index ad0bbff8..00000000 --- a/.github/scripts/createVault.mjs +++ /dev/null @@ -1,37 +0,0 @@ -import { execa } from 'execa'; -import assert from 'assert'; - -const agops = '/usr/src/agoric-sdk/packages/agoric-cli/bin/agops'; - -const createVault = async (containerName, agoricNet, userKey, wantMinted, giveCollateral) => { - console.log('Starting the vault creation process...'); - - try { - const env = { - AGORIC_NET: agoricNet, - }; - - const command = `${agops} vaults open --wantMinted ${wantMinted} --giveCollateral ${giveCollateral} > /tmp/want-ist.json`; - await execa('docker', ['exec', containerName, `bash -c "${command}"`], { env, shell: true }); - - const broadCastCommand = `${agops} perf satisfaction --executeOffer /tmp/want-ist.json --from ${userKey} --keyring-backend=test`; - const { stdout } = await execa('docker', ['exec', containerName, broadCastCommand], { - env, - shell: true, - }); - - assert.ok(!stdout.includes('Error'), `Expected 'stdout' not to contain 'Error'`); - console.log('Standard output:', stdout); - } catch (error) { - console.error('Error during vault creation:', error); - process.exit(1); - } -}; - -const containerName = process.env.containerName; -const agoricNet = process.env.agoricNet; -const userKey = process.env.userKey; -const wantMinted = process.env.wantMinted; -const giveCollateral = process.env.giveCollateral; - -createVault(containerName, agoricNet, userKey, wantMinted, giveCollateral); diff --git a/.github/scripts/placeBid.mjs b/.github/scripts/placeBid.mjs deleted file mode 100644 index 100081c5..00000000 --- a/.github/scripts/placeBid.mjs +++ /dev/null @@ -1,47 +0,0 @@ -import { execa } from 'execa'; -import assert from 'assert'; - -const agops = '/usr/src/agoric-sdk/packages/agoric-cli/bin/agops'; - -const placeBid = async ({ fromAddress, giveAmount, priceOrDiscount, commandType, agoricNet, containerName }) => { - console.log('Starting the bidding process...'); - - try { - const env = { - AGORIC_NET: agoricNet, - }; - - let commandTypeOption; - if (commandType === 'by-price') { - commandTypeOption = 'by-price --price'; - } else if (commandType === 'by-discount') { - commandTypeOption = 'by-discount --discount'; - } - - const command = `${agops} inter bid ${commandTypeOption} ${priceOrDiscount} --from ${fromAddress} --give ${giveAmount} --keyring-backend=test`; - - console.log('Executing command in the container...'); - const { stdout } = await execa('docker', ['exec', containerName, `bash -c "${command}"`], { - env, - shell: true, - }); - - assert.ok(stdout.includes('Your bid has been accepted')); - console.log('Standard output:', stdout); - } catch (error) { - console.error('Error during bid placement:', error); - process.exit(1); - } -}; - -const bidInfo = { - fromAddress: process.env.fromAddress, - giveAmount: process.env.giveAmount, - priceOrDiscount: process.env.priceOrDiscount, - commandType: process.env.commandType, - agoricNet: process.env.agoricNet, - commandTimeout: process.env.commandTimeout, - containerName: process.env.containerName, -}; - -placeBid(bidInfo); diff --git a/.github/workflows/liquidation.yml b/.github/workflows/liquidation.yml index cb0f38d8..e164a366 100644 --- a/.github/workflows/liquidation.yml +++ b/.github/workflows/liquidation.yml @@ -38,87 +38,98 @@ jobs: done - name: Set ATOM Price to 12.34 - run: node .github/scripts/changePrice.mjs + run: ./scripts/changePrice.mjs env: amount: 12.34 containerName: agd - agoricNet: local + AGORIC_NET: local - name: Get active vaults - run: node .github/scripts/getActiveVaults.mjs + run: ./scripts/getActiveVaults.mjs env: apiUrl: 'http://localhost:3000/' - expectedVaults: '7' + expectedVaults: 7 - name: Create Vault with 100 Minted and 15 Collateral - run: node .github/scripts/createVault.mjs + run: ./scripts/createVault.mjs env: wantMinted: '100' giveCollateral: '15' userKey: 'gov3' - agoricNet: 'local' + AGORIC_NET: 'local' commandTimeout: '120' containerName: 'agd' - name: Create Vault with 103 Minted and 15 Collateral - run: node .github/scripts/createVault.mjs + run: ./scripts/createVault.mjs env: wantMinted: '103' giveCollateral: '15' userKey: 'gov3' - agoricNet: 'local' + AGORIC_NET: 'local' commandTimeout: '120' containerName: 'agd' - name: Create Vault with 105 Minted and 15 Collateral - run: node .github/scripts/createVault.mjs + run: ./scripts/createVault.mjs env: wantMinted: '105' giveCollateral: '15' userKey: 'gov3' - agoricNet: 'local' + AGORIC_NET: 'local' commandTimeout: '120' containerName: 'agd' - name: Get active vaults - run: node .github/scripts/getActiveVaults.mjs + run: ./scripts/getActiveVaults.mjs env: apiUrl: 'http://localhost:3000/' expectedVaults: 10 - name: Place bid for 90IST - run: node .github/scripts/placeBid.mjs + run: ./scripts/placeBid.mjs env: fromAddress: 'gov1' giveAmount: '90IST' priceOrDiscount: '9' commandType: 'by-price' - agoricNet: 'local' + AGORIC_NET: 'local' containerName: 'agd' - name: Place bid for 80IST - run: node .github/scripts/placeBid.mjs + run: ./scripts/placeBid.mjs env: fromAddress: 'gov1' giveAmount: '80IST' priceOrDiscount: '10' commandType: 'by-discount' - agoricNet: 'local' + AGORIC_NET: 'local' containerName: 'agd' - name: Place bid for 150IST - run: node .github/scripts/placeBid.mjs + run: ./scripts/placeBid.mjs env: fromAddress: 'gov1' giveAmount: '150IST' priceOrDiscount: '15' commandType: 'by-discount' - agoricNet: 'local' + AGORIC_NET: 'local' containerName: 'agd' - name: Set ATOM Price to 9.99 - run: node .github/scripts/changePrice.mjs + run: ./scripts/changePrice.mjs env: amount: 9.99 containerName: agd - agoricNet: local + AGORIC_NET: local + + - name: Check liquidation indexing + run: ./scripts/checkLiquidation.mjs + env: + apiUrl: 'http://localhost:3000/' + + - name: Get active vaults + run: ./scripts/getActiveVaults.mjs + env: + apiUrl: 'http://localhost:3000/' + expectedVaults: 7 diff --git a/.github/workflows/pr.yaml b/.github/workflows/pr.yaml index 7e5e2084..c19f2b3a 100644 --- a/.github/workflows/pr.yaml +++ b/.github/workflows/pr.yaml @@ -7,7 +7,7 @@ jobs: runs-on: ubuntu-latest services: a3p: - image: ghcr.io/agoric/agoric-3-proposals@sha256:644e09bf041e5588570ff9a49e6129cc468e9c8458417541027e8532cb91083b + image: ghcr.io/agoric/agoric-3-proposals:use-upgrade-17 ports: - 26657:26657 postgres: diff --git a/package.json b/package.json index 4f8f205b..8c88226e 100644 --- a/package.json +++ b/package.json @@ -23,9 +23,10 @@ "author": "Agoric OpCo", "license": "Apache-2.0", "devDependencies": { + "@agoric/internal": "0.4.0-u18.0", "@cosmjs/stargate": "^0.28.9", "@subql/cli": "^5.4.0", - "@subql/node-cosmos": "4.2.1", + "@subql/node-cosmos": "^4.2.1", "@subql/testing": "latest", "execa": "^9.5.2", "prettier": "^3.4.2", diff --git a/scripts/changePrice.mjs b/scripts/changePrice.mjs new file mode 100644 index 00000000..e72900b9 --- /dev/null +++ b/scripts/changePrice.mjs @@ -0,0 +1,22 @@ +#! /usr/bin/env node +import { execa } from 'execa'; +import { assertAllDefined } from '@agoric/internal'; + +const agops = '/usr/src/agoric-sdk/packages/agoric-cli/bin/agops'; +const { AGORIC_NET, amount, containerName } = process.env; + +assertAllDefined({ AGORIC_NET, amount, containerName }); + +try { + const env = { + AGORIC_NET, + }; + + console.log(`Initiating price change to ${amount} for ATOM...`); + const command = `${agops} oracle setPrice --keys gov1,gov2 --pair ATOM.USD --price ${amount} --keyring-backend=test`; + const { stdout } = await execa('docker', ['exec', containerName, command], { env, shell: true }); + + console.log('Standard output:', stdout); +} catch (error) { + console.error('Error:', error); +} diff --git a/scripts/checkLiquidation.mjs b/scripts/checkLiquidation.mjs new file mode 100644 index 00000000..9b8208ed --- /dev/null +++ b/scripts/checkLiquidation.mjs @@ -0,0 +1,121 @@ +#! /usr/bin/env node +/* eslint-env node */ +import { equal } from 'node:assert/strict'; +const delay = (ms) => { + return new Promise((resolve) => setTimeout(resolve, ms)); +}; + +const states = { + liquidated: 'liquidated', + liquidating: 'liquidating', +}; + +const expectedLiquidating = { + id: [ + 'published.vaultFactory.managers.manager0.vaults.vault10-liquidating', + 'published.vaultFactory.managers.manager0.vaults.vault11-liquidating', + 'published.vaultFactory.managers.manager0.vaults.vault12-liquidating', + ], + debt: ['100500000', '103515000', '105525000'], + balance: ['15000000', '15000000', '15000000'], + denom: ['ATOM', 'ATOM', 'ATOM'], +}; + +const expectedLiquidated = { + id: [ + 'published.vaultFactory.managers.manager0.vaults.vault10-liquidated', + 'published.vaultFactory.managers.manager0.vaults.vault11-liquidated', + 'published.vaultFactory.managers.manager0.vaults.vault12-liquidated', + ], + debt: ['0', '0', '0'], + balance: ['3425146', '3077900', '2846403'], + denom: ['ATOM', 'ATOM', 'ATOM'], +}; + +const validate = async ({ apiUrl, maxRetries, retryDuration, expectations, filterState }) => { + let retries = 0; + + while (retries < maxRetries) { + try { + const graphqlQuery = { + query: `query { + vaultLiquidations (filter: {state: {equalTo: "${filterState}"}}) { + nodes { + id + denom + debt + state + balance + } + } + }`, + }; + + const response = await fetch(apiUrl, { + method: 'POST', + headers: { + 'Content-Type': 'application/json', + Accept: 'application/json', + }, + body: JSON.stringify(graphqlQuery), + }); + + const jsonResponse = await response.json(); + console.log('Response:', JSON.stringify(jsonResponse)); + + const nodes = jsonResponse?.data?.vaultLiquidations?.nodes || []; + if (nodes.length !== 3) { + console.error(`Attempt ${retries + 1}: No data available`); + retries++; + await delay(retryDuration); + continue; + } + + nodes.sort((a, b) => a.id.localeCompare(b.id)); + console.log('Sorted Nodes:', JSON.stringify(nodes)); + + for (const key of Object.keys(expectations)) { + for (let i = 0; i < nodes.length; i++) { + equal(nodes[i][key], expectations[i].key); + } + } + + console.log('All validations passed successfully.'); + return; + } catch (error) { + console.error(`Error on attempt ${retries + 1} fetching active vaults:`, error); + retries++; + await delay(retryDuration); + } + } + + console.error('Maximum retry attempts reached. Exiting...'); + process.exit(1); +}; + +const apiUrl = process.env.API_URL || 'http://localhost:3000/'; +console.log(`API URL set to: ${apiUrl}`); + +try { + console.log('Validating liquidating vaults...'); + await validate({ + apiUrl, + expectations: expectedLiquidating, + maxRetries: 6, + retryDuration: 3 * 60 * 1000, + filterState: states.liquidating, + }); + console.log('Validation successful for liquidating vaults.'); + + console.log('Validating liquidated vaults...'); + await validate({ + apiUrl, + expectations: expectedLiquidated, + maxRetries: 3, + retryDuration: 2 * 60 * 1000, + filterState: states.liquidated, + }); + console.log('Validation successful for liquidated vaults.'); +} catch (error) { + console.error('Validation failed:', error); +} diff --git a/.github/scripts/ci.package.json b/scripts/ci.package.json similarity index 100% rename from .github/scripts/ci.package.json rename to scripts/ci.package.json diff --git a/.github/scripts/ci.tsconfig.json b/scripts/ci.tsconfig.json similarity index 100% rename from .github/scripts/ci.tsconfig.json rename to scripts/ci.tsconfig.json diff --git a/.github/scripts/copy-ts-config.sh b/scripts/copy-ts-config.sh similarity index 100% rename from .github/scripts/copy-ts-config.sh rename to scripts/copy-ts-config.sh diff --git a/scripts/createVault.mjs b/scripts/createVault.mjs new file mode 100644 index 00000000..241df2f2 --- /dev/null +++ b/scripts/createVault.mjs @@ -0,0 +1,31 @@ +#! /usr/bin/env node +import { execa } from 'execa'; +import assert from 'node:assert/strict'; +import { assertAllDefined } from '@agoric/internal'; + +const agops = '/usr/src/agoric-sdk/packages/agoric-cli/bin/agops'; + +const { AGORIC_NET, userKey, containerName, wantMinted, giveCollateral } = process.env; +assertAllDefined({ AGORIC_NET, userKey, containerName, wantMinted, giveCollateral }); + +try { + const env = { + AGORIC_NET, + }; + + console.log('Starting the vault creation process...'); + const command = `${agops} vaults open --wantMinted ${wantMinted} --giveCollateral ${giveCollateral} > /tmp/want-ist.json`; + await execa('docker', ['exec', containerName, `bash -c "${command}"`], { env, shell: true }); + + const broadCastCommand = `${agops} perf satisfaction --executeOffer /tmp/want-ist.json --from ${userKey} --keyring-backend=test`; + const { stdout } = await execa('docker', ['exec', containerName, broadCastCommand], { + env, + shell: true, + }); + + assert.ok(!stdout.includes('Error'), `Expected 'stdout' not to contain 'Error'`); + console.log('Standard output:', stdout); +} catch (error) { + console.error('Error during vault creation:', error); + process.exit(1); +} diff --git a/.github/scripts/getActiveVaults.mjs b/scripts/getActiveVaults.mjs similarity index 97% rename from .github/scripts/getActiveVaults.mjs rename to scripts/getActiveVaults.mjs index a62f48f9..4d4cb21c 100644 --- a/.github/scripts/getActiveVaults.mjs +++ b/scripts/getActiveVaults.mjs @@ -1,4 +1,5 @@ -import fetch from 'node-fetch'; +#! /usr/bin/env node +/* eslint-env node */ const delay = (ms) => { return new Promise((resolve) => setTimeout(resolve, ms)); diff --git a/scripts/placeBid.mjs b/scripts/placeBid.mjs new file mode 100644 index 00000000..8ee96e7a --- /dev/null +++ b/scripts/placeBid.mjs @@ -0,0 +1,37 @@ +#! /usr/bin/env node +import { execa } from 'execa'; +import assert from 'node:assert/strict'; +import { assertAllDefined } from '@agoric/internal'; + +const agops = '/usr/src/agoric-sdk/packages/agoric-cli/bin/agops'; + +const { AGORIC_NET, fromAddress, giveAmount, priceOrDiscount, commandType, containerName } = process.env; +assertAllDefined({ AGORIC_NET, fromAddress, giveAmount, priceOrDiscount, commandType, containerName }); + +try { + const env = { + AGORIC_NET, + }; + + let commandTypeOption; + if (commandType === 'by-price') { + commandTypeOption = 'by-price --price'; + } else if (commandType === 'by-discount') { + commandTypeOption = 'by-discount --discount'; + } + + console.log('Starting the bidding process...'); + const command = `${agops} inter bid ${commandTypeOption} ${priceOrDiscount} --from ${fromAddress} --give ${giveAmount} --keyring-backend=test`; + + console.log('Executing command in the container...'); + const { stdout } = await execa('docker', ['exec', containerName, `bash -c "${command}"`], { + env, + shell: true, + }); + + assert.ok(stdout.includes('Your bid has been accepted')); + console.log('Standard output:', stdout); +} catch (error) { + console.error('Error during bid placement:', error); + process.exit(1); +} diff --git a/yarn.lock b/yarn.lock index c75cf26d..9b3c15a8 100644 --- a/yarn.lock +++ b/yarn.lock @@ -5,6 +5,54 @@ __metadata: version: 8 cacheKey: 10c0 +"@agoric/base-zone@npm:^0.1.1-u18.0": + version: 0.1.1-upgrade-18-dev-ef001c0.0 + resolution: "@agoric/base-zone@npm:0.1.1-upgrade-18-dev-ef001c0.0" + dependencies: + "@agoric/store": "npm:0.9.3-upgrade-18-dev-ef001c0.0+ef001c0" + "@endo/common": "npm:^1.2.7" + "@endo/errors": "npm:^1.2.7" + "@endo/exo": "npm:^1.5.6" + "@endo/far": "npm:^1.1.8" + "@endo/pass-style": "npm:^1.4.6" + "@endo/patterns": "npm:^1.4.6" + checksum: 10c0/0df4eba4133cf41c8a3e4edbfe5ba74a0976fde58687c50a1fb32b932160538ec1af077495c375b3ee223df271086500e571b02086275c8ea5be2d5c6c658702 + languageName: node + linkType: hard + +"@agoric/internal@npm:0.4.0-u18.0": + version: 0.4.0-u18.0 + resolution: "@agoric/internal@npm:0.4.0-u18.0" + dependencies: + "@agoric/base-zone": "npm:^0.1.1-u18.0" + "@endo/common": "npm:^1.2.7" + "@endo/errors": "npm:^1.2.7" + "@endo/far": "npm:^1.1.8" + "@endo/init": "npm:^1.1.6" + "@endo/marshal": "npm:^1.6.1" + "@endo/pass-style": "npm:^1.4.6" + "@endo/patterns": "npm:^1.4.6" + "@endo/promise-kit": "npm:^1.1.7" + "@endo/stream": "npm:^1.2.7" + anylogger: "npm:^0.21.0" + jessie.js: "npm:^0.3.4" + checksum: 10c0/5a7d36cb8faf69eabf9d53f6ea79bcd10187d83782e6fa06d8debd5d5565ecdbf33ef85efbe8697e91eed09c21599ab03b8b746065611513cc54b467a87ce427 + languageName: node + linkType: hard + +"@agoric/store@npm:0.9.3-upgrade-18-dev-ef001c0.0+ef001c0": + version: 0.9.3-upgrade-18-dev-ef001c0.0 + resolution: "@agoric/store@npm:0.9.3-upgrade-18-dev-ef001c0.0" + dependencies: + "@endo/errors": "npm:^1.2.7" + "@endo/exo": "npm:^1.5.6" + "@endo/marshal": "npm:^1.6.1" + "@endo/pass-style": "npm:^1.4.6" + "@endo/patterns": "npm:^1.4.6" + checksum: 10c0/8ca7d3a1b4fe909b98146d6c91c0a79a812f1df27ce298d791a0a1b1224f344eacb756be7a6c5c5abc16a875855b99eeddb0d058bcdcea01a55ccf0e2b8bc8ff + languageName: node + linkType: hard + "@ampproject/remapping@npm:^2.1.0, @ampproject/remapping@npm:^2.2.0": version: 2.3.0 resolution: "@ampproject/remapping@npm:2.3.0" @@ -1954,6 +2002,163 @@ __metadata: languageName: node linkType: hard +"@endo/base64@npm:^1.0.9": + version: 1.0.9 + resolution: "@endo/base64@npm:1.0.9" + checksum: 10c0/63e487cf59b50a080fab389a8ab24d66264910ecf375dc19677c2ee7421d92a4be9c85e435b216b4adc9983384073a7eb753223f85ba77aec8d9fd3e0c1fe090 + languageName: node + linkType: hard + +"@endo/common@npm:^1.2.7, @endo/common@npm:^1.2.8": + version: 1.2.8 + resolution: "@endo/common@npm:1.2.8" + dependencies: + "@endo/errors": "npm:^1.2.8" + "@endo/eventual-send": "npm:^1.2.8" + "@endo/promise-kit": "npm:^1.1.8" + checksum: 10c0/c9465721095d9f06278b6550909a02c330c7a69223f11aff29759067586d41b86054127639fa2c2c0345d0d0aa43518e5b72d5c547b67bfe8e802cd21756d87b + languageName: node + linkType: hard + +"@endo/env-options@npm:^1.1.8": + version: 1.1.8 + resolution: "@endo/env-options@npm:1.1.8" + checksum: 10c0/2f519f48a5b966dbd9e66134d4abc89ff02b9791d21146b49031ceb694584f3f41c6119125b6bb4eb0d347f5bcd846473b5f3c4ae6bae3dac19402fcaf522520 + languageName: node + linkType: hard + +"@endo/errors@npm:^1.2.7, @endo/errors@npm:^1.2.8": + version: 1.2.8 + resolution: "@endo/errors@npm:1.2.8" + dependencies: + ses: "npm:^1.10.0" + checksum: 10c0/3f33fc7119ab840ad0f5bdfb70e73cc99630f09593c31928e30de4d9c8e898c85397c5170964d54c819a757a74d3b005f6275480ff8d0f1aa2aa8ef872852e97 + languageName: node + linkType: hard + +"@endo/eventual-send@npm:^1.2.8": + version: 1.2.8 + resolution: "@endo/eventual-send@npm:1.2.8" + dependencies: + "@endo/env-options": "npm:^1.1.8" + checksum: 10c0/d7c16c935441b67d029fcb6785f425a1194fb7f936e4b20dde21eb393266cb7366edf7a95d3fdfa96cd4a3246a3659a06d0dbb3c1217045e1718e1cf34c7a3bd + languageName: node + linkType: hard + +"@endo/exo@npm:^1.5.6": + version: 1.5.7 + resolution: "@endo/exo@npm:1.5.7" + dependencies: + "@endo/common": "npm:^1.2.8" + "@endo/env-options": "npm:^1.1.8" + "@endo/errors": "npm:^1.2.8" + "@endo/eventual-send": "npm:^1.2.8" + "@endo/far": "npm:^1.1.9" + "@endo/pass-style": "npm:^1.4.7" + "@endo/patterns": "npm:^1.4.7" + checksum: 10c0/0193de0606a7f07f207f3dd8bb71ec6be0acfb0ff5ef570f03cbbcaed888db68e451082c34764de8ee301f8d2d175e6c5a5405e76367c27151d644536bdf57a4 + languageName: node + linkType: hard + +"@endo/far@npm:^1.0.0, @endo/far@npm:^1.1.8, @endo/far@npm:^1.1.9": + version: 1.1.9 + resolution: "@endo/far@npm:1.1.9" + dependencies: + "@endo/errors": "npm:^1.2.8" + "@endo/eventual-send": "npm:^1.2.8" + "@endo/pass-style": "npm:^1.4.7" + checksum: 10c0/e0d95743c25183b961aa1f11dd81c067739fd2fb3deeab58520e949961eacba9ed109bb01b9ed820d596e8a043b6721d650d9624abf0263296cca647e7286a2e + languageName: node + linkType: hard + +"@endo/init@npm:^1.1.6": + version: 1.1.7 + resolution: "@endo/init@npm:1.1.7" + dependencies: + "@endo/base64": "npm:^1.0.9" + "@endo/eventual-send": "npm:^1.2.8" + "@endo/lockdown": "npm:^1.0.13" + "@endo/promise-kit": "npm:^1.1.8" + checksum: 10c0/6cfcc244f02da9883f65a8f34da9483a628d5350192983c53d5116b12403dc5693145c6349b6c3ca381b6b8d9590cee16f90440dc0e2da5f525e13079d6c9a2f + languageName: node + linkType: hard + +"@endo/lockdown@npm:^1.0.13": + version: 1.0.13 + resolution: "@endo/lockdown@npm:1.0.13" + dependencies: + ses: "npm:^1.10.0" + checksum: 10c0/9df04cc477595b368088a1d445f2241d8a152cb4dcf6a79d39d4804594dd8ff472380ab2bdf262adeb5b4b7cfc73effb6cc716c5a3aeca282801d57fe8a018a0 + languageName: node + linkType: hard + +"@endo/marshal@npm:^1.6.1, @endo/marshal@npm:^1.6.2": + version: 1.6.2 + resolution: "@endo/marshal@npm:1.6.2" + dependencies: + "@endo/common": "npm:^1.2.8" + "@endo/errors": "npm:^1.2.8" + "@endo/eventual-send": "npm:^1.2.8" + "@endo/nat": "npm:^5.0.13" + "@endo/pass-style": "npm:^1.4.7" + "@endo/promise-kit": "npm:^1.1.8" + checksum: 10c0/bdb634a77c2147c1359792531822aabe642a5e4d39f496dd57bb97367617a2f2d72edaaa50c51ed6a2ec1f2c08deab6a571c3dd8ffa260d441d25f53606902b1 + languageName: node + linkType: hard + +"@endo/nat@npm:^5.0.13": + version: 5.0.13 + resolution: "@endo/nat@npm:5.0.13" + checksum: 10c0/78578de4567c9bc4c6f50638c688886c07c38177a8d44192230d344221da06ccffc6d9ef8d423e27198d864ed7c57ef5ced9b1d05922eaa4e40bf82856b1aa11 + languageName: node + linkType: hard + +"@endo/pass-style@npm:^1.4.6, @endo/pass-style@npm:^1.4.7": + version: 1.4.7 + resolution: "@endo/pass-style@npm:1.4.7" + dependencies: + "@endo/env-options": "npm:^1.1.8" + "@endo/errors": "npm:^1.2.8" + "@endo/eventual-send": "npm:^1.2.8" + "@endo/promise-kit": "npm:^1.1.8" + "@fast-check/ava": "npm:^1.1.5" + checksum: 10c0/ee30e011fb08c292718a315f2ebd5ee2da6d918bf2cdaf2b269e123207c642fa1525493c41180db8c941e1a1959369730114b116656c99e8bb107ca5917f3f4e + languageName: node + linkType: hard + +"@endo/patterns@npm:^1.4.6, @endo/patterns@npm:^1.4.7": + version: 1.4.7 + resolution: "@endo/patterns@npm:1.4.7" + dependencies: + "@endo/common": "npm:^1.2.8" + "@endo/errors": "npm:^1.2.8" + "@endo/eventual-send": "npm:^1.2.8" + "@endo/marshal": "npm:^1.6.2" + "@endo/promise-kit": "npm:^1.1.8" + checksum: 10c0/358720438a019847406dfad9f23fc9b565c955ffd86d75693cea994c492dd46efaf189502f04b04f8870e6d50ffcb44ffa1e1dd3a0d6b2dfbbe57edeb994b83b + languageName: node + linkType: hard + +"@endo/promise-kit@npm:^1.1.7, @endo/promise-kit@npm:^1.1.8": + version: 1.1.8 + resolution: "@endo/promise-kit@npm:1.1.8" + dependencies: + ses: "npm:^1.10.0" + checksum: 10c0/3a51755822bd4112474bec584005b81f9ffe6a6b590faa16cff7a4994010d001d6d190f58a1e890d85b0feb0eb052d79ed2c5ed88977afb0e47ca53b6b199196 + languageName: node + linkType: hard + +"@endo/stream@npm:^1.2.7": + version: 1.2.8 + resolution: "@endo/stream@npm:1.2.8" + dependencies: + "@endo/eventual-send": "npm:^1.2.8" + "@endo/promise-kit": "npm:^1.1.8" + ses: "npm:^1.10.0" + checksum: 10c0/f435f7650020b32c10bb4cb139910b363b4d4f22bcf9e7a659d3d2eae694a3ea43c3af49c80370760a573370429e5fbe1619dec631251578d4c5eba9ff161613 + languageName: node + linkType: hard + "@ethersproject/address@npm:^5.6.0": version: 5.7.0 resolution: "@ethersproject/address@npm:5.7.0" @@ -2014,6 +2219,17 @@ __metadata: languageName: node linkType: hard +"@fast-check/ava@npm:^1.1.5": + version: 1.2.1 + resolution: "@fast-check/ava@npm:1.2.1" + dependencies: + fast-check: "npm:^3.0.0" + peerDependencies: + ava: ^4 || ^5 || ^6 + checksum: 10c0/3800098fd7e8098102544a2f7a595351d063a7ebaeca18ed4901df5ec2679da2330ba8c0db2c820721d4cbb3e23d817ba22fec6d058957930e229f44fa71a684 + languageName: node + linkType: hard + "@graphql-typed-document-node/core@npm:^3.1.1": version: 3.2.0 resolution: "@graphql-typed-document-node/core@npm:3.2.0" @@ -3228,9 +3444,9 @@ __metadata: languageName: node linkType: hard -"@subql/common-cosmos@npm:5.0.6": - version: 5.0.6 - resolution: "@subql/common-cosmos@npm:5.0.6" +"@subql/common-cosmos@npm:5.1.0": + version: 5.1.0 + resolution: "@subql/common-cosmos@npm:5.1.0" dependencies: "@cosmwasm/ts-codegen": "npm:^1.11.1" "@protobufs/cosmos": "npm:^0.1.0" @@ -3240,7 +3456,7 @@ __metadata: "@protobufs/google": "npm:^0.0.10" "@protobufs/ibc": "npm:^0.1.0" "@protobufs/tendermint": "npm:^0.0.10" - "@subql/common": "npm:^5.2.1" + "@subql/common": "npm:^5.2.2" "@subql/types-cosmos": "npm:4.0.0" "@subql/x-cosmology-telescope": "npm:^1.4.14" fs-extra: "npm:^11.1.1" @@ -3250,11 +3466,11 @@ __metadata: class-transformer: "*" class-validator: "*" ejs: "*" - checksum: 10c0/7c1b2beb1d0497d1aa4bbf987c2bd91ccbe4f13456259dcdd9dc6fae10e791e7efdf6e01061ce35e1e219dd41429fb639595053574b75f301d911061af268ca1 + checksum: 10c0/83f6eabcdf6dcf2d9d8e499201f7751eb2009ec0c501be2c58b0e269ee40d77d34db90090562afbf91ff10bf9adaec9e04aff025766829200c95f035eff58c4b languageName: node linkType: hard -"@subql/common@npm:5.2.2": +"@subql/common@npm:5.2.2, @subql/common@npm:^5.2.2": version: 5.2.2 resolution: "@subql/common@npm:5.2.2" dependencies: @@ -3271,22 +3487,6 @@ __metadata: languageName: node linkType: hard -"@subql/common@npm:^5.2.1": - version: 5.2.1 - resolution: "@subql/common@npm:5.2.1" - dependencies: - "@subql/types-core": "npm:2.0.0" - axios: "npm:^0.28.0" - class-transformer: "npm:^0.5.1" - class-validator: "npm:^0.14.1" - js-yaml: "npm:^4.1.0" - reflect-metadata: "npm:^0.1.14" - semver: "npm:^7.6.3" - update-notifier: "npm:^5.1.0" - checksum: 10c0/02ac5e46489e9eeb73f01c007e868d491f415462d654149bb296f1c4f0d74ff67b4881458a154f237a1e88df7f4a99fdf0ff44739b85ae44b871234642753fc6 - languageName: node - linkType: hard - "@subql/node-core@npm:^16.1.0": version: 16.1.0 resolution: "@subql/node-core@npm:16.1.0" @@ -3319,9 +3519,9 @@ __metadata: languageName: node linkType: hard -"@subql/node-cosmos@npm:4.2.1": - version: 4.2.1 - resolution: "@subql/node-cosmos@npm:4.2.1" +"@subql/node-cosmos@npm:^4.2.1": + version: 4.3.0 + resolution: "@subql/node-cosmos@npm:4.3.0" dependencies: "@cosmjs/cosmwasm-stargate": "npm:^0.32.4" "@cosmjs/proto-signing": "npm:^0.32.4" @@ -3333,9 +3533,9 @@ __metadata: "@nestjs/event-emitter": "npm:^2.0.0" "@nestjs/platform-express": "npm:^9.4.0" "@nestjs/schedule": "npm:^3.0.1" - "@subql/common": "npm:^5.2.1" - "@subql/common-cosmos": "npm:5.0.6" - "@subql/node-core": "npm:^15.0.2" + "@subql/common": "npm:^5.2.2" + "@subql/common-cosmos": "npm:5.1.0" + "@subql/node-core": "npm:^16.1.0" "@subql/types-cosmos": "npm:4.0.0" lodash: "npm:^4.17.21" protobufjs: "npm:^6.11.4" @@ -3346,7 +3546,7 @@ __metadata: "@subql/utils": "*" bin: subql-node-cosmos: ./bin/run - checksum: 10c0/950dc4aae8bbca6b47c8e618c44d2d7c63ea39206d748f3a4d57a105e88509447fa72c0f6d6fd92b0394aec030f1f9cf932715d864e031cf0ebe49adbf4dcd74 + checksum: 10c0/78cc7dbde1cb39465ec3d1f231105a69e33cd7eb98bcb06d8aa45264ee9eb3b64777147ead5d6d6b9ab92bcfed73dff6344fbb8b23233dc7fda0d5f2885d124a languageName: node linkType: hard @@ -4119,9 +4319,10 @@ __metadata: version: 0.0.0-use.local resolution: "agoric-indexer@workspace:." dependencies: + "@agoric/internal": "npm:0.4.0-u18.0" "@cosmjs/stargate": "npm:^0.28.9" "@subql/cli": "npm:^5.4.0" - "@subql/node-cosmos": "npm:4.2.1" + "@subql/node-cosmos": "npm:^4.2.1" "@subql/testing": "npm:latest" "@subql/types-cosmos": "npm:^4.0.0" "@subql/utils": "npm:^2.17.0" @@ -4270,6 +4471,13 @@ __metadata: languageName: node linkType: hard +"anylogger@npm:^0.21.0": + version: 0.21.0 + resolution: "anylogger@npm:0.21.0" + checksum: 10c0/1ca7fcf5bc2b78d1e1d9b8c8cc7ce50b5c6cc67a8da5a28c9c975b7b46fff255a04abab02de38a5139190c9d8b34b3d6c59af6724521b077f7d7dfbad9b47a9c + languageName: node + linkType: hard + "anymatch@npm:^3.0.3": version: 3.1.3 resolution: "anymatch@npm:3.1.3" @@ -6004,6 +6212,15 @@ __metadata: languageName: node linkType: hard +"fast-check@npm:^3.0.0": + version: 3.23.2 + resolution: "fast-check@npm:3.23.2" + dependencies: + pure-rand: "npm:^6.1.0" + checksum: 10c0/16fcff3c80321ee765e23c3aebd0f6427f175c9c6c1753104ec658970162365dc2d56bda046d815e8f2e90634c07ba7d6f0bcfd327fbd576d98c56a18a9765ed + languageName: node + linkType: hard + "fast-deep-equal@npm:^3.1.1": version: 3.1.3 resolution: "fast-deep-equal@npm:3.1.3" @@ -7149,6 +7366,15 @@ __metadata: languageName: node linkType: hard +"jessie.js@npm:^0.3.4": + version: 0.3.4 + resolution: "jessie.js@npm:0.3.4" + dependencies: + "@endo/far": "npm:^1.0.0" + checksum: 10c0/853ab3f8a0e30df11742882f5e11479d1303033a5a203a247d8ffbf4c6f3f3d4bcbefa53084ae4632e6ab106e348f23dc988280486cbeaaf5d16487fa3d40e96 + languageName: node + linkType: hard + "jest-haste-map@npm:^28.1.3": version: 28.1.3 resolution: "jest-haste-map@npm:28.1.3" @@ -8724,6 +8950,13 @@ __metadata: languageName: node linkType: hard +"pure-rand@npm:^6.1.0": + version: 6.1.0 + resolution: "pure-rand@npm:6.1.0" + checksum: 10c0/1abe217897bf74dcb3a0c9aba3555fe975023147b48db540aa2faf507aee91c03bf54f6aef0eb2bf59cc259a16d06b28eca37f0dc426d94f4692aeff02fb0e65 + languageName: node + linkType: hard + "qs@npm:6.11.0": version: 6.11.0 resolution: "qs@npm:6.11.0" @@ -9296,6 +9529,15 @@ __metadata: languageName: node linkType: hard +"ses@npm:^1.10.0": + version: 1.10.0 + resolution: "ses@npm:1.10.0" + dependencies: + "@endo/env-options": "npm:^1.1.8" + checksum: 10c0/83b92bc49e27af04eeb7ee01a2196a0c4b0906e4de51e70403aa9ffc82be1d27a0c3506f2d54da8d6d260be0855f2123a13a7e2c6896e81ec85899df1a428609 + languageName: node + linkType: hard + "set-cookie-parser@npm:^2.4.8": version: 2.7.1 resolution: "set-cookie-parser@npm:2.7.1" From dfc248340d1af335cbd8dc98bf31d693e22c9769 Mon Sep 17 00:00:00 2001 From: rabi-siddique Date: Wed, 18 Dec 2024 22:10:51 +0500 Subject: [PATCH 15/16] ci: set execute permission for all .mjs files in scripts --- .github/workflows/liquidation.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/liquidation.yml b/.github/workflows/liquidation.yml index e164a366..54cb9d4c 100644 --- a/.github/workflows/liquidation.yml +++ b/.github/workflows/liquidation.yml @@ -37,6 +37,9 @@ jobs: docker logs $container done + - name: Set Execute Permission for All Scripts + run: chmod +x ./scripts/*.mjs + - name: Set ATOM Price to 12.34 run: ./scripts/changePrice.mjs env: From 6a69b4e3f83d347b48c75d7b4be870e425bbb853 Mon Sep 17 00:00:00 2001 From: rabi-siddique Date: Wed, 18 Dec 2024 22:16:56 +0500 Subject: [PATCH 16/16] chore(deps): install ses --- package.json | 2 ++ scripts/changePrice.mjs | 1 + scripts/checkLiquidation.mjs | 2 +- scripts/createVault.mjs | 1 + scripts/lockdown.mjs | 10 ++++++++++ scripts/placeBid.mjs | 1 + yarn.lock | 2 ++ 7 files changed, 18 insertions(+), 1 deletion(-) mode change 100644 => 100755 scripts/changePrice.mjs create mode 100644 scripts/lockdown.mjs diff --git a/package.json b/package.json index 8c88226e..8c7635f5 100644 --- a/package.json +++ b/package.json @@ -25,11 +25,13 @@ "devDependencies": { "@agoric/internal": "0.4.0-u18.0", "@cosmjs/stargate": "^0.28.9", + "@endo/eventual-send": "^1.2.8", "@subql/cli": "^5.4.0", "@subql/node-cosmos": "^4.2.1", "@subql/testing": "latest", "execa": "^9.5.2", "prettier": "^3.4.2", + "ses": "^1.10.0", "starknet": "6.11.0", "typescript": "^5.7.2" }, diff --git a/scripts/changePrice.mjs b/scripts/changePrice.mjs old mode 100644 new mode 100755 index e72900b9..45fbaa7f --- a/scripts/changePrice.mjs +++ b/scripts/changePrice.mjs @@ -1,4 +1,5 @@ #! /usr/bin/env node +import './lockdown.mjs'; import { execa } from 'execa'; import { assertAllDefined } from '@agoric/internal'; diff --git a/scripts/checkLiquidation.mjs b/scripts/checkLiquidation.mjs index 9b8208ed..008f9ca6 100644 --- a/scripts/checkLiquidation.mjs +++ b/scripts/checkLiquidation.mjs @@ -76,7 +76,7 @@ const validate = async ({ apiUrl, maxRetries, retryDuration, expectations, filte for (const key of Object.keys(expectations)) { for (let i = 0; i < nodes.length; i++) { - equal(nodes[i][key], expectations[i].key); + equal(nodes[i][key], expectations[key][i]); } } diff --git a/scripts/createVault.mjs b/scripts/createVault.mjs index 241df2f2..563e1f67 100644 --- a/scripts/createVault.mjs +++ b/scripts/createVault.mjs @@ -1,4 +1,5 @@ #! /usr/bin/env node +import './lockdown.mjs'; import { execa } from 'execa'; import assert from 'node:assert/strict'; import { assertAllDefined } from '@agoric/internal'; diff --git a/scripts/lockdown.mjs b/scripts/lockdown.mjs new file mode 100644 index 00000000..76a83b63 --- /dev/null +++ b/scripts/lockdown.mjs @@ -0,0 +1,10 @@ +import 'ses'; +import '@endo/eventual-send/shim.js'; + +const options = { + overrideTaming: 'severe', + stackFiltering: 'verbose', + errorTaming: 'unsafe', +}; + +lockdown(options); diff --git a/scripts/placeBid.mjs b/scripts/placeBid.mjs index 8ee96e7a..a3e8f847 100644 --- a/scripts/placeBid.mjs +++ b/scripts/placeBid.mjs @@ -1,4 +1,5 @@ #! /usr/bin/env node +import './lockdown.mjs'; import { execa } from 'execa'; import assert from 'node:assert/strict'; import { assertAllDefined } from '@agoric/internal'; diff --git a/yarn.lock b/yarn.lock index 9b3c15a8..3d72bb34 100644 --- a/yarn.lock +++ b/yarn.lock @@ -4321,6 +4321,7 @@ __metadata: dependencies: "@agoric/internal": "npm:0.4.0-u18.0" "@cosmjs/stargate": "npm:^0.28.9" + "@endo/eventual-send": "npm:^1.2.8" "@subql/cli": "npm:^5.4.0" "@subql/node-cosmos": "npm:^4.2.1" "@subql/testing": "npm:latest" @@ -4332,6 +4333,7 @@ __metadata: js-sha256: "npm:^0.11.0" pino: "npm:^7.8.0" prettier: "npm:^3.4.2" + ses: "npm:^1.10.0" starknet: "npm:6.11.0" typescript: "npm:^5.7.2" languageName: unknown