@gensyn-ai/gensyn-delphi-sdk 1.2.1 → 2.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -8,6 +8,64 @@ TypeScript SDK for agents to interact with the Delphi information market platfor
8
8
  npm install @gensyn-ai/gensyn-delphi-sdk
9
9
  ```
10
10
 
11
+ ## What's New in 2.1.0
12
+
13
+ 2.1.0 adds the agent trading competition as a third network. Nothing is breaking — existing
14
+ `testnet` / `mainnet` code is untouched, and every addition is opt-in.
15
+
16
+ **`competition-testnet` is a new `Network`.** Set `network: "competition-testnet"` (or
17
+ `DELPHI_NETWORK=competition-testnet`) to target the competition: the same chain as testnet, its
18
+ own LMSR contracts, the shared testnet REST API, and its own Goldsky subgraph. Trading, quoting,
19
+ redemption and liquidation call signatures are identical, so no call site changes. The client
20
+ sends `X-Delphi-Mode: competition` on REST requests automatically, and caller-supplied
21
+ `extraHeaders` still win. See [Competition networks](#competition-networks).
22
+
23
+ **`listMarkets` and `getMarket` accept an optional `competitionId`.** Omit it and the API reads
24
+ the active competition; pass a competition UUID to read a specific one. Ignored on
25
+ `testnet` / `mainnet`.
26
+
27
+ **`SubgraphClient` takes a `settlementEconomics` option.** The competition's LMSR gateway emits a
28
+ narrower `MarketSettled`, so its subgraph has no `marketCreatorReward`, `refund` or
29
+ `marketCreatorTradingFeesCut`. Pass `settlementEconomics: false` to omit them from
30
+ `getMarketSettlement()`'s query — they come back `null`, so the result shape is unchanged. The
31
+ default is `true`, and `getSubgraph()` sets it correctly per network, so this only matters if you
32
+ construct a `SubgraphClient` yourself against a competition subgraph.
33
+
34
+ If you `switch` exhaustively over the `Network` type, note it has gained a third member.
35
+
36
+ ## Upgrading to 2.0.0
37
+
38
+ 2.0.0 adds support for the automated-settlement deployment, which now receives every new
39
+ market on every network. Most code needs no change — all trading, quoting, redemption and
40
+ liquidation call signatures are identical across both deployments. Three things are breaking.
41
+
42
+ **1. The default subgraph no longer exposes `gatewayWinnerSubmitteds`.** The default
43
+ `subgraphUrl` now points at `delphi-testnet-autoset` / `delphi-mainnet-autoset`, where the
44
+ settlement entity is `gatewayMarketSettleds` with an identical payload. `SubgraphClient` throws
45
+ on GraphQL errors, so a query for the old entity fails hard rather than returning empty. Rename
46
+ the entity, or set `DELPHI_SUBGRAPH_URL` to the previous `delphi-testnet` / `delphi-mainnet`
47
+ subgraphs to keep querying legacy history. `gatewayBuys`, `gatewaySells`, `gatewayRedemptions`
48
+ and `gatewayLiquidations` are unchanged.
49
+
50
+ **2. Status fields are narrowed to `MarketStatus`, with a new `failed` member.**
51
+ `Market.status`, `Position.marketStatus` and `ListMarketsParams.status` were `string` and are now
52
+ the union `"open" | "awaiting_settlement" | "settled" | "expired" | "failed"`. Passing a
53
+ dynamically-typed `string` to the `status` filter needs a cast or validation, and an exhaustive
54
+ `switch` over a status needs a `failed` arm. `failed` markets have no winning outcome, so they
55
+ exit through `liquidate()` — see [Market Lifecycle](#market-lifecycle).
56
+
57
+ **3. The default gateway is the automated one, and market-scoped calls are routed.**
58
+ `gatewayAddress` / `factoryAddress` now default to the automated-settlement contracts, with the
59
+ originals available as `legacyGatewayAddress` / `legacyFactoryAddress`. Every market-scoped call
60
+ resolves its owning gateway first, so addresses from either deployment work without configuration.
61
+ Setting `gatewayAddress` or `DELPHI_GATEWAY_CONTRACT` now **pins every call to that gateway and
62
+ disables routing** — previously it simply set the only gateway there was. Unset it unless you are
63
+ targeting a local deployment.
64
+
65
+ New in this release: `resolveGateway()`, `getMarketStatus()`,
66
+ `SubgraphClient.getMarketSettlement()`, the `MarketStatus` type, and
67
+ `LIQUIDATABLE_MARKET_STATUSES`.
68
+
11
69
  ## Quick Start
12
70
 
13
71
  ```typescript
@@ -56,11 +114,14 @@ An API key is required for all REST API endpoints (listing markets, querying pos
56
114
 
57
115
  | Variable | Description | Default |
58
116
  |---|---|---|
59
- | `DELPHI_NETWORK` | Network to use: `testnet` or `mainnet` | `testnet` |
117
+ | `DELPHI_NETWORK` | Network to use: `testnet`, `mainnet` or `competition-testnet` | `testnet` |
60
118
  | `DELPHI_SIGNER_TYPE` | Signing method: `cdp_server_wallet` or `private_key` | `cdp_server_wallet` |
61
119
  | `DELPHI_API_ACCESS_KEY` | REST API key (see [API Key](#api-key) above) | — |
62
120
  | `DELPHI_API_BASE_URL` | Override the REST API base URL | *(network default)* |
63
- | `DELPHI_GATEWAY_CONTRACT` | Override the Gateway contract address | *(network default)* |
121
+ | `DELPHI_GATEWAY_CONTRACT` | Override the Gateway address. Pins **every** call to this gateway and disables per-market routing | *(network default)* |
122
+ | `DELPHI_LEGACY_GATEWAY_CONTRACT` | Override the legacy Gateway address used for legacy markets | *(network default)* |
123
+ | `DELPHI_FACTORY_CONTRACT` | Override the automated-settlement Factory (used to route markets) | *(network default)* |
124
+ | `DELPHI_LEGACY_FACTORY_CONTRACT` | Override the legacy Factory (used to route markets) | *(network default)* |
64
125
  | `DELPHI_TOKEN_ADDRESS` | Override the ERC-20 token (USDC) address | *(network default)* |
65
126
  | `DELPHI_SUBGRAPH_URL` | Override the Goldsky subgraph endpoint | *(network default)* |
66
127
  | `DELPHI_APP_URL` | Override the Delphi app base URL (used to build `marketUrl`) | *(network default)* |
@@ -84,15 +145,107 @@ An API key is required for all REST API endpoints (listing markets, querying pos
84
145
 
85
146
  ### Network Defaults
86
147
 
87
- | | Testnet | Mainnet |
148
+ | | Testnet | Mainnet | Competition Testnet |
149
+ |---|---|---|---|
150
+ | Chain ID | `685685` | `685689` | `685685` |
151
+ | RPC URL | `https://gensyn-testnet.g.alchemy.com/public` | `https://gensyn-mainnet.g.alchemy.com/public` | `https://gensyn-testnet.g.alchemy.com/public` |
152
+ | Gateway (automated settlement) | `0x22ea355D7218Dc86b4c83732cBbd01f7Ff2332b3` | `0x982a67aE92D8de361957249fB2BB4a62BCc6A8d5` | `0x097599c9D966fF496284b892A8F13BF885b258ef` |
153
+ | Factory (automated settlement) | `0x97d2b3F0614C8189343A38094629FCE2910b727A` | `0x9C73417f79a1361c6aF9Bd828343badEE1b84936` | `0xEa9D0a78d0209916e88e363B8FDa3e23206Ff49b` |
154
+ | Gateway (legacy) | `0x7b8FDBD187B0Be5e30e48B1995df574A62667147` | `0x4e4e85c52E0F414cc67eE88d0C649Ec81698d700` | — *(no legacy deployment)* |
155
+ | Factory (legacy) | `0xd03CEC55802f0D44D844384E1144B25717315E5A` | `0x4596d847eA56DCf9A37944c13793Af802Fc5D1eC` | — *(no legacy deployment)* |
156
+ | Token | `0x0724D6079b986F8e44bDafB8a09B60C0bd6A45a1` (USDC) | `0x5b32c997211621d55a89Cc5abAF1cC21F3A6ddF5` (USDC) | `0x8A2d75753362Eb5D5669a2c22cbf394b26a0571F` (competition token) |
157
+ | API URL | `https://delphi-api.gensyn.ai/` | `https://api.delphi.fyi/` | `https://delphi-api.gensyn.ai/` |
158
+ | Subgraph URL | [Goldsky endpoint](https://api.goldsky.com/api/public/project_cmnoqdag1obop01z3efnu8ssq/subgraphs/delphi-testnet-autoset/1.0.0/gn) | [Goldsky endpoint](https://api.goldsky.com/api/public/project_cmnoqdag1obop01z3efnu8ssq/subgraphs/delphi-mainnet-autoset/1.0.0/gn) | [Goldsky endpoint](https://api.goldsky.com/api/public/project_cmnoqdag1obop01z3efnu8ssq/subgraphs/delphi-agent-competition/1.0.0/gn) |
159
+ | App URL | `https://testnet.delphi.fyi` | `https://app.delphi.fyi` | `https://agent-competition.gensyn.ai` |
160
+
161
+ #### Competition networks
162
+
163
+ `competition-testnet` targets the agent trading competition: the same chain as
164
+ testnet, the competition's own LMSR contracts (identical gateway call
165
+ signatures, so trading/quoting/redeeming work unchanged), and the same REST
166
+ API deployment. The client automatically sends `X-Delphi-Mode: competition`
167
+ on REST requests so `listMarkets`/`getMarket`/`listPositions` return
168
+ competition data. Market reads are scoped to the **active competition** by
169
+ default; pass `competitionId` to `listMarkets`/`getMarket` to read a specific
170
+ one.
171
+
172
+ The competition has a single, oracle-settled deployment — there is no legacy
173
+ competition gateway — so per-market gateway routing is inert here and every
174
+ call goes to the competition gateway. See
175
+ [Market Deployments and Gateway Routing](#market-deployments-and-gateway-routing).
176
+
177
+ The competition has its own Goldsky subgraph indexing the LMSR gateway from
178
+ its deployment block (`21525320`), so `getSubgraph()` and `getMarketTrades()`
179
+ work as they do on testnet/mainnet. It is automated-settlement shaped like the
180
+ `-autoset` subgraphs — `gatewayBuys`, `gatewaySells`, `gatewayRedemptions`,
181
+ `gatewayLiquidations` and `gatewayMarketSettleds`, with no
182
+ `gatewayWinnerSubmitteds` (see [Upgrading to 2.0.0](#upgrading-to-200)).
183
+
184
+ One difference: the LMSR gateway's `MarketSettled` has no market-creator
185
+ economics, so the competition's `gatewayMarketSettleds` lacks
186
+ `marketCreatorReward`, `refund` and `marketCreatorTradingFeesCut`.
187
+ `getMarketSettlement()` handles this — it omits those fields from the query on
188
+ competition networks and returns them as `null`, so the result shape is the
189
+ same on every network. If you hand-write a settlement query against the
190
+ competition subgraph, do not request them: `SubgraphClient` throws on GraphQL
191
+ errors, so an unknown field fails the whole query.
192
+
193
+ ### Market Deployments and Gateway Routing
194
+
195
+ Delphi runs two contract deployments side by side on each network:
196
+
197
+ - **Automated settlement** — every new market. Settled by the Truebit oracle relayer, which
198
+ can also report that it *could not* resolve the question, leaving the market `failed`.
199
+ - **Legacy** — markets created before automated settlement, settled manually by the market
200
+ creator. Its factory no longer produces markets, but existing positions there are still
201
+ redeemable and liquidatable.
202
+
203
+ Each gateway only accepts markets deployed by its own factory and reverts with
204
+ `MarketProxyNotDeployedByFactory` for anything else. The client handles this for you: every
205
+ market-scoped call resolves the owning gateway first (one batched `marketProxiesExist` probe
206
+ across both factories, cached per market for the client's lifetime). You can pass a market
207
+ address from either deployment and it just works.
208
+
209
+ Setting `gatewayAddress` (or `DELPHI_GATEWAY_CONTRACT`) pins all calls to that one gateway and
210
+ skips routing — useful for a local deployment, but calls will revert if you pass a market that
211
+ gateway does not own.
212
+
213
+ One caveat: the default `subgraphUrl` indexes the **automated-settlement gateway only**. REST and
214
+ on-chain methods cover both deployments, but subgraph queries for a legacy market return empty.
215
+ Point `subgraphUrl` (or `DELPHI_SUBGRAPH_URL`) at the older `delphi-testnet` / `delphi-mainnet`
216
+ subgraphs to query legacy activity.
217
+
218
+ To resolve a gateway yourself:
219
+
220
+ ```typescript
221
+ const gateway = await client.resolveGateway("0x...");
222
+ ```
223
+
224
+ ### Market Lifecycle
225
+
226
+ | Status | Meaning | How holders exit |
88
227
  |---|---|---|
89
- | Chain ID | `685685` | `685689` |
90
- | RPC URL | `https://gensyn-testnet.g.alchemy.com/public` | `https://gensyn-mainnet.g.alchemy.com/public` |
91
- | Gateway | `0x7b8FDBD187B0Be5e30e48B1995df574A62667147` | `0x4e4e85c52E0F414cc67eE88d0C649Ec81698d700` |
92
- | Token (USDC) | `0x0724D6079b986F8e44bDafB8a09B60C0bd6A45a1` | `0x5b32c997211621d55a89Cc5abAF1cC21F3A6ddF5` |
93
- | API URL | `https://delphi-api.gensyn.ai/` | `https://api.delphi.fyi/` |
94
- | Subgraph URL | [Goldsky endpoint](https://api.goldsky.com/api/public/project_cmnoqdag1obop01z3efnu8ssq/subgraphs/delphi-testnet/1.0.0/gn) | [Goldsky endpoint](https://api.goldsky.com/api/public/project_cmnoqdag1obop01z3efnu8ssq/subgraphs/delphi-mainnet/1.0.0/gn) |
95
- | App URL | `https://testnet.delphi.fyi` | `https://app.delphi.fyi` |
228
+ | `open` | Trading is open | `sellShares` |
229
+ | `awaiting_settlement` | Trading closed, no outcome yet | — |
230
+ | `settled` | A winning outcome was set | `redeemMarket` |
231
+ | `expired` | Settlement deadline passed with no outcome | `liquidate` |
232
+ | `failed` | Settlement ran but could not resolve | `liquidate` |
233
+
234
+ `failed` occurs only on automated-settlement markets. Like `expired` it has **no winning
235
+ outcome**, so `redeem()` reverts — funds are recovered with `liquidate()` instead. If you sweep
236
+ a portfolio with `redeemPositions`, check the status first and route `expired`/`failed` markets
237
+ to `liquidate`:
238
+
239
+ ```typescript
240
+ import { LIQUIDATABLE_MARKET_STATUSES } from "@gensyn-ai/gensyn-delphi-sdk";
241
+
242
+ const status = await client.getMarketStatus(marketAddress);
243
+ if (LIQUIDATABLE_MARKET_STATUSES.includes(status)) {
244
+ await client.liquidate({ marketAddress, outcomeIndices: [0, 1] });
245
+ } else if (status === "settled") {
246
+ await client.redeemMarket({ marketAddress });
247
+ }
248
+ ```
96
249
 
97
250
  ### Config Object
98
251
 
@@ -207,7 +360,7 @@ Each market object includes:
207
360
 
208
361
  ```typescript
209
362
  const { markets } = await client.listMarkets({
210
- status: "open", // "open" | "closed" | "settled"
363
+ status: "open", // "open" | "awaiting_settlement" | "settled" | "expired" | "failed"
211
364
  category: "crypto", // "crypto" | "culture" | "economics" | "miscellaneous" | "politics" | "sports"
212
365
  orderBy: "liquidity", // "liquidity" (default) | "created" | "settles_at"
213
366
  verifiable: true, // filter by verifiable settlement
@@ -315,7 +468,7 @@ for (const result of results) {
315
468
 
316
469
  #### `liquidate(params)`
317
470
 
318
- Liquidate positions on an expired market. Burns shares across the specified outcome indices and returns the collateral tokens.
471
+ Liquidate positions on an `expired` or `failed` market. Burns shares across the specified outcome indices and returns the collateral tokens. This is the exit path for markets with no winning outcome — see [Market Lifecycle](#market-lifecycle).
319
472
 
320
473
  ```typescript
321
474
  const { transactionHash, sharesIn, totalTokensOut } = await client.liquidate({
@@ -324,6 +477,23 @@ const { transactionHash, sharesIn, totalTokensOut } = await client.liquidate({
324
477
  });
325
478
  ```
326
479
 
480
+ #### `getMarketStatus(marketAddress)`
481
+
482
+ Read a market's lifecycle status directly from its gateway. Unlike `getMarket()`, this hits the chain rather than the indexed REST API, so it reflects state that has not been indexed yet.
483
+
484
+ ```typescript
485
+ const status = await client.getMarketStatus("0xMarket");
486
+ // "open" | "awaiting_settlement" | "settled" | "expired" | "failed"
487
+ ```
488
+
489
+ #### `resolveGateway(marketAddress)`
490
+
491
+ Return the gateway address that serves a market — the automated-settlement gateway or the legacy one. Called automatically by every market-scoped method; exposed for callers that need it directly. See [Market Deployments and Gateway Routing](#market-deployments-and-gateway-routing).
492
+
493
+ ```typescript
494
+ const gateway = await client.resolveGateway("0xMarket");
495
+ ```
496
+
327
497
  #### `getTokenAllowance(params)`
328
498
 
329
499
  Read the current ERC-20 allowance your wallet has granted to the gateway.
@@ -391,7 +561,7 @@ Query on-chain event data indexed by the Goldsky subgraph.
391
561
 
392
562
  #### `getSubgraph()`
393
563
 
394
- Access the `SubgraphClient` for querying historical trade data.
564
+ Access the `SubgraphClient` for querying historical trade and settlement data. The default endpoint indexes the automated-settlement gateway — see [Market Deployments and Gateway Routing](#market-deployments-and-gateway-routing).
395
565
 
396
566
  ```typescript
397
567
  const subgraph = client.getSubgraph();
@@ -401,6 +571,11 @@ const { buys, sells } = await subgraph.getMarketTrades("0xMarketProxy", {
401
571
  first: 20,
402
572
  });
403
573
 
574
+ // Fetch how a market settled. `settled` and `failed` are mutually exclusive:
575
+ // a failed market has no winning outcome, so holders exit via liquidate().
576
+ const { settled, failed, resolutionRequests } =
577
+ await subgraph.getMarketSettlement("0xMarketProxy");
578
+
404
579
  // Check subgraph indexing metadata
405
580
  const meta = await subgraph.getMeta();
406
581
 
@@ -0,0 +1,108 @@
1
+ /**
2
+ * Minimal DelphiFactory ABI — only the reads the SDK needs to resolve which
3
+ * deployment (legacy or automated-settlement) a market proxy belongs to.
4
+ *
5
+ * Each gateway serves only the markets deployed by its own factory and reverts
6
+ * with `MarketProxyNotDeployedByFactory` for anything else, so `marketProxyExists`
7
+ * is what lets the client route a call to the correct gateway.
8
+ */
9
+ declare const DELPHI_FACTORY_ABI: readonly [{
10
+ readonly inputs: readonly [];
11
+ readonly name: "IMPLEMENTATION";
12
+ readonly outputs: readonly [{
13
+ readonly internalType: "address";
14
+ readonly name: "";
15
+ readonly type: "address";
16
+ }];
17
+ readonly stateMutability: "view";
18
+ readonly type: "function";
19
+ }, {
20
+ readonly inputs: readonly [];
21
+ readonly name: "getTotalMarketProxiesCount";
22
+ readonly outputs: readonly [{
23
+ readonly internalType: "uint256";
24
+ readonly name: "";
25
+ readonly type: "uint256";
26
+ }];
27
+ readonly stateMutability: "view";
28
+ readonly type: "function";
29
+ }, {
30
+ readonly inputs: readonly [{
31
+ readonly internalType: "address";
32
+ readonly name: "marketProxy";
33
+ readonly type: "address";
34
+ }];
35
+ readonly name: "marketProxyExists";
36
+ readonly outputs: readonly [{
37
+ readonly internalType: "bool";
38
+ readonly name: "";
39
+ readonly type: "bool";
40
+ }];
41
+ readonly stateMutability: "view";
42
+ readonly type: "function";
43
+ }, {
44
+ readonly inputs: readonly [{
45
+ readonly internalType: "address[]";
46
+ readonly name: "marketProxies";
47
+ readonly type: "address[]";
48
+ }];
49
+ readonly name: "marketProxiesExist";
50
+ readonly outputs: readonly [{
51
+ readonly internalType: "bool[]";
52
+ readonly name: "";
53
+ readonly type: "bool[]";
54
+ }];
55
+ readonly stateMutability: "view";
56
+ readonly type: "function";
57
+ }];
58
+ export declare const ABI: readonly [{
59
+ readonly inputs: readonly [];
60
+ readonly name: "IMPLEMENTATION";
61
+ readonly outputs: readonly [{
62
+ readonly internalType: "address";
63
+ readonly name: "";
64
+ readonly type: "address";
65
+ }];
66
+ readonly stateMutability: "view";
67
+ readonly type: "function";
68
+ }, {
69
+ readonly inputs: readonly [];
70
+ readonly name: "getTotalMarketProxiesCount";
71
+ readonly outputs: readonly [{
72
+ readonly internalType: "uint256";
73
+ readonly name: "";
74
+ readonly type: "uint256";
75
+ }];
76
+ readonly stateMutability: "view";
77
+ readonly type: "function";
78
+ }, {
79
+ readonly inputs: readonly [{
80
+ readonly internalType: "address";
81
+ readonly name: "marketProxy";
82
+ readonly type: "address";
83
+ }];
84
+ readonly name: "marketProxyExists";
85
+ readonly outputs: readonly [{
86
+ readonly internalType: "bool";
87
+ readonly name: "";
88
+ readonly type: "bool";
89
+ }];
90
+ readonly stateMutability: "view";
91
+ readonly type: "function";
92
+ }, {
93
+ readonly inputs: readonly [{
94
+ readonly internalType: "address[]";
95
+ readonly name: "marketProxies";
96
+ readonly type: "address[]";
97
+ }];
98
+ readonly name: "marketProxiesExist";
99
+ readonly outputs: readonly [{
100
+ readonly internalType: "bool[]";
101
+ readonly name: "";
102
+ readonly type: "bool[]";
103
+ }];
104
+ readonly stateMutability: "view";
105
+ readonly type: "function";
106
+ }];
107
+ export default DELPHI_FACTORY_ABI;
108
+ //# sourceMappingURL=DelphiFactory.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"DelphiFactory.d.ts","sourceRoot":"","sources":["../../src/abi/DelphiFactory.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiEA,CAAC;AAEzB,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqB,CAAC;AACtC,eAAe,kBAAkB,CAAC"}
@@ -0,0 +1,77 @@
1
+ /**
2
+ * Minimal DelphiFactory ABI — only the reads the SDK needs to resolve which
3
+ * deployment (legacy or automated-settlement) a market proxy belongs to.
4
+ *
5
+ * Each gateway serves only the markets deployed by its own factory and reverts
6
+ * with `MarketProxyNotDeployedByFactory` for anything else, so `marketProxyExists`
7
+ * is what lets the client route a call to the correct gateway.
8
+ */
9
+ const DELPHI_FACTORY_ABI = [
10
+ {
11
+ "inputs": [],
12
+ "name": "IMPLEMENTATION",
13
+ "outputs": [
14
+ {
15
+ "internalType": "address",
16
+ "name": "",
17
+ "type": "address"
18
+ }
19
+ ],
20
+ "stateMutability": "view",
21
+ "type": "function"
22
+ },
23
+ {
24
+ "inputs": [],
25
+ "name": "getTotalMarketProxiesCount",
26
+ "outputs": [
27
+ {
28
+ "internalType": "uint256",
29
+ "name": "",
30
+ "type": "uint256"
31
+ }
32
+ ],
33
+ "stateMutability": "view",
34
+ "type": "function"
35
+ },
36
+ {
37
+ "inputs": [
38
+ {
39
+ "internalType": "address",
40
+ "name": "marketProxy",
41
+ "type": "address"
42
+ }
43
+ ],
44
+ "name": "marketProxyExists",
45
+ "outputs": [
46
+ {
47
+ "internalType": "bool",
48
+ "name": "",
49
+ "type": "bool"
50
+ }
51
+ ],
52
+ "stateMutability": "view",
53
+ "type": "function"
54
+ },
55
+ {
56
+ "inputs": [
57
+ {
58
+ "internalType": "address[]",
59
+ "name": "marketProxies",
60
+ "type": "address[]"
61
+ }
62
+ ],
63
+ "name": "marketProxiesExist",
64
+ "outputs": [
65
+ {
66
+ "internalType": "bool[]",
67
+ "name": "",
68
+ "type": "bool[]"
69
+ }
70
+ ],
71
+ "stateMutability": "view",
72
+ "type": "function"
73
+ }
74
+ ];
75
+ export const ABI = DELPHI_FACTORY_ABI;
76
+ export default DELPHI_FACTORY_ABI;
77
+ //# sourceMappingURL=DelphiFactory.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"DelphiFactory.js","sourceRoot":"","sources":["../../src/abi/DelphiFactory.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,MAAM,kBAAkB,GAAG;IACzB;QACE,QAAQ,EAAE,EAAE;QACZ,MAAM,EAAE,gBAAgB;QACxB,SAAS,EAAE;YACT;gBACE,cAAc,EAAE,SAAS;gBACzB,MAAM,EAAE,EAAE;gBACV,MAAM,EAAE,SAAS;aAClB;SACF;QACD,iBAAiB,EAAE,MAAM;QACzB,MAAM,EAAE,UAAU;KACnB;IACD;QACE,QAAQ,EAAE,EAAE;QACZ,MAAM,EAAE,4BAA4B;QACpC,SAAS,EAAE;YACT;gBACE,cAAc,EAAE,SAAS;gBACzB,MAAM,EAAE,EAAE;gBACV,MAAM,EAAE,SAAS;aAClB;SACF;QACD,iBAAiB,EAAE,MAAM;QACzB,MAAM,EAAE,UAAU;KACnB;IACD;QACE,QAAQ,EAAE;YACR;gBACE,cAAc,EAAE,SAAS;gBACzB,MAAM,EAAE,aAAa;gBACrB,MAAM,EAAE,SAAS;aAClB;SACF;QACD,MAAM,EAAE,mBAAmB;QAC3B,SAAS,EAAE;YACT;gBACE,cAAc,EAAE,MAAM;gBACtB,MAAM,EAAE,EAAE;gBACV,MAAM,EAAE,MAAM;aACf;SACF;QACD,iBAAiB,EAAE,MAAM;QACzB,MAAM,EAAE,UAAU;KACnB;IACD;QACE,QAAQ,EAAE;YACR;gBACE,cAAc,EAAE,WAAW;gBAC3B,MAAM,EAAE,eAAe;gBACvB,MAAM,EAAE,WAAW;aACpB;SACF;QACD,MAAM,EAAE,oBAAoB;QAC5B,SAAS,EAAE;YACT;gBACE,cAAc,EAAE,QAAQ;gBACxB,MAAM,EAAE,EAAE;gBACV,MAAM,EAAE,QAAQ;aACjB;SACF;QACD,iBAAiB,EAAE,MAAM;QACzB,MAAM,EAAE,UAAU;KACnB;CACqB,CAAC;AAEzB,MAAM,CAAC,MAAM,GAAG,GAAG,kBAAkB,CAAC;AACtC,eAAe,kBAAkB,CAAC"}