presign-guard-wallet 0.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/LICENSE +21 -0
- package/README.md +80 -0
- package/index.d.ts +49 -0
- package/index.js +149 -0
- package/package.json +56 -0
package/LICENSE
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
MIT License
|
|
2
|
+
|
|
3
|
+
Copyright (c) 2026 Frits Zwager
|
|
4
|
+
|
|
5
|
+
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
6
|
+
of this software and associated documentation files (the "Software"), to deal
|
|
7
|
+
in the Software without restriction, including without limitation the rights
|
|
8
|
+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
9
|
+
copies of the Software, and to permit persons to whom the Software is
|
|
10
|
+
furnished to do so, subject to the following conditions:
|
|
11
|
+
|
|
12
|
+
The above copyright notice and this permission notice shall be included in all
|
|
13
|
+
copies or substantial portions of the Software.
|
|
14
|
+
|
|
15
|
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
16
|
+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
17
|
+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
18
|
+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
19
|
+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
20
|
+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
21
|
+
SOFTWARE.
|
package/README.md
ADDED
|
@@ -0,0 +1,80 @@
|
|
|
1
|
+
# presign-guard-wallet
|
|
2
|
+
|
|
3
|
+
A [viem](https://viem.sh) wallet for AI agents that asks [presign-guard](https://presign-guard.fizzl.eu) before it signs.
|
|
4
|
+
|
|
5
|
+
Before every `sendTransaction`, `writeContract` and `signTypedData`, the wallet pays **$0.01** (x402, USDC on Base) for a verdict on exactly what is about to be signed, and acts on it:
|
|
6
|
+
|
|
7
|
+
| Verdict | What the wallet does |
|
|
8
|
+
|---|---|
|
|
9
|
+
| 🟢 green | Signs |
|
|
10
|
+
| 🟠orange | `onOrange`: `"stop"` (default, throws), `"allow"`, or your own function (e.g. ask the user) |
|
|
11
|
+
| 🔴 red | Throws `PresignBlockedError` with the reasons; **nothing is signed** |
|
|
12
|
+
|
|
13
|
+
presign-guard decodes approvals, `increaseAllowance`, `setApprovalForAll`, EIP-2612 and Permit2 permits, EIP-3009 transfer authorizations (what an x402 payment signs) and Seaport orders, and screens every spender, recipient and token: known drainers and phishing addresses, sanctions, unlimited approvals to a plain wallet, honeypot tokens, unverified or brand-new contracts, and, with `origin`, new or lookalike domains and phishing sites. See the [reason codes](https://github.com/Fizzl13/presign-guard#reason-codes).
|
|
14
|
+
|
|
15
|
+
## Install
|
|
16
|
+
|
|
17
|
+
```sh
|
|
18
|
+
npm install presign-guard-wallet viem @x402/fetch @x402/evm
|
|
19
|
+
```
|
|
20
|
+
|
|
21
|
+
## Use
|
|
22
|
+
|
|
23
|
+
```js
|
|
24
|
+
import { createWalletClient, http } from "viem";
|
|
25
|
+
import { base } from "viem/chains";
|
|
26
|
+
import { privateKeyToAccount } from "viem/accounts";
|
|
27
|
+
import { wrapFetchWithPayment, x402Client } from "@x402/fetch";
|
|
28
|
+
import { ExactEvmScheme } from "@x402/evm/exact/client";
|
|
29
|
+
import { guardWallet, PresignBlockedError } from "presign-guard-wallet";
|
|
30
|
+
|
|
31
|
+
const account = privateKeyToAccount(process.env.AGENT_KEY); // the agent's wallet
|
|
32
|
+
const walletClient = createWalletClient({ account, chain: base, transport: http() });
|
|
33
|
+
|
|
34
|
+
// Pays for the checks: a few dollars of USDC on Base, capped per payment.
|
|
35
|
+
const payer = new x402Client().setSpendControls({ maxAmountPerPayment: "$0.02" });
|
|
36
|
+
payer.register("eip155:8453", new ExactEvmScheme(privateKeyToAccount(process.env.PAYER_KEY)));
|
|
37
|
+
const pay = wrapFetchWithPayment(fetch, payer);
|
|
38
|
+
|
|
39
|
+
const wallet = guardWallet(walletClient, { pay, onOrange: "stop" });
|
|
40
|
+
|
|
41
|
+
try {
|
|
42
|
+
await wallet.writeContract({ address: token, abi: erc20Abi, functionName: "approve", args: [spender, amount] });
|
|
43
|
+
} catch (err) {
|
|
44
|
+
if (err instanceof PresignBlockedError) console.log(err.code, err.message, err.verdict?.reasons);
|
|
45
|
+
else throw err;
|
|
46
|
+
}
|
|
47
|
+
```
|
|
48
|
+
|
|
49
|
+
`wallet` is the same client: every other method (`getAddresses`, `signMessage`, `extend`, …) works as before, unchecked.
|
|
50
|
+
|
|
51
|
+
## Options
|
|
52
|
+
|
|
53
|
+
| Option | Default | |
|
|
54
|
+
|---|---|---|
|
|
55
|
+
| `pay` | required | A fetch that pays x402 (`wrapFetchWithPayment`); cap it with spend controls |
|
|
56
|
+
| `onOrange` | `"stop"` | `"stop"`, `"allow"` or `async (verdict, { method, request }) => boolean` |
|
|
57
|
+
| `onError` | `"stop"` | When the check cannot be done (outage, a chain presign-guard does not cover): `"stop"` or `"allow"` |
|
|
58
|
+
| `origin` | | The site asking for the signature: its domain age and phishing lists are checked too |
|
|
59
|
+
| `onVerdict` | | `(verdict, { method, request }) => void`, e.g. for logging |
|
|
60
|
+
| `verifyReceipts` | `"require"` | Check presign-guard's signed receipt on every verdict; `"off"` skips it |
|
|
61
|
+
| `signers` | presign-guard's published signer | Accepted signer addresses |
|
|
62
|
+
| `authority` | the Fizzl payout wallet | Wallet whose certificates also make a signer trusted (key rotation); `null` accepts only `signers` |
|
|
63
|
+
|
|
64
|
+
Chains: Ethereum (1), Optimism (10), BNB Chain (56), Polygon (137), Base (8453), Arbitrum (42161).
|
|
65
|
+
|
|
66
|
+
## Signed verdicts
|
|
67
|
+
|
|
68
|
+
presign-guard signs every paid verdict (EIP-191 over canonical JSON, with a hash of your request inside the signed body; see [Signed verdicts](https://github.com/Fizzl13/presign-guard#signed-verdicts)). The wallet checks that signature before it acts:
|
|
69
|
+
|
|
70
|
+
- the verdict must be signed by presign-guard's published signer, `0xf084Ea47Ca4D99BB4De3ECB0332b316bE6521EaE` (pinned in the package), or a key the Fizzl payout wallet (`0x6B0F4651eD42893ab58139938175E4a69f175F25`) certified for presign-guard;
|
|
71
|
+
- the signature must cover exactly the request that was checked;
|
|
72
|
+
- otherwise it throws `PresignBlockedError` with code `bad_receipt`, also with `onError: "allow"`: a forged or changed "green" is never a signature.
|
|
73
|
+
|
|
74
|
+
## Costs and limits
|
|
75
|
+
|
|
76
|
+
- $0.01 per checked signature, paid with your `pay` fetch. Calls presign-guard does not cover (`signMessage`, contract deployments) are not checked and cost nothing.
|
|
77
|
+
- presign-guard reads public data (GoPlus, RugCheck, DexScreener, OFAC via PG1, phishing lists). A green verdict means no known problem was found, not a guarantee.
|
|
78
|
+
- The requests carry `user-agent: presign-guard-wallet/<version>` so the service can count how often the package is used.
|
|
79
|
+
|
|
80
|
+
MIT licensed.
|
package/index.d.ts
ADDED
|
@@ -0,0 +1,49 @@
|
|
|
1
|
+
import type { WalletClient } from "viem";
|
|
2
|
+
|
|
3
|
+
export declare const PRESIGN_URL: string;
|
|
4
|
+
export declare const PRESIGN_SIGNERS: string[];
|
|
5
|
+
export declare const SUPPORTED_CHAINS: number[];
|
|
6
|
+
export declare const VERSION: string;
|
|
7
|
+
|
|
8
|
+
/** A presign-guard verdict: see https://presign-guard.fizzl.eu/openapi.json */
|
|
9
|
+
export interface PresignVerdict {
|
|
10
|
+
verdict: "green" | "orange" | "red";
|
|
11
|
+
reasons?: Array<{ code: string; severity: "red" | "orange" | "info"; subject?: string; details?: Record<string, unknown> }>;
|
|
12
|
+
subject?: Record<string, unknown>;
|
|
13
|
+
receipt?: Record<string, unknown>;
|
|
14
|
+
[key: string]: unknown;
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
/** What is sent to presign-guard's POST /v1/check. */
|
|
18
|
+
export type CheckRequest =
|
|
19
|
+
| { type: "transaction"; chainId: number; to: string; data: string; value: string; origin?: string }
|
|
20
|
+
| { type: "signature"; chainId: number; typedData: unknown; origin?: string };
|
|
21
|
+
|
|
22
|
+
export declare class PresignBlockedError extends Error {
|
|
23
|
+
code: "red" | "orange" | "check_failed" | "bad_receipt" | "unsupported_chain";
|
|
24
|
+
verdict: PresignVerdict | null;
|
|
25
|
+
request: CheckRequest | null;
|
|
26
|
+
}
|
|
27
|
+
|
|
28
|
+
export interface GuardOptions {
|
|
29
|
+
/** A fetch that pays x402, e.g. wrapFetchWithPayment(fetch, client) with spend controls. Each check costs $0.01. */
|
|
30
|
+
pay: typeof globalThis.fetch;
|
|
31
|
+
/** What to do on an orange verdict. Default "stop". */
|
|
32
|
+
onOrange?: "stop" | "allow" | ((verdict: PresignVerdict, info: { method: string; request: CheckRequest }) => boolean | Promise<boolean>);
|
|
33
|
+
/** When the check cannot be done (outage, unsupported chain). Default "stop". A forged or changed verdict always stops. */
|
|
34
|
+
onError?: "stop" | "allow";
|
|
35
|
+
/** The site asking for the signature, if any: domain age and phishing lists are checked. */
|
|
36
|
+
origin?: string;
|
|
37
|
+
onVerdict?: (verdict: PresignVerdict, info: { method: string; request: CheckRequest }) => void;
|
|
38
|
+
presignUrl?: string;
|
|
39
|
+
/** Check presign-guard's signed receipt on every verdict. Default "require". */
|
|
40
|
+
verifyReceipts?: "require" | "off";
|
|
41
|
+
/** Accepted signer addresses. Default: the published signer (PRESIGN_SIGNERS). */
|
|
42
|
+
signers?: string[];
|
|
43
|
+
/** Wallet whose certificates also make a signer trusted (key rotation). Default: the Fizzl payout wallet; null accepts only `signers`. */
|
|
44
|
+
authority?: string | null;
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
/** The same wallet client; sendTransaction, writeContract and signTypedData are checked first. */
|
|
48
|
+
export declare function guardWallet<W extends WalletClient>(wallet: W, options: GuardOptions): W;
|
|
49
|
+
export declare function checkRequestFor(method: string, args: unknown, options?: { chainId?: number; origin?: string }): CheckRequest | null;
|
package/index.js
ADDED
|
@@ -0,0 +1,149 @@
|
|
|
1
|
+
// presign-guard-wallet: a viem wallet for AI agents that asks presign-guard
|
|
2
|
+
// before it signs.
|
|
3
|
+
//
|
|
4
|
+
// Before every sendTransaction, writeContract and signTypedData, the wallet
|
|
5
|
+
// pays $0.01 (x402, USDC) for a presign-guard verdict on exactly what is about
|
|
6
|
+
// to be signed, and acts on it:
|
|
7
|
+
// green → signs
|
|
8
|
+
// orange → onOrange: "stop" (default, throws), "allow", or your own async
|
|
9
|
+
// function that decides (e.g. ask the user)
|
|
10
|
+
// red → throws PresignBlockedError; nothing is signed
|
|
11
|
+
// Every verdict must carry presign-guard's signed receipt for exactly this
|
|
12
|
+
// request, checked against its pinned signer (or a key certified by the Fizzl
|
|
13
|
+
// payout wallet): a missing, changed or forged verdict is never a signature.
|
|
14
|
+
// If the check itself fails (network, outage), onError decides: "stop"
|
|
15
|
+
// (default) or "allow".
|
|
16
|
+
//
|
|
17
|
+
// Your keys stay in your wallet client; the check is paid with the x402 fetch
|
|
18
|
+
// you pass in (wrapFetchWithPayment from @x402/fetch, with spend controls).
|
|
19
|
+
|
|
20
|
+
import { encodeFunctionData } from "viem";
|
|
21
|
+
import { verifyReceipt, AUTHORITY } from "x402-safe-fetch";
|
|
22
|
+
|
|
23
|
+
export const PRESIGN_URL = "https://presign-guard.fizzl.eu";
|
|
24
|
+
export const PRESIGN_SIGNERS = ["0xf084Ea47Ca4D99BB4De3ECB0332b316bE6521EaE"];
|
|
25
|
+
export const SUPPORTED_CHAINS = [1, 10, 56, 137, 8453, 42161];
|
|
26
|
+
export const VERSION = "0.1.0";
|
|
27
|
+
const ROUTE = "POST /v1/check";
|
|
28
|
+
|
|
29
|
+
export class PresignBlockedError extends Error {
|
|
30
|
+
/** code: "red" | "orange" | "check_failed" | "bad_receipt" | "unsupported_chain" */
|
|
31
|
+
constructor(message, { code, verdict = null, request = null } = {}) {
|
|
32
|
+
super(message);
|
|
33
|
+
this.name = "PresignBlockedError";
|
|
34
|
+
this.code = code;
|
|
35
|
+
this.verdict = verdict;
|
|
36
|
+
this.request = request;
|
|
37
|
+
}
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
// JSON with bigints as decimal strings (viem uses bigint for values and amounts).
|
|
41
|
+
const toJson = (value) => JSON.stringify(value, (_k, v) => (typeof v === "bigint" ? v.toString() : v));
|
|
42
|
+
|
|
43
|
+
// What presign-guard should check for a wallet call, or null for calls it does not cover.
|
|
44
|
+
export function checkRequestFor(method, args, { chainId, origin } = {}) {
|
|
45
|
+
const base = { chainId, ...(origin ? { origin } : {}) };
|
|
46
|
+
if (method === "sendTransaction") {
|
|
47
|
+
if (!args?.to) return null; // contract deployment: nothing to screen
|
|
48
|
+
return { type: "transaction", ...base, to: args.to, data: args.data ?? "0x", value: String(args.value ?? 0n) };
|
|
49
|
+
}
|
|
50
|
+
if (method === "writeContract") {
|
|
51
|
+
const data = encodeFunctionData({ abi: args.abi, functionName: args.functionName, args: args.args });
|
|
52
|
+
return { type: "transaction", ...base, to: args.address, data, value: String(args.value ?? 0n) };
|
|
53
|
+
}
|
|
54
|
+
if (method === "signTypedData") {
|
|
55
|
+
const { domain, types, primaryType, message } = args;
|
|
56
|
+
return { type: "signature", ...base, typedData: { domain, types, primaryType, message } };
|
|
57
|
+
}
|
|
58
|
+
return null;
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
const GUARDED = new Set(["sendTransaction", "writeContract", "signTypedData"]);
|
|
62
|
+
|
|
63
|
+
/**
|
|
64
|
+
* @param {object} wallet a viem WalletClient
|
|
65
|
+
* @param {object} options
|
|
66
|
+
* @param {typeof fetch} options.pay a fetch that pays x402 (e.g. wrapFetchWithPayment(fetch, client))
|
|
67
|
+
* @param {"stop"|"allow"|((verdict: object, info: object) => boolean|Promise<boolean>)} [options.onOrange]
|
|
68
|
+
* @param {"stop"|"allow"} [options.onError] when the check cannot be done (default "stop")
|
|
69
|
+
* @param {string} [options.origin] the site asking for the signature, if any (domain age, phishing lists)
|
|
70
|
+
* @param {(verdict: object, info: {method: string, request: object}) => void} [options.onVerdict]
|
|
71
|
+
* @param {string} [options.presignUrl]
|
|
72
|
+
* @param {"require"|"off"} [options.verifyReceipts]
|
|
73
|
+
* @param {string[]} [options.signers]
|
|
74
|
+
* @param {string|null} [options.authority]
|
|
75
|
+
*/
|
|
76
|
+
export function guardWallet(wallet, {
|
|
77
|
+
pay,
|
|
78
|
+
onOrange = "stop",
|
|
79
|
+
onError = "stop",
|
|
80
|
+
origin,
|
|
81
|
+
onVerdict,
|
|
82
|
+
presignUrl = PRESIGN_URL,
|
|
83
|
+
verifyReceipts = "require",
|
|
84
|
+
signers = PRESIGN_SIGNERS,
|
|
85
|
+
authority = AUTHORITY,
|
|
86
|
+
} = {}) {
|
|
87
|
+
if (!wallet || typeof wallet !== "object") throw new TypeError("wallet must be a viem WalletClient");
|
|
88
|
+
if (typeof pay !== "function") throw new TypeError("pay is required: a fetch that pays x402, e.g. wrapFetchWithPayment(fetch, client)");
|
|
89
|
+
if (!["stop", "allow"].includes(onOrange) && typeof onOrange !== "function") throw new TypeError('onOrange must be "stop", "allow" or a function');
|
|
90
|
+
if (!["stop", "allow"].includes(onError)) throw new TypeError('onError must be "stop" or "allow"');
|
|
91
|
+
if (!["require", "off"].includes(verifyReceipts)) throw new TypeError('verifyReceipts must be "require" or "off"');
|
|
92
|
+
|
|
93
|
+
async function check(request) {
|
|
94
|
+
const body = toJson(request);
|
|
95
|
+
const res = await pay(`${presignUrl.replace(/\/$/, "")}/v1/check`, {
|
|
96
|
+
method: "POST",
|
|
97
|
+
headers: { "content-type": "application/json", accept: "application/json", "user-agent": `presign-guard-wallet/${VERSION}` },
|
|
98
|
+
body,
|
|
99
|
+
});
|
|
100
|
+
const verdict = await res.json().catch(() => null);
|
|
101
|
+
if (!res.ok || !verdict?.verdict) {
|
|
102
|
+
const why = verdict?.error || `HTTP ${res.status}`;
|
|
103
|
+
throw new PresignBlockedError(`presign check failed (${why}); nothing was signed`, { code: "check_failed", verdict, request });
|
|
104
|
+
}
|
|
105
|
+
if (verifyReceipts === "require") {
|
|
106
|
+
const ok = verifyReceipt(verdict, { signers, route: ROUTE, input: JSON.parse(body), authority, service: "presign-guard" });
|
|
107
|
+
if (!ok.valid) throw new PresignBlockedError(`verdict not trusted (${ok.reason}); nothing was signed`, { code: "bad_receipt", verdict, request });
|
|
108
|
+
}
|
|
109
|
+
return verdict;
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
async function guarded(method, original, args, rest) {
|
|
113
|
+
const chainId = args?.chain?.id ?? wallet.chain?.id;
|
|
114
|
+
const request = checkRequestFor(method, args, { chainId, origin });
|
|
115
|
+
if (!request) return original(args, ...rest);
|
|
116
|
+
const run = () => original(args, ...rest);
|
|
117
|
+
if (!SUPPORTED_CHAINS.includes(chainId)) {
|
|
118
|
+
if (onError === "allow") return run();
|
|
119
|
+
throw new PresignBlockedError(`chain ${chainId} is not covered by presign-guard; nothing was signed`, { code: "unsupported_chain", request });
|
|
120
|
+
}
|
|
121
|
+
let verdict;
|
|
122
|
+
try {
|
|
123
|
+
verdict = await check(request);
|
|
124
|
+
} catch (err) {
|
|
125
|
+
if (err instanceof PresignBlockedError && err.code === "bad_receipt") throw err;
|
|
126
|
+
if (onError === "allow") return run();
|
|
127
|
+
if (err instanceof PresignBlockedError) throw err;
|
|
128
|
+
throw new PresignBlockedError(`presign check failed (${err.message}); nothing was signed`, { code: "check_failed", request });
|
|
129
|
+
}
|
|
130
|
+
onVerdict?.(verdict, { method, request });
|
|
131
|
+
const why = (verdict.reasons || []).filter((r) => r.severity !== "info").map((r) => r.code).join(", ") || verdict.verdict;
|
|
132
|
+
if (verdict.verdict === "red") throw new PresignBlockedError(`not signed: red (${why})`, { code: "red", verdict, request });
|
|
133
|
+
if (verdict.verdict === "orange") {
|
|
134
|
+
const ok = onOrange === "allow" || (typeof onOrange === "function" && (await onOrange(verdict, { method, request })) === true);
|
|
135
|
+
if (!ok) throw new PresignBlockedError(`not signed: orange (${why})`, { code: "orange", verdict, request });
|
|
136
|
+
} else if (verdict.verdict !== "green") {
|
|
137
|
+
throw new PresignBlockedError(`not signed: unknown verdict ${verdict.verdict}`, { code: "check_failed", verdict, request });
|
|
138
|
+
}
|
|
139
|
+
return run();
|
|
140
|
+
}
|
|
141
|
+
|
|
142
|
+
return new Proxy(wallet, {
|
|
143
|
+
get(target, prop, receiver) {
|
|
144
|
+
const value = Reflect.get(target, prop, receiver);
|
|
145
|
+
if (typeof prop !== "string" || !GUARDED.has(prop) || typeof value !== "function") return value;
|
|
146
|
+
return (args, ...rest) => guarded(prop, value.bind(target), args, rest);
|
|
147
|
+
},
|
|
148
|
+
});
|
|
149
|
+
}
|
package/package.json
ADDED
|
@@ -0,0 +1,56 @@
|
|
|
1
|
+
{
|
|
2
|
+
"name": "presign-guard-wallet",
|
|
3
|
+
"version": "0.1.0",
|
|
4
|
+
"description": "A viem wallet for AI agents that asks presign-guard ($0.01 over x402) before every transaction, contract write and typed-data signature, and refuses to sign red.",
|
|
5
|
+
"type": "module",
|
|
6
|
+
"exports": {
|
|
7
|
+
".": {
|
|
8
|
+
"types": "./index.d.ts",
|
|
9
|
+
"default": "./index.js"
|
|
10
|
+
}
|
|
11
|
+
},
|
|
12
|
+
"main": "./index.js",
|
|
13
|
+
"types": "./index.d.ts",
|
|
14
|
+
"files": [
|
|
15
|
+
"index.js",
|
|
16
|
+
"index.d.ts",
|
|
17
|
+
"README.md",
|
|
18
|
+
"LICENSE"
|
|
19
|
+
],
|
|
20
|
+
"engines": {
|
|
21
|
+
"node": ">=20"
|
|
22
|
+
},
|
|
23
|
+
"scripts": {
|
|
24
|
+
"test": "node --test test/*.test.mjs"
|
|
25
|
+
},
|
|
26
|
+
"dependencies": {
|
|
27
|
+
"x402-safe-fetch": "^0.4.0"
|
|
28
|
+
},
|
|
29
|
+
"peerDependencies": {
|
|
30
|
+
"@x402/fetch": "^2.27.0",
|
|
31
|
+
"viem": "^2.30.0"
|
|
32
|
+
},
|
|
33
|
+
"devDependencies": {
|
|
34
|
+
"@x402/fetch": "^2.27.0",
|
|
35
|
+
"viem": "^2.56.9"
|
|
36
|
+
},
|
|
37
|
+
"keywords": [
|
|
38
|
+
"x402",
|
|
39
|
+
"agents",
|
|
40
|
+
"wallet",
|
|
41
|
+
"viem",
|
|
42
|
+
"security",
|
|
43
|
+
"presign",
|
|
44
|
+
"approvals",
|
|
45
|
+
"permit2",
|
|
46
|
+
"drainer",
|
|
47
|
+
"usdc"
|
|
48
|
+
],
|
|
49
|
+
"repository": {
|
|
50
|
+
"type": "git",
|
|
51
|
+
"url": "git+https://github.com/Fizzl13/x402-examples.git",
|
|
52
|
+
"directory": "guard-wallet"
|
|
53
|
+
},
|
|
54
|
+
"homepage": "https://github.com/Fizzl13/x402-examples/tree/main/guard-wallet#readme",
|
|
55
|
+
"license": "MIT"
|
|
56
|
+
}
|