@agent-shield/sdk 0.5.2 → 0.5.4

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.
Files changed (40) hide show
  1. package/README.md +15 -13
  2. package/dist/accounts.d.ts +3 -1
  3. package/dist/accounts.d.ts.map +1 -1
  4. package/dist/accounts.js +9 -0
  5. package/dist/accounts.js.map +1 -1
  6. package/dist/client.d.ts +5 -1
  7. package/dist/client.d.ts.map +1 -1
  8. package/dist/client.js +15 -0
  9. package/dist/client.js.map +1 -1
  10. package/dist/idl-json.d.ts +1054 -2004
  11. package/dist/idl-json.d.ts.map +1 -1
  12. package/dist/idl-json.js +407 -455
  13. package/dist/idl-json.js.map +1 -1
  14. package/dist/idl.d.ts +458 -451
  15. package/dist/idl.d.ts.map +1 -1
  16. package/dist/index.d.ts +5 -5
  17. package/dist/index.d.ts.map +1 -1
  18. package/dist/index.js +13 -8
  19. package/dist/index.js.map +1 -1
  20. package/dist/instructions.d.ts +213 -147
  21. package/dist/instructions.d.ts.map +1 -1
  22. package/dist/instructions.js +65 -17
  23. package/dist/instructions.js.map +1 -1
  24. package/dist/types.d.ts +48 -66
  25. package/dist/types.d.ts.map +1 -1
  26. package/dist/types.js +8 -13
  27. package/dist/types.js.map +1 -1
  28. package/dist/wrap.d.ts +2 -10
  29. package/dist/wrap.d.ts.map +1 -1
  30. package/dist/wrap.js +1 -32
  31. package/dist/wrap.js.map +1 -1
  32. package/dist/wrapper/harden.d.ts +5 -7
  33. package/dist/wrapper/harden.d.ts.map +1 -1
  34. package/dist/wrapper/harden.js +11 -35
  35. package/dist/wrapper/harden.js.map +1 -1
  36. package/dist/wrapper/index.d.ts +2 -1
  37. package/dist/wrapper/index.d.ts.map +1 -1
  38. package/dist/wrapper/index.js +4 -2
  39. package/dist/wrapper/index.js.map +1 -1
  40. package/package.json +4 -4
package/dist/idl-json.d.ts CHANGED
@@ -1,2043 +1,1093 @@
1
1
  export declare const IDL: {
2
- readonly address: "4ZeVCqnjUgUtFrHHPG7jELUxvJeoVGHhGNgPrhBPwrHL";
3
- readonly metadata: {
4
- readonly name: "agent_shield";
5
- readonly version: "0.1.0";
6
- readonly spec: "0.1.0";
7
- readonly description: "On-chain guardrails for AI agents on Solana - Permission controls, spending limits, and audit infrastructure for autonomous agents";
2
+ address: string;
3
+ metadata: {
4
+ name: string;
5
+ version: string;
6
+ spec: string;
7
+ description: string;
8
8
  };
9
- readonly instructions: readonly [{
10
- readonly name: "agent_transfer";
11
- readonly docs: readonly ["Transfer tokens from the vault to an allowed destination.", "Only the agent can call this. Respects destination allowlist,", "spending caps, and per-token limits."];
12
- readonly discriminator: readonly [199, 111, 151, 49, 124, 13, 150, 44];
13
- readonly accounts: readonly [{
14
- readonly name: "agent";
15
- readonly writable: true;
16
- readonly signer: true;
17
- }, {
18
- readonly name: "vault";
19
- readonly writable: true;
20
- readonly pda: {
21
- readonly seeds: readonly [{
22
- readonly kind: "const";
23
- readonly value: readonly [118, 97, 117, 108, 116];
24
- }, {
25
- readonly kind: "account";
26
- readonly path: "vault.owner";
27
- readonly account: "AgentVault";
28
- }, {
29
- readonly kind: "account";
30
- readonly path: "vault.vault_id";
31
- readonly account: "AgentVault";
32
- }];
33
- };
34
- readonly relations: readonly ["policy", "tracker"];
35
- }, {
36
- readonly name: "policy";
37
- readonly pda: {
38
- readonly seeds: readonly [{
39
- readonly kind: "const";
40
- readonly value: readonly [112, 111, 108, 105, 99, 121];
41
- }, {
42
- readonly kind: "account";
43
- readonly path: "vault";
44
- }];
45
- };
46
- }, {
47
- readonly name: "tracker";
48
- readonly writable: true;
49
- readonly pda: {
50
- readonly seeds: readonly [{
51
- readonly kind: "const";
52
- readonly value: readonly [116, 114, 97, 99, 107, 101, 114];
53
- }, {
54
- readonly kind: "account";
55
- readonly path: "vault";
56
- }];
57
- };
58
- }, {
59
- readonly name: "vault_token_account";
60
- readonly docs: readonly ["Vault's PDA-owned token account (source)"];
61
- readonly writable: true;
62
- }, {
63
- readonly name: "destination_token_account";
64
- readonly docs: readonly ["Destination token account (must be in allowed destinations if configured)"];
65
- readonly writable: true;
66
- }, {
67
- readonly name: "fee_destination_token_account";
68
- readonly docs: readonly ["Developer fee destination token account — must match vault.fee_destination"];
69
- readonly writable: true;
70
- readonly optional: true;
71
- }, {
72
- readonly name: "protocol_treasury_token_account";
73
- readonly docs: readonly ["Protocol treasury token account"];
74
- readonly writable: true;
75
- readonly optional: true;
76
- }, {
77
- readonly name: "token_program";
78
- readonly address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
79
- }];
80
- readonly args: readonly [{
81
- readonly name: "amount";
82
- readonly type: "u64";
83
- }];
84
- }, {
85
- readonly name: "apply_pending_policy";
86
- readonly docs: readonly ["Apply a queued policy update after the timelock period has expired.", "Closes the PendingPolicyUpdate PDA and returns rent to the owner."];
87
- readonly discriminator: readonly [114, 212, 19, 227, 89, 199, 74, 62];
88
- readonly accounts: readonly [{
89
- readonly name: "owner";
90
- readonly writable: true;
91
- readonly signer: true;
92
- readonly relations: readonly ["vault"];
93
- }, {
94
- readonly name: "vault";
95
- readonly pda: {
96
- readonly seeds: readonly [{
97
- readonly kind: "const";
98
- readonly value: readonly [118, 97, 117, 108, 116];
99
- }, {
100
- readonly kind: "account";
101
- readonly path: "owner";
102
- }, {
103
- readonly kind: "account";
104
- readonly path: "vault.vault_id";
105
- readonly account: "AgentVault";
106
- }];
107
- };
108
- readonly relations: readonly ["policy", "tracker", "pending_policy"];
109
- }, {
110
- readonly name: "policy";
111
- readonly writable: true;
112
- readonly pda: {
113
- readonly seeds: readonly [{
114
- readonly kind: "const";
115
- readonly value: readonly [112, 111, 108, 105, 99, 121];
116
- }, {
117
- readonly kind: "account";
118
- readonly path: "vault";
119
- }];
120
- };
121
- }, {
122
- readonly name: "tracker";
123
- readonly writable: true;
124
- readonly pda: {
125
- readonly seeds: readonly [{
126
- readonly kind: "const";
127
- readonly value: readonly [116, 114, 97, 99, 107, 101, 114];
128
- }, {
129
- readonly kind: "account";
130
- readonly path: "vault";
131
- }];
132
- };
133
- }, {
134
- readonly name: "pending_policy";
135
- readonly writable: true;
136
- readonly pda: {
137
- readonly seeds: readonly [{
138
- readonly kind: "const";
139
- readonly value: readonly [112, 101, 110, 100, 105, 110, 103, 95, 112, 111, 108, 105, 99, 121];
140
- }, {
141
- readonly kind: "account";
142
- readonly path: "vault";
143
- }];
144
- };
145
- }];
146
- readonly args: readonly [];
147
- }, {
148
- readonly name: "cancel_pending_policy";
149
- readonly docs: readonly ["Cancel a queued policy update. Closes the PendingPolicyUpdate PDA", "and returns rent to the owner."];
150
- readonly discriminator: readonly [153, 36, 104, 200, 50, 94, 207, 33];
151
- readonly accounts: readonly [{
152
- readonly name: "owner";
153
- readonly writable: true;
154
- readonly signer: true;
155
- readonly relations: readonly ["vault"];
156
- }, {
157
- readonly name: "vault";
158
- readonly pda: {
159
- readonly seeds: readonly [{
160
- readonly kind: "const";
161
- readonly value: readonly [118, 97, 117, 108, 116];
162
- }, {
163
- readonly kind: "account";
164
- readonly path: "owner";
165
- }, {
166
- readonly kind: "account";
167
- readonly path: "vault.vault_id";
168
- readonly account: "AgentVault";
169
- }];
170
- };
171
- readonly relations: readonly ["pending_policy"];
172
- }, {
173
- readonly name: "pending_policy";
174
- readonly writable: true;
175
- readonly pda: {
176
- readonly seeds: readonly [{
177
- readonly kind: "const";
178
- readonly value: readonly [112, 101, 110, 100, 105, 110, 103, 95, 112, 111, 108, 105, 99, 121];
179
- }, {
180
- readonly kind: "account";
181
- readonly path: "vault";
182
- }];
183
- };
184
- }];
185
- readonly args: readonly [];
186
- }, {
187
- readonly name: "close_vault";
188
- readonly docs: readonly ["Close the vault entirely. Withdraws all remaining funds and closes all PDAs.", "Reclaims rent. Vault must have no open positions. Only the owner can call this."];
189
- readonly discriminator: readonly [141, 103, 17, 126, 72, 75, 29, 29];
190
- readonly accounts: readonly [{
191
- readonly name: "owner";
192
- readonly writable: true;
193
- readonly signer: true;
194
- readonly relations: readonly ["vault"];
195
- }, {
196
- readonly name: "vault";
197
- readonly writable: true;
198
- readonly pda: {
199
- readonly seeds: readonly [{
200
- readonly kind: "const";
201
- readonly value: readonly [118, 97, 117, 108, 116];
202
- }, {
203
- readonly kind: "account";
204
- readonly path: "owner";
205
- }, {
206
- readonly kind: "account";
207
- readonly path: "vault.vault_id";
208
- readonly account: "AgentVault";
209
- }];
210
- };
211
- readonly relations: readonly ["policy", "tracker"];
212
- }, {
213
- readonly name: "policy";
214
- readonly writable: true;
215
- readonly pda: {
216
- readonly seeds: readonly [{
217
- readonly kind: "const";
218
- readonly value: readonly [112, 111, 108, 105, 99, 121];
219
- }, {
220
- readonly kind: "account";
221
- readonly path: "vault";
222
- }];
223
- };
224
- }, {
225
- readonly name: "tracker";
226
- readonly writable: true;
227
- readonly pda: {
228
- readonly seeds: readonly [{
229
- readonly kind: "const";
230
- readonly value: readonly [116, 114, 97, 99, 107, 101, 114];
231
- }, {
232
- readonly kind: "account";
233
- readonly path: "vault";
234
- }];
235
- };
236
- }, {
237
- readonly name: "system_program";
238
- readonly address: "11111111111111111111111111111111";
239
- }];
240
- readonly args: readonly [];
241
- }, {
242
- readonly name: "deposit_funds";
243
- readonly docs: readonly ["Deposit SPL tokens into the vault's PDA-controlled token account.", "Only the owner can call this."];
244
- readonly discriminator: readonly [202, 39, 52, 211, 53, 20, 250, 88];
245
- readonly accounts: readonly [{
246
- readonly name: "owner";
247
- readonly writable: true;
248
- readonly signer: true;
249
- readonly relations: readonly ["vault"];
250
- }, {
251
- readonly name: "vault";
252
- readonly pda: {
253
- readonly seeds: readonly [{
254
- readonly kind: "const";
255
- readonly value: readonly [118, 97, 117, 108, 116];
256
- }, {
257
- readonly kind: "account";
258
- readonly path: "owner";
259
- }, {
260
- readonly kind: "account";
261
- readonly path: "vault.vault_id";
262
- readonly account: "AgentVault";
263
- }];
264
- };
265
- }, {
266
- readonly name: "mint";
267
- }, {
268
- readonly name: "owner_token_account";
269
- readonly docs: readonly ["Owner's token account to transfer from"];
270
- readonly writable: true;
271
- readonly pda: {
272
- readonly seeds: readonly [{
273
- readonly kind: "account";
274
- readonly path: "owner";
275
- }, {
276
- readonly kind: "const";
277
- readonly value: readonly [6, 221, 246, 225, 215, 101, 161, 147, 217, 203, 225, 70, 206, 235, 121, 172, 28, 180, 133, 237, 95, 91, 55, 145, 58, 140, 245, 133, 126, 255, 0, 169];
278
- }, {
279
- readonly kind: "account";
280
- readonly path: "mint";
281
- }];
282
- readonly program: {
283
- readonly kind: "const";
284
- readonly value: readonly [140, 151, 37, 143, 78, 36, 137, 241, 187, 61, 16, 41, 20, 142, 13, 131, 11, 90, 19, 153, 218, 255, 16, 132, 4, 142, 123, 216, 219, 233, 248, 89];
285
- };
286
- };
287
- }, {
288
- readonly name: "vault_token_account";
289
- readonly docs: readonly ["Vault's PDA-controlled token account"];
290
- readonly writable: true;
291
- readonly pda: {
292
- readonly seeds: readonly [{
293
- readonly kind: "account";
294
- readonly path: "vault";
295
- }, {
296
- readonly kind: "const";
297
- readonly value: readonly [6, 221, 246, 225, 215, 101, 161, 147, 217, 203, 225, 70, 206, 235, 121, 172, 28, 180, 133, 237, 95, 91, 55, 145, 58, 140, 245, 133, 126, 255, 0, 169];
298
- }, {
299
- readonly kind: "account";
300
- readonly path: "mint";
301
- }];
302
- readonly program: {
303
- readonly kind: "const";
304
- readonly value: readonly [140, 151, 37, 143, 78, 36, 137, 241, 187, 61, 16, 41, 20, 142, 13, 131, 11, 90, 19, 153, 218, 255, 16, 132, 4, 142, 123, 216, 219, 233, 248, 89];
9
+ instructions: ({
10
+ name: string;
11
+ docs: string[];
12
+ discriminator: number[];
13
+ accounts: ({
14
+ name: string;
15
+ writable: boolean;
16
+ signer: boolean;
17
+ pda?: undefined;
18
+ relations?: undefined;
19
+ docs?: undefined;
20
+ optional?: undefined;
21
+ address?: undefined;
22
+ } | {
23
+ name: string;
24
+ writable: boolean;
25
+ pda: {
26
+ seeds: ({
27
+ kind: string;
28
+ value: number[];
29
+ path?: undefined;
30
+ account?: undefined;
31
+ } | {
32
+ kind: string;
33
+ path: string;
34
+ account: string;
35
+ value?: undefined;
36
+ })[];
37
+ };
38
+ relations: string[];
39
+ signer?: undefined;
40
+ docs?: undefined;
41
+ optional?: undefined;
42
+ address?: undefined;
43
+ } | {
44
+ name: string;
45
+ pda: {
46
+ seeds: ({
47
+ kind: string;
48
+ value: number[];
49
+ path?: undefined;
50
+ } | {
51
+ kind: string;
52
+ path: string;
53
+ value?: undefined;
54
+ })[];
55
+ };
56
+ writable?: undefined;
57
+ signer?: undefined;
58
+ relations?: undefined;
59
+ docs?: undefined;
60
+ optional?: undefined;
61
+ address?: undefined;
62
+ } | {
63
+ name: string;
64
+ docs: string[];
65
+ writable: boolean;
66
+ pda: {
67
+ seeds: ({
68
+ kind: string;
69
+ value: number[];
70
+ path?: undefined;
71
+ } | {
72
+ kind: string;
73
+ path: string;
74
+ value?: undefined;
75
+ })[];
76
+ };
77
+ signer?: undefined;
78
+ relations?: undefined;
79
+ optional?: undefined;
80
+ address?: undefined;
81
+ } | {
82
+ name: string;
83
+ docs: string[];
84
+ pda: {
85
+ seeds: {
86
+ kind: string;
87
+ value: number[];
88
+ }[];
89
+ };
90
+ writable?: undefined;
91
+ signer?: undefined;
92
+ relations?: undefined;
93
+ optional?: undefined;
94
+ address?: undefined;
95
+ } | {
96
+ name: string;
97
+ docs: string[];
98
+ writable: boolean;
99
+ signer?: undefined;
100
+ pda?: undefined;
101
+ relations?: undefined;
102
+ optional?: undefined;
103
+ address?: undefined;
104
+ } | {
105
+ name: string;
106
+ docs: string[];
107
+ writable?: undefined;
108
+ signer?: undefined;
109
+ pda?: undefined;
110
+ relations?: undefined;
111
+ optional?: undefined;
112
+ address?: undefined;
113
+ } | {
114
+ name: string;
115
+ docs: string[];
116
+ writable: boolean;
117
+ optional: boolean;
118
+ signer?: undefined;
119
+ pda?: undefined;
120
+ relations?: undefined;
121
+ address?: undefined;
122
+ } | {
123
+ name: string;
124
+ address: string;
125
+ writable?: undefined;
126
+ signer?: undefined;
127
+ pda?: undefined;
128
+ relations?: undefined;
129
+ docs?: undefined;
130
+ optional?: undefined;
131
+ })[];
132
+ args: {
133
+ name: string;
134
+ type: string;
135
+ }[];
136
+ } | {
137
+ name: string;
138
+ docs: string[];
139
+ discriminator: number[];
140
+ accounts: ({
141
+ name: string;
142
+ writable: boolean;
143
+ signer: boolean;
144
+ relations: string[];
145
+ pda?: undefined;
146
+ docs?: undefined;
147
+ address?: undefined;
148
+ } | {
149
+ name: string;
150
+ writable: boolean;
151
+ pda: {
152
+ seeds: ({
153
+ kind: string;
154
+ value: number[];
155
+ path?: undefined;
156
+ account?: undefined;
157
+ } | {
158
+ kind: string;
159
+ path: string;
160
+ value?: undefined;
161
+ account?: undefined;
162
+ } | {
163
+ kind: string;
164
+ path: string;
165
+ account: string;
166
+ value?: undefined;
167
+ })[];
168
+ };
169
+ relations: string[];
170
+ signer?: undefined;
171
+ docs?: undefined;
172
+ address?: undefined;
173
+ } | {
174
+ name: string;
175
+ writable: boolean;
176
+ pda: {
177
+ seeds: ({
178
+ kind: string;
179
+ value: number[];
180
+ path?: undefined;
181
+ } | {
182
+ kind: string;
183
+ path: string;
184
+ value?: undefined;
185
+ })[];
186
+ };
187
+ signer?: undefined;
188
+ relations?: undefined;
189
+ docs?: undefined;
190
+ address?: undefined;
191
+ } | {
192
+ name: string;
193
+ docs: string[];
194
+ writable: boolean;
195
+ pda: {
196
+ seeds: ({
197
+ kind: string;
198
+ value: number[];
199
+ path?: undefined;
200
+ } | {
201
+ kind: string;
202
+ path: string;
203
+ value?: undefined;
204
+ })[];
205
+ };
206
+ signer?: undefined;
207
+ relations?: undefined;
208
+ address?: undefined;
209
+ } | {
210
+ name: string;
211
+ address: string;
212
+ writable?: undefined;
213
+ signer?: undefined;
214
+ relations?: undefined;
215
+ pda?: undefined;
216
+ docs?: undefined;
217
+ })[];
218
+ args: never[];
219
+ } | {
220
+ name: string;
221
+ docs: string[];
222
+ discriminator: number[];
223
+ accounts: ({
224
+ name: string;
225
+ writable: boolean;
226
+ signer: boolean;
227
+ relations: string[];
228
+ pda?: undefined;
229
+ docs?: undefined;
230
+ address?: undefined;
231
+ } | {
232
+ name: string;
233
+ pda: {
234
+ seeds: ({
235
+ kind: string;
236
+ value: number[];
237
+ path?: undefined;
238
+ account?: undefined;
239
+ } | {
240
+ kind: string;
241
+ path: string;
242
+ value?: undefined;
243
+ account?: undefined;
244
+ } | {
245
+ kind: string;
246
+ path: string;
247
+ account: string;
248
+ value?: undefined;
249
+ })[];
250
+ program?: undefined;
251
+ };
252
+ writable?: undefined;
253
+ signer?: undefined;
254
+ relations?: undefined;
255
+ docs?: undefined;
256
+ address?: undefined;
257
+ } | {
258
+ name: string;
259
+ writable?: undefined;
260
+ signer?: undefined;
261
+ relations?: undefined;
262
+ pda?: undefined;
263
+ docs?: undefined;
264
+ address?: undefined;
265
+ } | {
266
+ name: string;
267
+ docs: string[];
268
+ writable: boolean;
269
+ pda: {
270
+ seeds: ({
271
+ kind: string;
272
+ path: string;
273
+ value?: undefined;
274
+ } | {
275
+ kind: string;
276
+ value: number[];
277
+ path?: undefined;
278
+ })[];
279
+ program: {
280
+ kind: string;
281
+ value: number[];
305
282
  };
306
283
  };
307
- }, {
308
- readonly name: "token_program";
309
- readonly address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
310
- }, {
311
- readonly name: "associated_token_program";
312
- readonly address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
313
- }, {
314
- readonly name: "system_program";
315
- readonly address: "11111111111111111111111111111111";
316
- }];
317
- readonly args: readonly [{
318
- readonly name: "amount";
319
- readonly type: "u64";
320
- }];
321
- }, {
322
- readonly name: "finalize_session";
323
- readonly docs: readonly ["Finalize a session after the DeFi action completes.", "Revokes token delegation, collects fees, closes the SessionAuthority PDA,", "and records the transaction in the audit log.", "Can be called by the agent or permissionlessly (for cleanup of expired sessions)."];
324
- readonly discriminator: readonly [34, 148, 144, 47, 37, 130, 206, 161];
325
- readonly accounts: readonly [{
326
- readonly name: "payer";
327
- readonly writable: true;
328
- readonly signer: true;
329
- }, {
330
- readonly name: "vault";
331
- readonly writable: true;
332
- readonly pda: {
333
- readonly seeds: readonly [{
334
- readonly kind: "const";
335
- readonly value: readonly [118, 97, 117, 108, 116];
336
- }, {
337
- readonly kind: "account";
338
- readonly path: "vault.owner";
339
- readonly account: "AgentVault";
340
- }, {
341
- readonly kind: "account";
342
- readonly path: "vault.vault_id";
343
- readonly account: "AgentVault";
344
- }];
345
- };
346
- readonly relations: readonly ["policy", "tracker", "session"];
347
- }, {
348
- readonly name: "policy";
349
- readonly pda: {
350
- readonly seeds: readonly [{
351
- readonly kind: "const";
352
- readonly value: readonly [112, 111, 108, 105, 99, 121];
353
- }, {
354
- readonly kind: "account";
355
- readonly path: "vault";
356
- }];
357
- };
358
- }, {
359
- readonly name: "tracker";
360
- readonly writable: true;
361
- readonly pda: {
362
- readonly seeds: readonly [{
363
- readonly kind: "const";
364
- readonly value: readonly [116, 114, 97, 99, 107, 101, 114];
365
- }, {
366
- readonly kind: "account";
367
- readonly path: "vault";
368
- }];
369
- };
370
- }, {
371
- readonly name: "session";
372
- readonly docs: readonly ["Session rent is returned to the session's agent (who paid for it),", "not the arbitrary payer, to prevent rent theft.", "Seeds include token_mint for per-token concurrent sessions."];
373
- readonly writable: true;
374
- readonly pda: {
375
- readonly seeds: readonly [{
376
- readonly kind: "const";
377
- readonly value: readonly [115, 101, 115, 115, 105, 111, 110];
378
- }, {
379
- readonly kind: "account";
380
- readonly path: "vault";
381
- }, {
382
- readonly kind: "account";
383
- readonly path: "session.agent";
384
- readonly account: "SessionAuthority";
385
- }, {
386
- readonly kind: "account";
387
- readonly path: "session.authorized_token";
388
- readonly account: "SessionAuthority";
389
- }];
390
- };
391
- }, {
392
- readonly name: "session_rent_recipient";
393
- readonly docs: readonly ["Validated in handler to equal session.agent."];
394
- readonly writable: true;
395
- }, {
396
- readonly name: "vault_token_account";
397
- readonly docs: readonly ["Vault's PDA token account for the session's token (fee source + delegation revocation)"];
398
- readonly writable: true;
399
- readonly optional: true;
400
- }, {
401
- readonly name: "fee_destination_token_account";
402
- readonly docs: readonly ["Developer fee destination token account — must match vault.fee_destination"];
403
- readonly writable: true;
404
- readonly optional: true;
405
- }, {
406
- readonly name: "protocol_treasury_token_account";
407
- readonly docs: readonly ["Protocol treasury token account — must be owned by PROTOCOL_TREASURY"];
408
- readonly writable: true;
409
- readonly optional: true;
410
- }, {
411
- readonly name: "token_program";
412
- readonly address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
413
- }, {
414
- readonly name: "system_program";
415
- readonly address: "11111111111111111111111111111111";
416
- }];
417
- readonly args: readonly [{
418
- readonly name: "success";
419
- readonly type: "bool";
420
- }];
421
- }, {
422
- readonly name: "initialize_vault";
423
- readonly docs: readonly ["Initialize a new agent vault with policy configuration.", "Only the owner can call this. Creates vault PDA, policy PDA, and spend tracker PDA.", "`tracker_tier`: 0 = Standard (200 entries), 1 = Pro (500), 2 = Max (1000)."];
424
- readonly discriminator: readonly [48, 191, 163, 44, 71, 129, 63, 164];
425
- readonly accounts: readonly [{
426
- readonly name: "owner";
427
- readonly writable: true;
428
- readonly signer: true;
429
- }, {
430
- readonly name: "vault";
431
- readonly writable: true;
432
- readonly pda: {
433
- readonly seeds: readonly [{
434
- readonly kind: "const";
435
- readonly value: readonly [118, 97, 117, 108, 116];
436
- }, {
437
- readonly kind: "account";
438
- readonly path: "owner";
439
- }, {
440
- readonly kind: "arg";
441
- readonly path: "vault_id";
442
- }];
443
- };
444
- }, {
445
- readonly name: "policy";
446
- readonly writable: true;
447
- readonly pda: {
448
- readonly seeds: readonly [{
449
- readonly kind: "const";
450
- readonly value: readonly [112, 111, 108, 105, 99, 121];
451
- }, {
452
- readonly kind: "account";
453
- readonly path: "vault";
454
- }];
455
- };
456
- }, {
457
- readonly name: "tracker";
458
- readonly writable: true;
459
- readonly pda: {
460
- readonly seeds: readonly [{
461
- readonly kind: "const";
462
- readonly value: readonly [116, 114, 97, 99, 107, 101, 114];
463
- }, {
464
- readonly kind: "account";
465
- readonly path: "vault";
466
- }];
467
- };
468
- }, {
469
- readonly name: "fee_destination";
470
- readonly docs: readonly ["The protocol treasury that receives fees"];
471
- }, {
472
- readonly name: "system_program";
473
- readonly address: "11111111111111111111111111111111";
474
- }];
475
- readonly args: readonly [{
476
- readonly name: "vault_id";
477
- readonly type: "u64";
478
- }, {
479
- readonly name: "daily_spending_cap_usd";
480
- readonly type: "u64";
481
- }, {
482
- readonly name: "max_transaction_size_usd";
483
- readonly type: "u64";
484
- }, {
485
- readonly name: "allowed_tokens";
486
- readonly type: {
487
- readonly vec: {
488
- readonly defined: {
489
- readonly name: "AllowedToken";
490
- };
491
- };
492
- };
493
- }, {
494
- readonly name: "allowed_protocols";
495
- readonly type: {
496
- readonly vec: "pubkey";
497
- };
498
- }, {
499
- readonly name: "max_leverage_bps";
500
- readonly type: "u16";
501
- }, {
502
- readonly name: "max_concurrent_positions";
503
- readonly type: "u8";
504
- }, {
505
- readonly name: "developer_fee_rate";
506
- readonly type: "u16";
507
- }, {
508
- readonly name: "timelock_duration";
509
- readonly type: "u64";
510
- }, {
511
- readonly name: "allowed_destinations";
512
- readonly type: {
513
- readonly vec: "pubkey";
514
- };
515
- }, {
516
- readonly name: "tracker_tier";
517
- readonly type: "u8";
518
- }];
519
- }, {
520
- readonly name: "queue_policy_update";
521
- readonly docs: readonly ["Queue a policy update when timelock is active.", "Creates a PendingPolicyUpdate PDA that becomes executable after", "the timelock period expires."];
522
- readonly discriminator: readonly [149, 18, 76, 197, 179, 193, 91, 77];
523
- readonly accounts: readonly [{
524
- readonly name: "owner";
525
- readonly writable: true;
526
- readonly signer: true;
527
- readonly relations: readonly ["vault"];
528
- }, {
529
- readonly name: "vault";
530
- readonly pda: {
531
- readonly seeds: readonly [{
532
- readonly kind: "const";
533
- readonly value: readonly [118, 97, 117, 108, 116];
534
- }, {
535
- readonly kind: "account";
536
- readonly path: "owner";
537
- }, {
538
- readonly kind: "account";
539
- readonly path: "vault.vault_id";
540
- readonly account: "AgentVault";
541
- }];
542
- };
543
- readonly relations: readonly ["policy"];
544
- }, {
545
- readonly name: "policy";
546
- readonly pda: {
547
- readonly seeds: readonly [{
548
- readonly kind: "const";
549
- readonly value: readonly [112, 111, 108, 105, 99, 121];
550
- }, {
551
- readonly kind: "account";
552
- readonly path: "vault";
553
- }];
554
- };
555
- }, {
556
- readonly name: "pending_policy";
557
- readonly writable: true;
558
- readonly pda: {
559
- readonly seeds: readonly [{
560
- readonly kind: "const";
561
- readonly value: readonly [112, 101, 110, 100, 105, 110, 103, 95, 112, 111, 108, 105, 99, 121];
562
- }, {
563
- readonly kind: "account";
564
- readonly path: "vault";
565
- }];
566
- };
567
- }, {
568
- readonly name: "system_program";
569
- readonly address: "11111111111111111111111111111111";
570
- }];
571
- readonly args: readonly [{
572
- readonly name: "daily_spending_cap_usd";
573
- readonly type: {
574
- readonly option: "u64";
575
- };
576
- }, {
577
- readonly name: "max_transaction_amount_usd";
578
- readonly type: {
579
- readonly option: "u64";
580
- };
581
- }, {
582
- readonly name: "allowed_tokens";
583
- readonly type: {
584
- readonly option: {
585
- readonly vec: {
586
- readonly defined: {
587
- readonly name: "AllowedToken";
588
- };
284
+ signer?: undefined;
285
+ relations?: undefined;
286
+ address?: undefined;
287
+ } | {
288
+ name: string;
289
+ address: string;
290
+ writable?: undefined;
291
+ signer?: undefined;
292
+ relations?: undefined;
293
+ pda?: undefined;
294
+ docs?: undefined;
295
+ })[];
296
+ args: {
297
+ name: string;
298
+ type: string;
299
+ }[];
300
+ } | {
301
+ name: string;
302
+ docs: string[];
303
+ discriminator: number[];
304
+ accounts: ({
305
+ name: string;
306
+ writable: boolean;
307
+ signer: boolean;
308
+ pda?: undefined;
309
+ relations?: undefined;
310
+ docs?: undefined;
311
+ optional?: undefined;
312
+ address?: undefined;
313
+ } | {
314
+ name: string;
315
+ writable: boolean;
316
+ pda: {
317
+ seeds: ({
318
+ kind: string;
319
+ value: number[];
320
+ path?: undefined;
321
+ account?: undefined;
322
+ } | {
323
+ kind: string;
324
+ path: string;
325
+ account: string;
326
+ value?: undefined;
327
+ })[];
328
+ };
329
+ relations: string[];
330
+ signer?: undefined;
331
+ docs?: undefined;
332
+ optional?: undefined;
333
+ address?: undefined;
334
+ } | {
335
+ name: string;
336
+ pda: {
337
+ seeds: ({
338
+ kind: string;
339
+ value: number[];
340
+ path?: undefined;
341
+ } | {
342
+ kind: string;
343
+ path: string;
344
+ value?: undefined;
345
+ })[];
346
+ };
347
+ writable?: undefined;
348
+ signer?: undefined;
349
+ relations?: undefined;
350
+ docs?: undefined;
351
+ optional?: undefined;
352
+ address?: undefined;
353
+ } | {
354
+ name: string;
355
+ docs: string[];
356
+ writable: boolean;
357
+ pda: {
358
+ seeds: ({
359
+ kind: string;
360
+ value: number[];
361
+ path?: undefined;
362
+ account?: undefined;
363
+ } | {
364
+ kind: string;
365
+ path: string;
366
+ value?: undefined;
367
+ account?: undefined;
368
+ } | {
369
+ kind: string;
370
+ path: string;
371
+ account: string;
372
+ value?: undefined;
373
+ })[];
374
+ };
375
+ signer?: undefined;
376
+ relations?: undefined;
377
+ optional?: undefined;
378
+ address?: undefined;
379
+ } | {
380
+ name: string;
381
+ writable: boolean;
382
+ signer?: undefined;
383
+ pda?: undefined;
384
+ relations?: undefined;
385
+ docs?: undefined;
386
+ optional?: undefined;
387
+ address?: undefined;
388
+ } | {
389
+ name: string;
390
+ docs: string[];
391
+ writable: boolean;
392
+ optional: boolean;
393
+ signer?: undefined;
394
+ pda?: undefined;
395
+ relations?: undefined;
396
+ address?: undefined;
397
+ } | {
398
+ name: string;
399
+ address: string;
400
+ writable?: undefined;
401
+ signer?: undefined;
402
+ pda?: undefined;
403
+ relations?: undefined;
404
+ docs?: undefined;
405
+ optional?: undefined;
406
+ })[];
407
+ args: {
408
+ name: string;
409
+ type: string;
410
+ }[];
411
+ } | {
412
+ name: string;
413
+ docs: string[];
414
+ discriminator: number[];
415
+ accounts: ({
416
+ name: string;
417
+ writable: boolean;
418
+ signer: boolean;
419
+ pda?: undefined;
420
+ address?: undefined;
421
+ } | {
422
+ name: string;
423
+ writable: boolean;
424
+ pda: {
425
+ seeds: {
426
+ kind: string;
427
+ value: number[];
428
+ }[];
429
+ };
430
+ signer?: undefined;
431
+ address?: undefined;
432
+ } | {
433
+ name: string;
434
+ address: string;
435
+ writable?: undefined;
436
+ signer?: undefined;
437
+ pda?: undefined;
438
+ })[];
439
+ args: {
440
+ name: string;
441
+ type: {
442
+ vec: {
443
+ defined: {
444
+ name: string;
589
445
  };
590
446
  };
591
447
  };
592
- }, {
593
- readonly name: "allowed_protocols";
594
- readonly type: {
595
- readonly option: {
596
- readonly vec: "pubkey";
448
+ }[];
449
+ } | {
450
+ name: string;
451
+ docs: string[];
452
+ discriminator: number[];
453
+ accounts: ({
454
+ name: string;
455
+ writable: boolean;
456
+ signer: boolean;
457
+ pda?: undefined;
458
+ docs?: undefined;
459
+ address?: undefined;
460
+ } | {
461
+ name: string;
462
+ writable: boolean;
463
+ pda: {
464
+ seeds: ({
465
+ kind: string;
466
+ value: number[];
467
+ path?: undefined;
468
+ } | {
469
+ kind: string;
470
+ path: string;
471
+ value?: undefined;
472
+ })[];
473
+ };
474
+ signer?: undefined;
475
+ docs?: undefined;
476
+ address?: undefined;
477
+ } | {
478
+ name: string;
479
+ docs: string[];
480
+ writable: boolean;
481
+ pda: {
482
+ seeds: ({
483
+ kind: string;
484
+ value: number[];
485
+ path?: undefined;
486
+ } | {
487
+ kind: string;
488
+ path: string;
489
+ value?: undefined;
490
+ })[];
491
+ };
492
+ signer?: undefined;
493
+ address?: undefined;
494
+ } | {
495
+ name: string;
496
+ writable?: undefined;
497
+ signer?: undefined;
498
+ pda?: undefined;
499
+ docs?: undefined;
500
+ address?: undefined;
501
+ } | {
502
+ name: string;
503
+ address: string;
504
+ writable?: undefined;
505
+ signer?: undefined;
506
+ pda?: undefined;
507
+ docs?: undefined;
508
+ })[];
509
+ args: ({
510
+ name: string;
511
+ type: string;
512
+ } | {
513
+ name: string;
514
+ type: {
515
+ vec: string;
516
+ };
517
+ })[];
518
+ } | {
519
+ name: string;
520
+ docs: string[];
521
+ discriminator: number[];
522
+ accounts: ({
523
+ name: string;
524
+ writable: boolean;
525
+ signer: boolean;
526
+ relations: string[];
527
+ pda?: undefined;
528
+ address?: undefined;
529
+ } | {
530
+ name: string;
531
+ pda: {
532
+ seeds: ({
533
+ kind: string;
534
+ value: number[];
535
+ path?: undefined;
536
+ account?: undefined;
537
+ } | {
538
+ kind: string;
539
+ path: string;
540
+ value?: undefined;
541
+ account?: undefined;
542
+ } | {
543
+ kind: string;
544
+ path: string;
545
+ account: string;
546
+ value?: undefined;
547
+ })[];
548
+ };
549
+ relations: string[];
550
+ writable?: undefined;
551
+ signer?: undefined;
552
+ address?: undefined;
553
+ } | {
554
+ name: string;
555
+ pda: {
556
+ seeds: ({
557
+ kind: string;
558
+ value: number[];
559
+ path?: undefined;
560
+ } | {
561
+ kind: string;
562
+ path: string;
563
+ value?: undefined;
564
+ })[];
565
+ };
566
+ writable?: undefined;
567
+ signer?: undefined;
568
+ relations?: undefined;
569
+ address?: undefined;
570
+ } | {
571
+ name: string;
572
+ writable: boolean;
573
+ pda: {
574
+ seeds: ({
575
+ kind: string;
576
+ value: number[];
577
+ path?: undefined;
578
+ } | {
579
+ kind: string;
580
+ path: string;
581
+ value?: undefined;
582
+ })[];
583
+ };
584
+ signer?: undefined;
585
+ relations?: undefined;
586
+ address?: undefined;
587
+ } | {
588
+ name: string;
589
+ address: string;
590
+ writable?: undefined;
591
+ signer?: undefined;
592
+ relations?: undefined;
593
+ pda?: undefined;
594
+ })[];
595
+ args: ({
596
+ name: string;
597
+ type: {
598
+ option: string;
599
+ };
600
+ } | {
601
+ name: string;
602
+ type: {
603
+ option: {
604
+ vec: string;
597
605
  };
598
606
  };
599
- }, {
600
- readonly name: "max_leverage_bps";
601
- readonly type: {
602
- readonly option: "u16";
603
- };
604
- }, {
605
- readonly name: "can_open_positions";
606
- readonly type: {
607
- readonly option: "bool";
608
- };
609
- }, {
610
- readonly name: "max_concurrent_positions";
611
- readonly type: {
612
- readonly option: "u8";
613
- };
614
- }, {
615
- readonly name: "developer_fee_rate";
616
- readonly type: {
617
- readonly option: "u16";
618
- };
619
- }, {
620
- readonly name: "timelock_duration";
621
- readonly type: {
622
- readonly option: "u64";
623
- };
624
- }, {
625
- readonly name: "allowed_destinations";
626
- readonly type: {
627
- readonly option: {
628
- readonly vec: "pubkey";
629
- };
630
- };
631
- }];
632
- }, {
633
- readonly name: "reactivate_vault";
634
- readonly docs: readonly ["Reactivate a frozen vault. Optionally rotate the agent key.", "Only the owner can call this."];
635
- readonly discriminator: readonly [245, 50, 143, 70, 114, 220, 25, 251];
636
- readonly accounts: readonly [{
637
- readonly name: "owner";
638
- readonly signer: true;
639
- readonly relations: readonly ["vault"];
640
- }, {
641
- readonly name: "vault";
642
- readonly writable: true;
643
- readonly pda: {
644
- readonly seeds: readonly [{
645
- readonly kind: "const";
646
- readonly value: readonly [118, 97, 117, 108, 116];
647
- }, {
648
- readonly kind: "account";
649
- readonly path: "owner";
650
- }, {
651
- readonly kind: "account";
652
- readonly path: "vault.vault_id";
653
- readonly account: "AgentVault";
654
- }];
655
- };
656
- }];
657
- readonly args: readonly [{
658
- readonly name: "new_agent";
659
- readonly type: {
660
- readonly option: "pubkey";
661
- };
662
- }];
663
- }, {
664
- readonly name: "register_agent";
665
- readonly docs: readonly ["Register an agent's signing key to this vault.", "Only the owner can call this. One agent per vault."];
666
- readonly discriminator: readonly [135, 157, 66, 195, 2, 113, 175, 30];
667
- readonly accounts: readonly [{
668
- readonly name: "owner";
669
- readonly signer: true;
670
- readonly relations: readonly ["vault"];
671
- }, {
672
- readonly name: "vault";
673
- readonly writable: true;
674
- readonly pda: {
675
- readonly seeds: readonly [{
676
- readonly kind: "const";
677
- readonly value: readonly [118, 97, 117, 108, 116];
678
- }, {
679
- readonly kind: "account";
680
- readonly path: "owner";
681
- }, {
682
- readonly kind: "account";
683
- readonly path: "vault.vault_id";
684
- readonly account: "AgentVault";
685
- }];
686
- };
687
- }];
688
- readonly args: readonly [{
689
- readonly name: "agent";
690
- readonly type: "pubkey";
691
- }];
692
- }, {
693
- readonly name: "revoke_agent";
694
- readonly docs: readonly ["Kill switch. Immediately freezes the vault, preventing all agent actions.", "Only the owner can call this. Funds can still be withdrawn by the owner."];
695
- readonly discriminator: readonly [227, 60, 209, 125, 240, 117, 163, 73];
696
- readonly accounts: readonly [{
697
- readonly name: "owner";
698
- readonly signer: true;
699
- readonly relations: readonly ["vault"];
700
- }, {
701
- readonly name: "vault";
702
- readonly writable: true;
703
- readonly pda: {
704
- readonly seeds: readonly [{
705
- readonly kind: "const";
706
- readonly value: readonly [118, 97, 117, 108, 116];
707
- }, {
708
- readonly kind: "account";
709
- readonly path: "owner";
710
- }, {
711
- readonly kind: "account";
712
- readonly path: "vault.vault_id";
713
- readonly account: "AgentVault";
714
- }];
715
- };
716
- }];
717
- readonly args: readonly [];
718
- }, {
719
- readonly name: "update_policy";
720
- readonly docs: readonly ["Update the policy configuration for a vault.", "Only the owner can call this. Cannot be called by the agent.", "Blocked when timelock_duration > 0 — use queue_policy_update instead."];
721
- readonly discriminator: readonly [212, 245, 246, 7, 163, 151, 18, 57];
722
- readonly accounts: readonly [{
723
- readonly name: "owner";
724
- readonly signer: true;
725
- readonly relations: readonly ["vault"];
726
- }, {
727
- readonly name: "vault";
728
- readonly pda: {
729
- readonly seeds: readonly [{
730
- readonly kind: "const";
731
- readonly value: readonly [118, 97, 117, 108, 116];
732
- }, {
733
- readonly kind: "account";
734
- readonly path: "owner";
735
- }, {
736
- readonly kind: "account";
737
- readonly path: "vault.vault_id";
738
- readonly account: "AgentVault";
739
- }];
740
- };
741
- readonly relations: readonly ["policy", "tracker"];
742
- }, {
743
- readonly name: "policy";
744
- readonly writable: true;
745
- readonly pda: {
746
- readonly seeds: readonly [{
747
- readonly kind: "const";
748
- readonly value: readonly [112, 111, 108, 105, 99, 121];
749
- }, {
750
- readonly kind: "account";
751
- readonly path: "vault";
752
- }];
753
- };
754
- }, {
755
- readonly name: "tracker";
756
- readonly writable: true;
757
- readonly pda: {
758
- readonly seeds: readonly [{
759
- readonly kind: "const";
760
- readonly value: readonly [116, 114, 97, 99, 107, 101, 114];
761
- }, {
762
- readonly kind: "account";
763
- readonly path: "vault";
764
- }];
765
- };
766
- }];
767
- readonly args: readonly [{
768
- readonly name: "daily_spending_cap_usd";
769
- readonly type: {
770
- readonly option: "u64";
771
- };
772
- }, {
773
- readonly name: "max_transaction_size_usd";
774
- readonly type: {
775
- readonly option: "u64";
776
- };
777
- }, {
778
- readonly name: "allowed_tokens";
779
- readonly type: {
780
- readonly option: {
781
- readonly vec: {
782
- readonly defined: {
783
- readonly name: "AllowedToken";
784
- };
607
+ })[];
608
+ } | {
609
+ name: string;
610
+ docs: string[];
611
+ discriminator: number[];
612
+ accounts: ({
613
+ name: string;
614
+ signer: boolean;
615
+ relations: string[];
616
+ writable?: undefined;
617
+ pda?: undefined;
618
+ } | {
619
+ name: string;
620
+ writable: boolean;
621
+ pda: {
622
+ seeds: ({
623
+ kind: string;
624
+ value: number[];
625
+ path?: undefined;
626
+ account?: undefined;
627
+ } | {
628
+ kind: string;
629
+ path: string;
630
+ value?: undefined;
631
+ account?: undefined;
632
+ } | {
633
+ kind: string;
634
+ path: string;
635
+ account: string;
636
+ value?: undefined;
637
+ })[];
638
+ };
639
+ signer?: undefined;
640
+ relations?: undefined;
641
+ })[];
642
+ args: {
643
+ name: string;
644
+ type: {
645
+ option: string;
646
+ };
647
+ }[];
648
+ } | {
649
+ name: string;
650
+ docs: string[];
651
+ discriminator: number[];
652
+ accounts: ({
653
+ name: string;
654
+ signer: boolean;
655
+ relations: string[];
656
+ writable?: undefined;
657
+ pda?: undefined;
658
+ } | {
659
+ name: string;
660
+ writable: boolean;
661
+ pda: {
662
+ seeds: ({
663
+ kind: string;
664
+ value: number[];
665
+ path?: undefined;
666
+ account?: undefined;
667
+ } | {
668
+ kind: string;
669
+ path: string;
670
+ value?: undefined;
671
+ account?: undefined;
672
+ } | {
673
+ kind: string;
674
+ path: string;
675
+ account: string;
676
+ value?: undefined;
677
+ })[];
678
+ };
679
+ signer?: undefined;
680
+ relations?: undefined;
681
+ })[];
682
+ args: {
683
+ name: string;
684
+ type: string;
685
+ }[];
686
+ } | {
687
+ name: string;
688
+ docs: string[];
689
+ discriminator: number[];
690
+ accounts: ({
691
+ name: string;
692
+ signer: boolean;
693
+ writable?: undefined;
694
+ pda?: undefined;
695
+ } | {
696
+ name: string;
697
+ writable: boolean;
698
+ pda: {
699
+ seeds: {
700
+ kind: string;
701
+ value: number[];
702
+ }[];
703
+ };
704
+ signer?: undefined;
705
+ })[];
706
+ args: ({
707
+ name: string;
708
+ type: {
709
+ vec: {
710
+ defined: {
711
+ name: string;
785
712
  };
786
713
  };
787
714
  };
788
- }, {
789
- readonly name: "allowed_protocols";
790
- readonly type: {
791
- readonly option: {
792
- readonly vec: "pubkey";
715
+ } | {
716
+ name: string;
717
+ type: {
718
+ vec: string;
719
+ };
720
+ })[];
721
+ } | {
722
+ name: string;
723
+ docs: string[];
724
+ discriminator: number[];
725
+ accounts: ({
726
+ name: string;
727
+ signer: boolean;
728
+ relations: string[];
729
+ pda?: undefined;
730
+ writable?: undefined;
731
+ } | {
732
+ name: string;
733
+ pda: {
734
+ seeds: ({
735
+ kind: string;
736
+ value: number[];
737
+ path?: undefined;
738
+ account?: undefined;
739
+ } | {
740
+ kind: string;
741
+ path: string;
742
+ value?: undefined;
743
+ account?: undefined;
744
+ } | {
745
+ kind: string;
746
+ path: string;
747
+ account: string;
748
+ value?: undefined;
749
+ })[];
750
+ };
751
+ relations: string[];
752
+ signer?: undefined;
753
+ writable?: undefined;
754
+ } | {
755
+ name: string;
756
+ writable: boolean;
757
+ pda: {
758
+ seeds: ({
759
+ kind: string;
760
+ value: number[];
761
+ path?: undefined;
762
+ } | {
763
+ kind: string;
764
+ path: string;
765
+ value?: undefined;
766
+ })[];
767
+ };
768
+ signer?: undefined;
769
+ relations?: undefined;
770
+ })[];
771
+ args: ({
772
+ name: string;
773
+ type: {
774
+ option: string;
775
+ };
776
+ } | {
777
+ name: string;
778
+ type: {
779
+ option: {
780
+ vec: string;
793
781
  };
794
782
  };
795
- }, {
796
- readonly name: "max_leverage_bps";
797
- readonly type: {
798
- readonly option: "u16";
799
- };
800
- }, {
801
- readonly name: "can_open_positions";
802
- readonly type: {
803
- readonly option: "bool";
804
- };
805
- }, {
806
- readonly name: "max_concurrent_positions";
807
- readonly type: {
808
- readonly option: "u8";
809
- };
810
- }, {
811
- readonly name: "developer_fee_rate";
812
- readonly type: {
813
- readonly option: "u16";
814
- };
815
- }, {
816
- readonly name: "timelock_duration";
817
- readonly type: {
818
- readonly option: "u64";
819
- };
820
- }, {
821
- readonly name: "allowed_destinations";
822
- readonly type: {
823
- readonly option: {
824
- readonly vec: "pubkey";
783
+ })[];
784
+ } | {
785
+ name: string;
786
+ docs: string[];
787
+ discriminator: number[];
788
+ accounts: ({
789
+ name: string;
790
+ writable: boolean;
791
+ signer: boolean;
792
+ pda?: undefined;
793
+ relations?: undefined;
794
+ docs?: undefined;
795
+ address?: undefined;
796
+ } | {
797
+ name: string;
798
+ writable: boolean;
799
+ pda: {
800
+ seeds: ({
801
+ kind: string;
802
+ value: number[];
803
+ path?: undefined;
804
+ account?: undefined;
805
+ } | {
806
+ kind: string;
807
+ path: string;
808
+ account: string;
809
+ value?: undefined;
810
+ })[];
811
+ };
812
+ relations: string[];
813
+ signer?: undefined;
814
+ docs?: undefined;
815
+ address?: undefined;
816
+ } | {
817
+ name: string;
818
+ pda: {
819
+ seeds: ({
820
+ kind: string;
821
+ value: number[];
822
+ path?: undefined;
823
+ } | {
824
+ kind: string;
825
+ path: string;
826
+ value?: undefined;
827
+ })[];
828
+ };
829
+ writable?: undefined;
830
+ signer?: undefined;
831
+ relations?: undefined;
832
+ docs?: undefined;
833
+ address?: undefined;
834
+ } | {
835
+ name: string;
836
+ docs: string[];
837
+ writable: boolean;
838
+ pda: {
839
+ seeds: ({
840
+ kind: string;
841
+ value: number[];
842
+ path?: undefined;
843
+ } | {
844
+ kind: string;
845
+ path: string;
846
+ value?: undefined;
847
+ })[];
848
+ };
849
+ signer?: undefined;
850
+ relations?: undefined;
851
+ address?: undefined;
852
+ } | {
853
+ name: string;
854
+ docs: string[];
855
+ pda: {
856
+ seeds: {
857
+ kind: string;
858
+ value: number[];
859
+ }[];
860
+ };
861
+ writable?: undefined;
862
+ signer?: undefined;
863
+ relations?: undefined;
864
+ address?: undefined;
865
+ } | {
866
+ name: string;
867
+ docs: string[];
868
+ writable: boolean;
869
+ signer?: undefined;
870
+ pda?: undefined;
871
+ relations?: undefined;
872
+ address?: undefined;
873
+ } | {
874
+ name: string;
875
+ docs: string[];
876
+ writable?: undefined;
877
+ signer?: undefined;
878
+ pda?: undefined;
879
+ relations?: undefined;
880
+ address?: undefined;
881
+ } | {
882
+ name: string;
883
+ address: string;
884
+ writable?: undefined;
885
+ signer?: undefined;
886
+ pda?: undefined;
887
+ relations?: undefined;
888
+ docs?: undefined;
889
+ })[];
890
+ args: ({
891
+ name: string;
892
+ type: {
893
+ defined: {
894
+ name: string;
825
895
  };
826
- };
827
- }];
828
- }, {
829
- readonly name: "validate_and_authorize";
830
- readonly docs: readonly ["Core permission check. Called by the agent before a DeFi action.", "Validates the action against all policy constraints (USD caps, per-token caps).", "If approved, creates a SessionAuthority PDA, delegates tokens to agent,", "and updates spend tracking.", "If denied, reverts the entire transaction (including subsequent DeFi instructions)."];
831
- readonly discriminator: readonly [22, 183, 48, 222, 218, 11, 197, 152];
832
- readonly accounts: readonly [{
833
- readonly name: "agent";
834
- readonly writable: true;
835
- readonly signer: true;
836
- }, {
837
- readonly name: "vault";
838
- readonly writable: true;
839
- readonly pda: {
840
- readonly seeds: readonly [{
841
- readonly kind: "const";
842
- readonly value: readonly [118, 97, 117, 108, 116];
843
- }, {
844
- readonly kind: "account";
845
- readonly path: "vault.owner";
846
- readonly account: "AgentVault";
847
- }, {
848
- readonly kind: "account";
849
- readonly path: "vault.vault_id";
850
- readonly account: "AgentVault";
851
- }];
852
- };
853
- readonly relations: readonly ["policy", "tracker"];
854
- }, {
855
- readonly name: "policy";
856
- readonly pda: {
857
- readonly seeds: readonly [{
858
- readonly kind: "const";
859
- readonly value: readonly [112, 111, 108, 105, 99, 121];
860
- }, {
861
- readonly kind: "account";
862
- readonly path: "vault";
863
- }];
864
- };
865
- }, {
866
- readonly name: "tracker";
867
- readonly writable: true;
868
- readonly pda: {
869
- readonly seeds: readonly [{
870
- readonly kind: "const";
871
- readonly value: readonly [116, 114, 97, 99, 107, 101, 114];
872
- }, {
873
- readonly kind: "account";
874
- readonly path: "vault";
875
- }];
876
- };
877
- }, {
878
- readonly name: "session";
879
- readonly docs: readonly ["Ephemeral session PDA — `init` ensures no double-authorization.", "Seeds include token_mint for per-token concurrent sessions."];
880
- readonly writable: true;
881
- readonly pda: {
882
- readonly seeds: readonly [{
883
- readonly kind: "const";
884
- readonly value: readonly [115, 101, 115, 115, 105, 111, 110];
885
- }, {
886
- readonly kind: "account";
887
- readonly path: "vault";
888
- }, {
889
- readonly kind: "account";
890
- readonly path: "agent";
891
- }, {
892
- readonly kind: "arg";
893
- readonly path: "token_mint";
894
- }];
895
- };
896
- }, {
897
- readonly name: "vault_token_account";
898
- readonly docs: readonly ["Vault's PDA-owned token account for the spend token (delegation source)"];
899
- readonly writable: true;
900
- }, {
901
- readonly name: "token_mint_account";
902
- readonly docs: readonly ["The token mint being spent"];
903
- }, {
904
- readonly name: "token_program";
905
- readonly address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
906
- }, {
907
- readonly name: "system_program";
908
- readonly address: "11111111111111111111111111111111";
909
- }];
910
- readonly args: readonly [{
911
- readonly name: "action_type";
912
- readonly type: {
913
- readonly defined: {
914
- readonly name: "ActionType";
915
- };
916
- };
917
- }, {
918
- readonly name: "token_mint";
919
- readonly type: "pubkey";
920
- }, {
921
- readonly name: "amount";
922
- readonly type: "u64";
923
- }, {
924
- readonly name: "target_protocol";
925
- readonly type: "pubkey";
926
- }, {
927
- readonly name: "leverage_bps";
928
- readonly type: {
929
- readonly option: "u16";
930
- };
931
- }];
932
- }, {
933
- readonly name: "withdraw_funds";
934
- readonly docs: readonly ["Withdraw tokens from the vault back to the owner.", "Works in any vault status (Active or Frozen). Only the owner can call this."];
935
- readonly discriminator: readonly [241, 36, 29, 111, 208, 31, 104, 217];
936
- readonly accounts: readonly [{
937
- readonly name: "owner";
938
- readonly writable: true;
939
- readonly signer: true;
940
- readonly relations: readonly ["vault"];
941
- }, {
942
- readonly name: "vault";
943
- readonly pda: {
944
- readonly seeds: readonly [{
945
- readonly kind: "const";
946
- readonly value: readonly [118, 97, 117, 108, 116];
947
- }, {
948
- readonly kind: "account";
949
- readonly path: "owner";
950
- }, {
951
- readonly kind: "account";
952
- readonly path: "vault.vault_id";
953
- readonly account: "AgentVault";
954
- }];
955
- };
956
- }, {
957
- readonly name: "mint";
958
- }, {
959
- readonly name: "vault_token_account";
960
- readonly docs: readonly ["Vault's PDA-controlled token account"];
961
- readonly writable: true;
962
- readonly pda: {
963
- readonly seeds: readonly [{
964
- readonly kind: "account";
965
- readonly path: "vault";
966
- }, {
967
- readonly kind: "const";
968
- readonly value: readonly [6, 221, 246, 225, 215, 101, 161, 147, 217, 203, 225, 70, 206, 235, 121, 172, 28, 180, 133, 237, 95, 91, 55, 145, 58, 140, 245, 133, 126, 255, 0, 169];
969
- }, {
970
- readonly kind: "account";
971
- readonly path: "mint";
972
- }];
973
- readonly program: {
974
- readonly kind: "const";
975
- readonly value: readonly [140, 151, 37, 143, 78, 36, 137, 241, 187, 61, 16, 41, 20, 142, 13, 131, 11, 90, 19, 153, 218, 255, 16, 132, 4, 142, 123, 216, 219, 233, 248, 89];
976
- };
977
- };
978
- }, {
979
- readonly name: "owner_token_account";
980
- readonly docs: readonly ["Owner's token account to receive funds"];
981
- readonly writable: true;
982
- readonly pda: {
983
- readonly seeds: readonly [{
984
- readonly kind: "account";
985
- readonly path: "owner";
986
- }, {
987
- readonly kind: "const";
988
- readonly value: readonly [6, 221, 246, 225, 215, 101, 161, 147, 217, 203, 225, 70, 206, 235, 121, 172, 28, 180, 133, 237, 95, 91, 55, 145, 58, 140, 245, 133, 126, 255, 0, 169];
989
- }, {
990
- readonly kind: "account";
991
- readonly path: "mint";
992
- }];
993
- readonly program: {
994
- readonly kind: "const";
995
- readonly value: readonly [140, 151, 37, 143, 78, 36, 137, 241, 187, 61, 16, 41, 20, 142, 13, 131, 11, 90, 19, 153, 218, 255, 16, 132, 4, 142, 123, 216, 219, 233, 248, 89];
996
- };
997
- };
998
- }, {
999
- readonly name: "token_program";
1000
- readonly address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
1001
- }];
1002
- readonly args: readonly [{
1003
- readonly name: "amount";
1004
- readonly type: "u64";
1005
- }];
1006
- }];
1007
- readonly accounts: readonly [{
1008
- readonly name: "AgentVault";
1009
- readonly discriminator: readonly [232, 220, 237, 164, 157, 9, 215, 194];
1010
- }, {
1011
- readonly name: "PendingPolicyUpdate";
1012
- readonly discriminator: readonly [77, 255, 2, 51, 79, 237, 183, 239];
1013
- }, {
1014
- readonly name: "PolicyConfig";
1015
- readonly discriminator: readonly [219, 7, 79, 84, 175, 51, 148, 146];
1016
- }, {
1017
- readonly name: "SessionAuthority";
1018
- readonly discriminator: readonly [48, 9, 30, 120, 134, 35, 172, 170];
1019
- }, {
1020
- readonly name: "SpendTracker";
1021
- readonly discriminator: readonly [180, 17, 195, 180, 162, 207, 239, 205];
1022
- }];
1023
- readonly events: readonly [{
1024
- readonly name: "ActionAuthorized";
1025
- readonly discriminator: readonly [85, 90, 59, 218, 126, 8, 179, 63];
1026
- }, {
1027
- readonly name: "ActionDenied";
1028
- readonly discriminator: readonly [243, 239, 240, 51, 151, 100, 10, 100];
1029
- }, {
1030
- readonly name: "AgentRegistered";
1031
- readonly discriminator: readonly [191, 78, 217, 54, 232, 100, 189, 85];
1032
- }, {
1033
- readonly name: "AgentRevoked";
1034
- readonly discriminator: readonly [12, 251, 249, 166, 122, 83, 162, 116];
1035
- }, {
1036
- readonly name: "AgentTransferExecuted";
1037
- readonly discriminator: readonly [88, 52, 117, 69, 112, 152, 167, 40];
1038
- }, {
1039
- readonly name: "DelegationRevoked";
1040
- readonly discriminator: readonly [59, 158, 142, 49, 164, 116, 220, 8];
1041
- }, {
1042
- readonly name: "FeesCollected";
1043
- readonly discriminator: readonly [233, 23, 117, 225, 107, 178, 254, 8];
1044
- }, {
1045
- readonly name: "FundsDeposited";
1046
- readonly discriminator: readonly [157, 209, 100, 95, 59, 100, 3, 68];
1047
- }, {
1048
- readonly name: "FundsWithdrawn";
1049
- readonly discriminator: readonly [56, 130, 230, 154, 35, 92, 11, 118];
1050
- }, {
1051
- readonly name: "PolicyChangeApplied";
1052
- readonly discriminator: readonly [104, 89, 5, 100, 180, 202, 52, 73];
1053
- }, {
1054
- readonly name: "PolicyChangeCancelled";
1055
- readonly discriminator: readonly [200, 158, 226, 255, 25, 211, 30, 151];
1056
- }, {
1057
- readonly name: "PolicyChangeQueued";
1058
- readonly discriminator: readonly [73, 231, 182, 136, 141, 120, 32, 79];
1059
- }, {
1060
- readonly name: "PolicyUpdated";
1061
- readonly discriminator: readonly [225, 112, 112, 67, 95, 236, 245, 161];
1062
- }, {
1063
- readonly name: "SessionFinalized";
1064
- readonly discriminator: readonly [33, 12, 242, 91, 206, 42, 163, 235];
1065
- }, {
1066
- readonly name: "VaultClosed";
1067
- readonly discriminator: readonly [238, 129, 38, 228, 227, 118, 249, 215];
1068
- }, {
1069
- readonly name: "VaultCreated";
1070
- readonly discriminator: readonly [117, 25, 120, 254, 75, 236, 78, 115];
1071
- }, {
1072
- readonly name: "VaultReactivated";
1073
- readonly discriminator: readonly [197, 52, 160, 147, 159, 89, 90, 28];
1074
- }];
1075
- readonly errors: readonly [{
1076
- readonly code: 6000;
1077
- readonly name: "VaultNotActive";
1078
- readonly msg: "Vault is not active";
1079
- }, {
1080
- readonly code: 6001;
1081
- readonly name: "UnauthorizedAgent";
1082
- readonly msg: "Unauthorized: signer is not the registered agent";
1083
- }, {
1084
- readonly code: 6002;
1085
- readonly name: "UnauthorizedOwner";
1086
- readonly msg: "Unauthorized: signer is not the vault owner";
1087
- }, {
1088
- readonly code: 6003;
1089
- readonly name: "TokenNotAllowed";
1090
- readonly msg: "Token not in allowed list";
1091
- }, {
1092
- readonly code: 6004;
1093
- readonly name: "ProtocolNotAllowed";
1094
- readonly msg: "Protocol not in allowed list";
1095
- }, {
1096
- readonly code: 6005;
1097
- readonly name: "TransactionTooLarge";
1098
- readonly msg: "Transaction exceeds maximum single transaction size";
1099
- }, {
1100
- readonly code: 6006;
1101
- readonly name: "DailyCapExceeded";
1102
- readonly msg: "Daily spending cap would be exceeded";
1103
- }, {
1104
- readonly code: 6007;
1105
- readonly name: "LeverageTooHigh";
1106
- readonly msg: "Leverage exceeds maximum allowed";
1107
- }, {
1108
- readonly code: 6008;
1109
- readonly name: "TooManyPositions";
1110
- readonly msg: "Maximum concurrent open positions reached";
1111
- }, {
1112
- readonly code: 6009;
1113
- readonly name: "PositionOpeningDisallowed";
1114
- readonly msg: "Cannot open new positions (policy disallows)";
1115
- }, {
1116
- readonly code: 6010;
1117
- readonly name: "SessionExpired";
1118
- readonly msg: "Session has expired";
1119
- }, {
1120
- readonly code: 6011;
1121
- readonly name: "SessionNotAuthorized";
1122
- readonly msg: "Session not authorized";
1123
- }, {
1124
- readonly code: 6012;
1125
- readonly name: "InvalidSession";
1126
- readonly msg: "Invalid session: does not belong to this vault";
1127
- }, {
1128
- readonly code: 6013;
1129
- readonly name: "OpenPositionsExist";
1130
- readonly msg: "Vault has open positions, cannot close";
1131
- }, {
1132
- readonly code: 6014;
1133
- readonly name: "TooManyAllowedTokens";
1134
- readonly msg: "Policy configuration invalid: too many allowed tokens";
1135
- }, {
1136
- readonly code: 6015;
1137
- readonly name: "TooManyAllowedProtocols";
1138
- readonly msg: "Policy configuration invalid: too many allowed protocols";
1139
- }, {
1140
- readonly code: 6016;
1141
- readonly name: "AgentAlreadyRegistered";
1142
- readonly msg: "Agent already registered for this vault";
1143
- }, {
1144
- readonly code: 6017;
1145
- readonly name: "NoAgentRegistered";
1146
- readonly msg: "No agent registered for this vault";
1147
- }, {
1148
- readonly code: 6018;
1149
- readonly name: "VaultNotFrozen";
1150
- readonly msg: "Vault is not frozen (expected frozen for reactivation)";
1151
- }, {
1152
- readonly code: 6019;
1153
- readonly name: "VaultAlreadyClosed";
1154
- readonly msg: "Vault is already closed";
1155
- }, {
1156
- readonly code: 6020;
1157
- readonly name: "InsufficientBalance";
1158
- readonly msg: "Insufficient vault balance for withdrawal";
1159
- }, {
1160
- readonly code: 6021;
1161
- readonly name: "DeveloperFeeTooHigh";
1162
- readonly msg: "Developer fee rate exceeds maximum (500 / 1,000,000 = 5 BPS)";
1163
- }, {
1164
- readonly code: 6022;
1165
- readonly name: "InvalidFeeDestination";
1166
- readonly msg: "Fee destination account invalid";
1167
- }, {
1168
- readonly code: 6023;
1169
- readonly name: "InvalidProtocolTreasury";
1170
- readonly msg: "Protocol treasury account does not match expected address";
1171
- }, {
1172
- readonly code: 6024;
1173
- readonly name: "TooManySpendEntries";
1174
- readonly msg: "Spend entry limit reached (too many active entries in rolling window)";
1175
- }, {
1176
- readonly code: 6025;
1177
- readonly name: "InvalidAgentKey";
1178
- readonly msg: "Invalid agent: cannot be the zero address";
1179
- }, {
1180
- readonly code: 6026;
1181
- readonly name: "AgentIsOwner";
1182
- readonly msg: "Invalid agent: agent cannot be the vault owner";
1183
- }, {
1184
- readonly code: 6027;
1185
- readonly name: "Overflow";
1186
- readonly msg: "Arithmetic overflow";
1187
- }, {
1188
- readonly code: 6028;
1189
- readonly name: "DelegationFailed";
1190
- readonly msg: "Token delegation approval failed";
1191
- }, {
1192
- readonly code: 6029;
1193
- readonly name: "RevocationFailed";
1194
- readonly msg: "Token delegation revocation failed";
1195
- }, {
1196
- readonly code: 6030;
1197
- readonly name: "OracleFeedStale";
1198
- readonly msg: "Oracle feed value is too stale";
1199
- }, {
1200
- readonly code: 6031;
1201
- readonly name: "OracleFeedInvalid";
1202
- readonly msg: "Cannot parse oracle feed data";
1203
- }, {
1204
- readonly code: 6032;
1205
- readonly name: "TokenSpendBlocked";
1206
- readonly msg: "Unpriced token cannot be spent (receive-only)";
1207
- }, {
1208
- readonly code: 6033;
1209
- readonly name: "InvalidTokenAccount";
1210
- readonly msg: "Token account does not belong to vault or has wrong mint";
1211
- }, {
1212
- readonly code: 6034;
1213
- readonly name: "OracleAccountMissing";
1214
- readonly msg: "Oracle-priced token requires feed account in remaining_accounts";
1215
- }, {
1216
- readonly code: 6035;
1217
- readonly name: "PerTokenCapExceeded";
1218
- readonly msg: "Per-token daily spending cap would be exceeded";
1219
- }, {
1220
- readonly code: 6036;
1221
- readonly name: "PerTokenTxLimitExceeded";
1222
- readonly msg: "Per-token single transaction limit exceeded";
1223
- }, {
1224
- readonly code: 6037;
1225
- readonly name: "OracleConfidenceTooWide";
1226
- readonly msg: "Oracle price confidence interval too wide";
1227
- }, {
1228
- readonly code: 6038;
1229
- readonly name: "OracleUnsupportedType";
1230
- readonly msg: "Oracle account owner is not a recognized oracle program";
1231
- }, {
1232
- readonly code: 6039;
1233
- readonly name: "OracleNotVerified";
1234
- readonly msg: "Pyth price update not fully verified by Wormhole";
1235
- }, {
1236
- readonly code: 6040;
1237
- readonly name: "TimelockNotExpired";
1238
- readonly msg: "Timelock period has not expired yet";
1239
- }, {
1240
- readonly code: 6041;
1241
- readonly name: "TimelockActive";
1242
- readonly msg: "Vault has timelock active — use queue_policy_update instead";
1243
- }, {
1244
- readonly code: 6042;
1245
- readonly name: "NoTimelockConfigured";
1246
- readonly msg: "No timelock configured on this vault";
1247
- }, {
1248
- readonly code: 6043;
1249
- readonly name: "DestinationNotAllowed";
1250
- readonly msg: "Destination not in allowed list";
1251
- }, {
1252
- readonly code: 6044;
1253
- readonly name: "TooManyDestinations";
1254
- readonly msg: "Too many destinations (max 10)";
1255
- }, {
1256
- readonly code: 6045;
1257
- readonly name: "InvalidTrackerTier";
1258
- readonly msg: "Invalid tracker tier (must be 0, 1, or 2)";
1259
- }];
1260
- readonly types: readonly [{
1261
- readonly name: "ActionAuthorized";
1262
- readonly type: {
1263
- readonly kind: "struct";
1264
- readonly fields: readonly [{
1265
- readonly name: "vault";
1266
- readonly type: "pubkey";
1267
- }, {
1268
- readonly name: "agent";
1269
- readonly type: "pubkey";
1270
- }, {
1271
- readonly name: "action_type";
1272
- readonly type: {
1273
- readonly defined: {
1274
- readonly name: "ActionType";
896
+ option?: undefined;
897
+ };
898
+ } | {
899
+ name: string;
900
+ type: string;
901
+ } | {
902
+ name: string;
903
+ type: {
904
+ option: string;
905
+ defined?: undefined;
906
+ };
907
+ })[];
908
+ })[];
909
+ accounts: {
910
+ name: string;
911
+ discriminator: number[];
912
+ }[];
913
+ events: {
914
+ name: string;
915
+ discriminator: number[];
916
+ }[];
917
+ errors: {
918
+ code: number;
919
+ name: string;
920
+ msg: string;
921
+ }[];
922
+ types: ({
923
+ name: string;
924
+ type: {
925
+ kind: string;
926
+ fields: ({
927
+ name: string;
928
+ type: string;
929
+ } | {
930
+ name: string;
931
+ type: {
932
+ defined: {
933
+ name: string;
1275
934
  };
935
+ option?: undefined;
1276
936
  };
1277
- }, {
1278
- readonly name: "token_mint";
1279
- readonly type: "pubkey";
1280
- }, {
1281
- readonly name: "amount";
1282
- readonly type: "u64";
1283
- }, {
1284
- readonly name: "usd_amount";
1285
- readonly type: "u64";
1286
- }, {
1287
- readonly name: "protocol";
1288
- readonly type: "pubkey";
1289
- }, {
1290
- readonly name: "rolling_spend_usd_after";
1291
- readonly type: "u64";
1292
- }, {
1293
- readonly name: "daily_cap_usd";
1294
- readonly type: "u64";
1295
- }, {
1296
- readonly name: "delegated";
1297
- readonly type: "bool";
1298
- }, {
1299
- readonly name: "oracle_price";
1300
- readonly type: {
1301
- readonly option: "i128";
937
+ } | {
938
+ name: string;
939
+ type: {
940
+ option: string;
941
+ defined?: undefined;
1302
942
  };
1303
- }, {
1304
- readonly name: "oracle_source";
1305
- readonly type: {
1306
- readonly option: "u8";
1307
- };
1308
- }, {
1309
- readonly name: "timestamp";
1310
- readonly type: "i64";
1311
- }];
1312
- };
1313
- }, {
1314
- readonly name: "ActionDenied";
1315
- readonly type: {
1316
- readonly kind: "struct";
1317
- readonly fields: readonly [{
1318
- readonly name: "vault";
1319
- readonly type: "pubkey";
1320
- }, {
1321
- readonly name: "agent";
1322
- readonly type: "pubkey";
1323
- }, {
1324
- readonly name: "reason";
1325
- readonly type: "string";
1326
- }, {
1327
- readonly name: "timestamp";
1328
- readonly type: "i64";
1329
- }];
1330
- };
1331
- }, {
1332
- readonly name: "ActionType";
1333
- readonly docs: readonly ["Action types that agents can request"];
1334
- readonly type: {
1335
- readonly kind: "enum";
1336
- readonly variants: readonly [{
1337
- readonly name: "Swap";
1338
- }, {
1339
- readonly name: "OpenPosition";
1340
- }, {
1341
- readonly name: "ClosePosition";
1342
- }, {
1343
- readonly name: "IncreasePosition";
1344
- }, {
1345
- readonly name: "DecreasePosition";
1346
- }, {
1347
- readonly name: "Deposit";
1348
- }, {
1349
- readonly name: "Withdraw";
1350
- }, {
1351
- readonly name: "Transfer";
1352
- }];
1353
- };
1354
- }, {
1355
- readonly name: "AgentRegistered";
1356
- readonly type: {
1357
- readonly kind: "struct";
1358
- readonly fields: readonly [{
1359
- readonly name: "vault";
1360
- readonly type: "pubkey";
1361
- }, {
1362
- readonly name: "agent";
1363
- readonly type: "pubkey";
1364
- }, {
1365
- readonly name: "timestamp";
1366
- readonly type: "i64";
1367
- }];
1368
- };
1369
- }, {
1370
- readonly name: "AgentRevoked";
1371
- readonly type: {
1372
- readonly kind: "struct";
1373
- readonly fields: readonly [{
1374
- readonly name: "vault";
1375
- readonly type: "pubkey";
1376
- }, {
1377
- readonly name: "agent";
1378
- readonly type: "pubkey";
1379
- }, {
1380
- readonly name: "timestamp";
1381
- readonly type: "i64";
1382
- }];
943
+ })[];
944
+ variants?: undefined;
1383
945
  };
1384
- }, {
1385
- readonly name: "AgentTransferExecuted";
1386
- readonly type: {
1387
- readonly kind: "struct";
1388
- readonly fields: readonly [{
1389
- readonly name: "vault";
1390
- readonly type: "pubkey";
1391
- }, {
1392
- readonly name: "destination";
1393
- readonly type: "pubkey";
1394
- }, {
1395
- readonly name: "amount";
1396
- readonly type: "u64";
1397
- }, {
1398
- readonly name: "mint";
1399
- readonly type: "pubkey";
1400
- }];
946
+ docs?: undefined;
947
+ serialization?: undefined;
948
+ repr?: undefined;
949
+ } | {
950
+ name: string;
951
+ docs: string[];
952
+ type: {
953
+ kind: string;
954
+ variants: {
955
+ name: string;
956
+ }[];
957
+ fields?: undefined;
1401
958
  };
1402
- }, {
1403
- readonly name: "AgentVault";
1404
- readonly type: {
1405
- readonly kind: "struct";
1406
- readonly fields: readonly [{
1407
- readonly name: "owner";
1408
- readonly docs: readonly ["The owner who created this vault (has full authority)"];
1409
- readonly type: "pubkey";
1410
- }, {
1411
- readonly name: "agent";
1412
- readonly docs: readonly ["The registered agent's signing key (Pubkey::default() if not yet registered)"];
1413
- readonly type: "pubkey";
1414
- }, {
1415
- readonly name: "fee_destination";
1416
- readonly docs: readonly ["Developer fee destination — the wallet that receives developer fees", "on every finalized transaction. IMMUTABLE after initialization — only", "`initialize_vault` writes this field. This prevents a compromised owner", "key from redirecting fees. Protocol fees go to PROTOCOL_TREASURY separately."];
1417
- readonly type: "pubkey";
1418
- }, {
1419
- readonly name: "vault_id";
1420
- readonly docs: readonly ["Unique vault identifier (allows one owner to have multiple vaults)"];
1421
- readonly type: "u64";
1422
- }, {
1423
- readonly name: "status";
1424
- readonly docs: readonly ["Vault status: Active, Frozen, or Closed"];
1425
- readonly type: {
1426
- readonly defined: {
1427
- readonly name: "VaultStatus";
1428
- };
1429
- };
1430
- }, {
1431
- readonly name: "bump";
1432
- readonly docs: readonly ["Bump seed for PDA derivation"];
1433
- readonly type: "u8";
1434
- }, {
1435
- readonly name: "created_at";
1436
- readonly docs: readonly ["Unix timestamp of vault creation"];
1437
- readonly type: "i64";
1438
- }, {
1439
- readonly name: "total_transactions";
1440
- readonly docs: readonly ["Total number of agent transactions executed through this vault"];
1441
- readonly type: "u64";
1442
- }, {
1443
- readonly name: "total_volume";
1444
- readonly docs: readonly ["Total volume processed in token base units"];
1445
- readonly type: "u64";
1446
- }, {
1447
- readonly name: "open_positions";
1448
- readonly docs: readonly ["Number of currently open positions (for perps tracking)"];
1449
- readonly type: "u8";
1450
- }, {
1451
- readonly name: "total_fees_collected";
1452
- readonly docs: readonly ["Cumulative developer fees collected from this vault (token base units).", "Protocol fees are tracked separately via events."];
1453
- readonly type: "u64";
1454
- }, {
1455
- readonly name: "tracker_tier";
1456
- readonly docs: readonly ["Tracker capacity tier chosen at vault creation"];
1457
- readonly type: {
1458
- readonly defined: {
1459
- readonly name: "TrackerTier";
1460
- };
1461
- };
1462
- }];
1463
- };
1464
- }, {
1465
- readonly name: "AllowedToken";
1466
- readonly docs: readonly ["Per-token configuration including oracle feed and per-token caps.", "Replaces the old `Vec<Pubkey>` allowed_tokens with richer metadata.", "", "Oracle feed classification:", "- `Pubkey::default()` = stablecoin (1:1 USD, no oracle needed)", "- `UNPRICED_SENTINEL` ([0xFF; 32]) = unpriced token (receive-only)", "- Any other pubkey = Oracle feed account (Pyth PriceUpdateV2 or Switchboard PullFeed)"];
1467
- readonly type: {
1468
- readonly kind: "struct";
1469
- readonly fields: readonly [{
1470
- readonly name: "mint";
1471
- readonly docs: readonly ["Token mint address"];
1472
- readonly type: "pubkey";
1473
- }, {
1474
- readonly name: "oracle_feed";
1475
- readonly docs: readonly ["Oracle feed account (Pyth PriceUpdateV2 or Switchboard PullFeed) for USD pricing.", "`Pubkey::default()` = stablecoin (1:1 USD).", "`UNPRICED_SENTINEL` = unpriced (receive-only, cannot be spent)."];
1476
- readonly type: "pubkey";
1477
- }, {
1478
- readonly name: "decimals";
1479
- readonly docs: readonly ["Token decimals (e.g., 6 for USDC, 9 for SOL)"];
1480
- readonly type: "u8";
1481
- }, {
1482
- readonly name: "daily_cap_base";
1483
- readonly docs: readonly ["Per-token daily cap in base units (0 = no per-token limit,", "only the aggregate USD cap applies)"];
1484
- readonly type: "u64";
1485
- }, {
1486
- readonly name: "max_tx_base";
1487
- readonly docs: readonly ["Per-token max single transaction in base units", "(0 = no per-token tx limit, only USD tx limit applies)"];
1488
- readonly type: "u64";
1489
- }];
1490
- };
1491
- }, {
1492
- readonly name: "DelegationRevoked";
1493
- readonly type: {
1494
- readonly kind: "struct";
1495
- readonly fields: readonly [{
1496
- readonly name: "vault";
1497
- readonly type: "pubkey";
1498
- }, {
1499
- readonly name: "token_account";
1500
- readonly type: "pubkey";
1501
- }, {
1502
- readonly name: "timestamp";
1503
- readonly type: "i64";
1504
- }];
1505
- };
1506
- }, {
1507
- readonly name: "FeesCollected";
1508
- readonly type: {
1509
- readonly kind: "struct";
1510
- readonly fields: readonly [{
1511
- readonly name: "vault";
1512
- readonly type: "pubkey";
1513
- }, {
1514
- readonly name: "token_mint";
1515
- readonly type: "pubkey";
1516
- }, {
1517
- readonly name: "protocol_fee_amount";
1518
- readonly type: "u64";
1519
- }, {
1520
- readonly name: "developer_fee_amount";
1521
- readonly type: "u64";
1522
- }, {
1523
- readonly name: "protocol_fee_rate";
1524
- readonly type: "u16";
1525
- }, {
1526
- readonly name: "developer_fee_rate";
1527
- readonly type: "u16";
1528
- }, {
1529
- readonly name: "transaction_amount";
1530
- readonly type: "u64";
1531
- }, {
1532
- readonly name: "protocol_treasury";
1533
- readonly type: "pubkey";
1534
- }, {
1535
- readonly name: "developer_fee_destination";
1536
- readonly type: "pubkey";
1537
- }, {
1538
- readonly name: "cumulative_developer_fees";
1539
- readonly type: "u64";
1540
- }, {
1541
- readonly name: "timestamp";
1542
- readonly type: "i64";
1543
- }];
1544
- };
1545
- }, {
1546
- readonly name: "FundsDeposited";
1547
- readonly type: {
1548
- readonly kind: "struct";
1549
- readonly fields: readonly [{
1550
- readonly name: "vault";
1551
- readonly type: "pubkey";
1552
- }, {
1553
- readonly name: "token_mint";
1554
- readonly type: "pubkey";
1555
- }, {
1556
- readonly name: "amount";
1557
- readonly type: "u64";
1558
- }, {
1559
- readonly name: "timestamp";
1560
- readonly type: "i64";
1561
- }];
1562
- };
1563
- }, {
1564
- readonly name: "FundsWithdrawn";
1565
- readonly type: {
1566
- readonly kind: "struct";
1567
- readonly fields: readonly [{
1568
- readonly name: "vault";
1569
- readonly type: "pubkey";
1570
- }, {
1571
- readonly name: "token_mint";
1572
- readonly type: "pubkey";
1573
- }, {
1574
- readonly name: "amount";
1575
- readonly type: "u64";
1576
- }, {
1577
- readonly name: "destination";
1578
- readonly type: "pubkey";
1579
- }, {
1580
- readonly name: "timestamp";
1581
- readonly type: "i64";
1582
- }];
1583
- };
1584
- }, {
1585
- readonly name: "PendingPolicyUpdate";
1586
- readonly docs: readonly ["Queued policy update that becomes executable after a timelock period.", "Created by `queue_policy_update`, applied by `apply_pending_policy`,", "or cancelled by `cancel_pending_policy`.", "", "PDA seeds: `[b\"pending_policy\", vault.key().as_ref()]`"];
1587
- readonly type: {
1588
- readonly kind: "struct";
1589
- readonly fields: readonly [{
1590
- readonly name: "vault";
1591
- readonly docs: readonly ["Associated vault pubkey"];
1592
- readonly type: "pubkey";
1593
- }, {
1594
- readonly name: "queued_at";
1595
- readonly docs: readonly ["Unix timestamp when this update was queued"];
1596
- readonly type: "i64";
1597
- }, {
1598
- readonly name: "executes_at";
1599
- readonly docs: readonly ["Unix timestamp when this update becomes executable"];
1600
- readonly type: "i64";
1601
- }, {
1602
- readonly name: "daily_spending_cap_usd";
1603
- readonly type: {
1604
- readonly option: "u64";
1605
- };
1606
- }, {
1607
- readonly name: "max_transaction_amount_usd";
1608
- readonly type: {
1609
- readonly option: "u64";
1610
- };
1611
- }, {
1612
- readonly name: "allowed_tokens";
1613
- readonly type: {
1614
- readonly option: {
1615
- readonly vec: {
1616
- readonly defined: {
1617
- readonly name: "AllowedToken";
1618
- };
959
+ serialization?: undefined;
960
+ repr?: undefined;
961
+ } | {
962
+ name: string;
963
+ docs: string[];
964
+ type: {
965
+ kind: string;
966
+ fields: ({
967
+ name: string;
968
+ docs: string[];
969
+ type: string;
970
+ } | {
971
+ name: string;
972
+ docs: string[];
973
+ type: {
974
+ vec: {
975
+ defined: {
976
+ name: string;
1619
977
  };
1620
978
  };
1621
979
  };
1622
- }, {
1623
- readonly name: "allowed_protocols";
1624
- readonly type: {
1625
- readonly option: {
1626
- readonly vec: "pubkey";
1627
- };
1628
- };
1629
- }, {
1630
- readonly name: "max_leverage_bps";
1631
- readonly type: {
1632
- readonly option: "u16";
1633
- };
1634
- }, {
1635
- readonly name: "can_open_positions";
1636
- readonly type: {
1637
- readonly option: "bool";
1638
- };
1639
- }, {
1640
- readonly name: "max_concurrent_positions";
1641
- readonly type: {
1642
- readonly option: "u8";
1643
- };
1644
- }, {
1645
- readonly name: "developer_fee_rate";
1646
- readonly type: {
1647
- readonly option: "u16";
1648
- };
1649
- }, {
1650
- readonly name: "timelock_duration";
1651
- readonly type: {
1652
- readonly option: "u64";
980
+ })[];
981
+ variants?: undefined;
982
+ };
983
+ serialization?: undefined;
984
+ repr?: undefined;
985
+ } | {
986
+ name: string;
987
+ docs: string[];
988
+ type: {
989
+ kind: string;
990
+ fields: ({
991
+ name: string;
992
+ docs: string[];
993
+ type: string;
994
+ } | {
995
+ name: string;
996
+ type: {
997
+ option: string;
1653
998
  };
1654
- }, {
1655
- readonly name: "allowed_destinations";
1656
- readonly type: {
1657
- readonly option: {
1658
- readonly vec: "pubkey";
999
+ docs?: undefined;
1000
+ } | {
1001
+ name: string;
1002
+ type: {
1003
+ option: {
1004
+ vec: string;
1659
1005
  };
1660
1006
  };
1661
- }, {
1662
- readonly name: "bump";
1663
- readonly docs: readonly ["Bump seed for PDA"];
1664
- readonly type: "u8";
1665
- }];
1666
- };
1667
- }, {
1668
- readonly name: "PolicyChangeApplied";
1669
- readonly type: {
1670
- readonly kind: "struct";
1671
- readonly fields: readonly [{
1672
- readonly name: "vault";
1673
- readonly type: "pubkey";
1674
- }, {
1675
- readonly name: "applied_at";
1676
- readonly type: "i64";
1677
- }];
1678
- };
1679
- }, {
1680
- readonly name: "PolicyChangeCancelled";
1681
- readonly type: {
1682
- readonly kind: "struct";
1683
- readonly fields: readonly [{
1684
- readonly name: "vault";
1685
- readonly type: "pubkey";
1686
- }];
1007
+ docs?: undefined;
1008
+ })[];
1009
+ variants?: undefined;
1687
1010
  };
1688
- }, {
1689
- readonly name: "PolicyChangeQueued";
1690
- readonly type: {
1691
- readonly kind: "struct";
1692
- readonly fields: readonly [{
1693
- readonly name: "vault";
1694
- readonly type: "pubkey";
1695
- }, {
1696
- readonly name: "executes_at";
1697
- readonly type: "i64";
1698
- }];
1699
- };
1700
- }, {
1701
- readonly name: "PolicyConfig";
1702
- readonly type: {
1703
- readonly kind: "struct";
1704
- readonly fields: readonly [{
1705
- readonly name: "vault";
1706
- readonly docs: readonly ["Associated vault pubkey"];
1707
- readonly type: "pubkey";
1708
- }, {
1709
- readonly name: "daily_spending_cap_usd";
1710
- readonly docs: readonly ["Maximum aggregate spend per rolling 24h period in USD (6 decimals).", "$500 = 500_000_000. This is the primary spending cap."];
1711
- readonly type: "u64";
1712
- }, {
1713
- readonly name: "max_transaction_size_usd";
1714
- readonly docs: readonly ["Maximum single transaction size in USD (6 decimals)."];
1715
- readonly type: "u64";
1716
- }, {
1717
- readonly name: "allowed_tokens";
1718
- readonly docs: readonly ["Allowed token mints with oracle feeds and per-token caps.", "Bounded to MAX_ALLOWED_TOKENS entries."];
1719
- readonly type: {
1720
- readonly vec: {
1721
- readonly defined: {
1722
- readonly name: "AllowedToken";
1723
- };
1724
- };
1725
- };
1726
- }, {
1727
- readonly name: "allowed_protocols";
1728
- readonly docs: readonly ["Allowed program IDs the agent can call (Jupiter, Flash Trade, etc.)", "Bounded to MAX_ALLOWED_PROTOCOLS entries"];
1729
- readonly type: {
1730
- readonly vec: "pubkey";
1011
+ serialization?: undefined;
1012
+ repr?: undefined;
1013
+ } | {
1014
+ name: string;
1015
+ type: {
1016
+ kind: string;
1017
+ fields: ({
1018
+ name: string;
1019
+ docs: string[];
1020
+ type: string;
1021
+ } | {
1022
+ name: string;
1023
+ docs: string[];
1024
+ type: {
1025
+ vec: string;
1731
1026
  };
1732
- }, {
1733
- readonly name: "max_leverage_bps";
1734
- readonly docs: readonly ["Maximum leverage multiplier in basis points (e.g., 10000 = 100x, 1000 = 10x)", "Set to 0 to disallow leveraged positions entirely"];
1735
- readonly type: "u16";
1736
- }, {
1737
- readonly name: "can_open_positions";
1738
- readonly docs: readonly ["Whether the agent can open new positions (vs only close existing)"];
1739
- readonly type: "bool";
1740
- }, {
1741
- readonly name: "max_concurrent_positions";
1742
- readonly docs: readonly ["Maximum number of concurrent open positions"];
1743
- readonly type: "u8";
1744
- }, {
1745
- readonly name: "developer_fee_rate";
1746
- readonly docs: readonly ["Developer fee rate (rate / 1,000,000). Applied to every finalized", "transaction. Fee deducted from vault, transferred to vault's", "fee_destination. Max MAX_DEVELOPER_FEE_RATE (500 = 5 BPS).", "Set to 0 for no developer fee. Protocol fee is always applied", "separately at PROTOCOL_FEE_RATE."];
1747
- readonly type: "u16";
1748
- }, {
1749
- readonly name: "timelock_duration";
1750
- readonly docs: readonly ["Timelock duration in seconds for policy changes. 0 = no timelock", "(immediate updates allowed). When > 0, policy changes must go", "through queue_policy_update → apply_pending_policy."];
1751
- readonly type: "u64";
1752
- }, {
1753
- readonly name: "allowed_destinations";
1754
- readonly docs: readonly ["Allowed destination addresses for agent transfers.", "Empty = any destination allowed. Bounded to MAX_ALLOWED_DESTINATIONS."];
1755
- readonly type: {
1756
- readonly vec: "pubkey";
1757
- };
1758
- }, {
1759
- readonly name: "bump";
1760
- readonly docs: readonly ["Bump seed for PDA"];
1761
- readonly type: "u8";
1762
- }];
1763
- };
1764
- }, {
1765
- readonly name: "PolicyUpdated";
1766
- readonly type: {
1767
- readonly kind: "struct";
1768
- readonly fields: readonly [{
1769
- readonly name: "vault";
1770
- readonly type: "pubkey";
1771
- }, {
1772
- readonly name: "daily_cap_usd";
1773
- readonly type: "u64";
1774
- }, {
1775
- readonly name: "max_transaction_size_usd";
1776
- readonly type: "u64";
1777
- }, {
1778
- readonly name: "allowed_tokens_count";
1779
- readonly type: "u8";
1780
- }, {
1781
- readonly name: "allowed_protocols_count";
1782
- readonly type: "u8";
1783
- }, {
1784
- readonly name: "max_leverage_bps";
1785
- readonly type: "u16";
1786
- }, {
1787
- readonly name: "developer_fee_rate";
1788
- readonly type: "u16";
1789
- }, {
1790
- readonly name: "timestamp";
1791
- readonly type: "i64";
1792
- }];
1027
+ })[];
1028
+ variants?: undefined;
1793
1029
  };
1794
- }, {
1795
- readonly name: "SessionAuthority";
1796
- readonly type: {
1797
- readonly kind: "struct";
1798
- readonly fields: readonly [{
1799
- readonly name: "vault";
1800
- readonly docs: readonly ["Associated vault"];
1801
- readonly type: "pubkey";
1802
- }, {
1803
- readonly name: "agent";
1804
- readonly docs: readonly ["The agent who initiated this session"];
1805
- readonly type: "pubkey";
1806
- }, {
1807
- readonly name: "authorized";
1808
- readonly docs: readonly ["Whether this session has been authorized by the permission check"];
1809
- readonly type: "bool";
1810
- }, {
1811
- readonly name: "authorized_amount";
1812
- readonly docs: readonly ["Authorized action details (for verification in finalize)"];
1813
- readonly type: "u64";
1814
- }, {
1815
- readonly name: "authorized_token";
1816
- readonly type: "pubkey";
1817
- }, {
1818
- readonly name: "authorized_protocol";
1819
- readonly type: "pubkey";
1820
- }, {
1821
- readonly name: "action_type";
1822
- readonly docs: readonly ["The action type that was authorized (stored so finalize can record it)"];
1823
- readonly type: {
1824
- readonly defined: {
1825
- readonly name: "ActionType";
1030
+ docs?: undefined;
1031
+ serialization?: undefined;
1032
+ repr?: undefined;
1033
+ } | {
1034
+ name: string;
1035
+ type: {
1036
+ kind: string;
1037
+ fields: ({
1038
+ name: string;
1039
+ docs: string[];
1040
+ type: string;
1041
+ } | {
1042
+ name: string;
1043
+ type: string;
1044
+ docs?: undefined;
1045
+ } | {
1046
+ name: string;
1047
+ docs: string[];
1048
+ type: {
1049
+ defined: {
1050
+ name: string;
1826
1051
  };
1827
1052
  };
1828
- }, {
1829
- readonly name: "expires_at_slot";
1830
- readonly docs: readonly ["Slot-based expiry: session is valid until this slot"];
1831
- readonly type: "u64";
1832
- }, {
1833
- readonly name: "delegated";
1834
- readonly docs: readonly ["Whether token delegation was set up (approve CPI)"];
1835
- readonly type: "bool";
1836
- }, {
1837
- readonly name: "delegation_token_account";
1838
- readonly docs: readonly ["The vault's token account that was delegated to the agent", "(only meaningful when delegated == true)"];
1839
- readonly type: "pubkey";
1840
- }, {
1841
- readonly name: "bump";
1842
- readonly docs: readonly ["Bump seed for PDA"];
1843
- readonly type: "u8";
1844
- }];
1845
- };
1846
- }, {
1847
- readonly name: "SessionFinalized";
1848
- readonly type: {
1849
- readonly kind: "struct";
1850
- readonly fields: readonly [{
1851
- readonly name: "vault";
1852
- readonly type: "pubkey";
1853
- }, {
1854
- readonly name: "agent";
1855
- readonly type: "pubkey";
1856
- }, {
1857
- readonly name: "success";
1858
- readonly type: "bool";
1859
- }, {
1860
- readonly name: "is_expired";
1861
- readonly type: "bool";
1862
- }, {
1863
- readonly name: "timestamp";
1864
- readonly type: "i64";
1865
- }];
1053
+ })[];
1054
+ variants?: undefined;
1866
1055
  };
1867
- }, {
1868
- readonly name: "SpendEntry";
1869
- readonly type: {
1870
- readonly kind: "struct";
1871
- readonly fields: readonly [{
1872
- readonly name: "token_index";
1873
- readonly docs: readonly ["Index into PolicyConfig.allowed_tokens[] (0-9).", "Compact representation — avoids storing full 32-byte Pubkey per entry.", "Invalidated when token list changes (rolling_spends is cleared)."];
1874
- readonly type: "u8";
1875
- }, {
1876
- readonly name: "usd_amount";
1877
- readonly docs: readonly ["USD value of this spend (6 decimals, e.g., $500 = 500_000_000)"];
1878
- readonly type: "u64";
1879
- }, {
1880
- readonly name: "base_amount";
1881
- readonly docs: readonly ["Original amount in token base units (for per-token cap checks)"];
1882
- readonly type: "u64";
1883
- }, {
1884
- readonly name: "timestamp";
1885
- readonly type: "i64";
1886
- }];
1056
+ docs?: undefined;
1057
+ serialization?: undefined;
1058
+ repr?: undefined;
1059
+ } | {
1060
+ name: string;
1061
+ docs: string[];
1062
+ serialization: string;
1063
+ repr: {
1064
+ kind: string;
1887
1065
  };
1888
- }, {
1889
- readonly name: "SpendTracker";
1890
- readonly type: {
1891
- readonly kind: "struct";
1892
- readonly fields: readonly [{
1893
- readonly name: "vault";
1894
- readonly docs: readonly ["Associated vault pubkey"];
1895
- readonly type: "pubkey";
1896
- }, {
1897
- readonly name: "tracker_tier";
1898
- readonly docs: readonly ["Tracker capacity tier (Standard/Pro/Max)"];
1899
- readonly type: {
1900
- readonly defined: {
1901
- readonly name: "TrackerTier";
1902
- };
1903
- };
1904
- }, {
1905
- readonly name: "max_spend_entries";
1906
- readonly docs: readonly ["Maximum spend entries for this tracker (derived from tier at init)"];
1907
- readonly type: "u32";
1908
- }, {
1909
- readonly name: "rolling_spends";
1910
- readonly docs: readonly ["Rolling spend entries: (token_mint, usd_amount, base_amount, timestamp)", "Entries older than ROLLING_WINDOW_SECONDS are pruned on each access"];
1911
- readonly type: {
1912
- readonly vec: {
1913
- readonly defined: {
1914
- readonly name: "SpendEntry";
1066
+ type: {
1067
+ kind: string;
1068
+ fields: ({
1069
+ name: string;
1070
+ docs: string[];
1071
+ type: string;
1072
+ } | {
1073
+ name: string;
1074
+ docs: string[];
1075
+ type: {
1076
+ array: (number | {
1077
+ defined: {
1078
+ name: string;
1915
1079
  };
1916
- };
1917
- };
1918
- }, {
1919
- readonly name: "recent_transactions";
1920
- readonly docs: readonly ["Recent transaction log for on-chain audit trail", "Bounded to MAX_RECENT_TRANSACTIONS, oldest entries evicted (ring buffer)"];
1921
- readonly type: {
1922
- readonly vec: {
1923
- readonly defined: {
1924
- readonly name: "TransactionRecord";
1925
- };
1926
- };
1927
- };
1928
- }, {
1929
- readonly name: "bump";
1930
- readonly docs: readonly ["Bump seed for PDA"];
1931
- readonly type: "u8";
1932
- }];
1933
- };
1934
- }, {
1935
- readonly name: "TrackerTier";
1936
- readonly docs: readonly ["Tracker capacity tiers — chosen at vault creation, determines", "max rolling spend entries and SpendTracker account size."];
1937
- readonly type: {
1938
- readonly kind: "enum";
1939
- readonly variants: readonly [{
1940
- readonly name: "Standard";
1941
- }, {
1942
- readonly name: "Pro";
1943
- }, {
1944
- readonly name: "Max";
1945
- }];
1946
- };
1947
- }, {
1948
- readonly name: "TransactionRecord";
1949
- readonly type: {
1950
- readonly kind: "struct";
1951
- readonly fields: readonly [{
1952
- readonly name: "timestamp";
1953
- readonly type: "i64";
1954
- }, {
1955
- readonly name: "action_type";
1956
- readonly type: {
1957
- readonly defined: {
1958
- readonly name: "ActionType";
1959
- };
1080
+ })[];
1960
1081
  };
1961
- }, {
1962
- readonly name: "token_mint";
1963
- readonly type: "pubkey";
1964
- }, {
1965
- readonly name: "amount";
1966
- readonly type: "u64";
1967
- }, {
1968
- readonly name: "protocol";
1969
- readonly type: "pubkey";
1970
- }, {
1971
- readonly name: "success";
1972
- readonly type: "bool";
1973
- }, {
1974
- readonly name: "slot";
1975
- readonly type: "u64";
1976
- }];
1977
- };
1978
- }, {
1979
- readonly name: "VaultClosed";
1980
- readonly type: {
1981
- readonly kind: "struct";
1982
- readonly fields: readonly [{
1983
- readonly name: "vault";
1984
- readonly type: "pubkey";
1985
- }, {
1986
- readonly name: "owner";
1987
- readonly type: "pubkey";
1988
- }, {
1989
- readonly name: "timestamp";
1990
- readonly type: "i64";
1991
- }];
1992
- };
1993
- }, {
1994
- readonly name: "VaultCreated";
1995
- readonly type: {
1996
- readonly kind: "struct";
1997
- readonly fields: readonly [{
1998
- readonly name: "vault";
1999
- readonly type: "pubkey";
2000
- }, {
2001
- readonly name: "owner";
2002
- readonly type: "pubkey";
2003
- }, {
2004
- readonly name: "vault_id";
2005
- readonly type: "u64";
2006
- }, {
2007
- readonly name: "timestamp";
2008
- readonly type: "i64";
2009
- }];
2010
- };
2011
- }, {
2012
- readonly name: "VaultReactivated";
2013
- readonly type: {
2014
- readonly kind: "struct";
2015
- readonly fields: readonly [{
2016
- readonly name: "vault";
2017
- readonly type: "pubkey";
2018
- }, {
2019
- readonly name: "new_agent";
2020
- readonly type: {
2021
- readonly option: "pubkey";
1082
+ } | {
1083
+ name: string;
1084
+ docs: string[];
1085
+ type: {
1086
+ array: (string | number)[];
2022
1087
  };
2023
- }, {
2024
- readonly name: "timestamp";
2025
- readonly type: "i64";
2026
- }];
2027
- };
2028
- }, {
2029
- readonly name: "VaultStatus";
2030
- readonly docs: readonly ["Vault status enum"];
2031
- readonly type: {
2032
- readonly kind: "enum";
2033
- readonly variants: readonly [{
2034
- readonly name: "Active";
2035
- }, {
2036
- readonly name: "Frozen";
2037
- }, {
2038
- readonly name: "Closed";
2039
- }];
1088
+ })[];
1089
+ variants?: undefined;
2040
1090
  };
2041
- }];
1091
+ })[];
2042
1092
  };
2043
1093
  //# sourceMappingURL=idl-json.d.ts.map