@rhinestone/shared-configs 2.0.0 → 2.1.0

package/dist/scripts/__tests__/validation.test.js

@@ -4,10 +4,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const bun_test_1 = require("bun:test");
+const viem_1 = require("viem");
 const validation_1 = require("../validation");
 const index_1 = require("../../src/index");
 const oft_json_1 = __importDefault(require("../../configs/oft.json"));
 const nativeToken = { address: "0x0", symbol: "ETH", decimals: 18 };
+const usdcAddress = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+const validAuthorization = {
+    standards: ["erc3009", "erc2612"],
+    domain: {
+        name: "USD Coin",
+        version: "2",
+        chainId: 1,
+        verifyingContract: usdcAddress,
+    },
+    domainSeparator: "0x06c37168a7db5138defc7866392bb87a741f9b3d104deb5094588ce041cae335",
+    eoaOnly: false,
+};
 /** A structurally complete entry, so semantic tests don't trip structural checks. */
 function validChain(overrides = {}) {
     return {
@@ -26,6 +39,8 @@ function validChain(overrides = {}) {
         tokens: [{ ...nativeToken, balanceSlot: null, approvalSlot: null }],
         settlementLayers: ["ACROSS", "ECO", "RELAY"],
         swapQuoters: ["0x"],
+        providerIds: { alchemy: "ETH_MAINNET", zerion: "ethereum" },
+        sessionCapable: true,
         ...overrides,
     };
 }
@@ -41,6 +56,62 @@ function errorsFor(chain) {
         (0, bun_test_1.expect)(errors).toEqual([]);
         (0, bun_test_1.expect)(result.hasErrors).toBe(false);
     });
+    (0, bun_test_1.it)("publishes exactly the authorization capabilities verified by the live audit", () => {
+        const both = { standards: ["erc3009", "erc2612"], eoaOnly: false };
+        const permitOnly = { standards: ["erc2612"], eoaOnly: true };
+        const transferOnly = { standards: ["erc3009"], eoaOnly: true };
+        const expected = new Map([
+            ["1:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48", both],
+            ["10:0x0b2c639c533813f4aa9d7837caf62653d097ff85", both],
+            ["10:0x01bff41798a0bcf287b996046ca68b395dbc1071", both],
+            ["100:0x2a22f9c3b484c3629090feed35f17ff8f88f76f0", both],
+            ["130:0x078d782b760474a361dda0af3839290b0ef57ad6", both],
+            ["130:0x9151434b16b9763660705744891fa906f660ecc5", both],
+            ["137:0x3c499c542cef5e3811e1192ce70d8cc03d5c3359", both],
+            ["137:0xc2132d05d31c914a87c6611c10748aeb04b58e8f", permitOnly],
+            ["143:0x754704bc059f8c67012fed69bc8a327a5aafb603", both],
+            ["143:0xe7cd86e13ac4309349f30b3435a9d337750fc82d", both],
+            ["146:0x29219dd400f2bf60e5a23d13be72b486d4038894", both],
+            ["999:0xb88339cb7199b77e23db6e890353e22632ba630f", both],
+            ["999:0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb", both],
+            ["1868:0xba9986d2381edf1da03b0b9c1f8b00dc4aacc369", both],
+            ["4663:0x0bd7d308f8e1639fab988df18a8011f41eacad73", permitOnly],
+            ["4663:0x5fc5360d0400a0fd4f2af552add042d716f1d168", both],
+            ["8453:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913", both],
+            ["9745:0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb", both],
+            ["9746:0x502012b361aebce43b26ec812b74d9a51db4d412", transferOnly],
+            ["42161:0x82af49447d8a07e3bd95bd0d56f35241523fbab1", permitOnly],
+            ["42161:0xaf88d065e77c8cc2239327c5edb3a432268e5831", both],
+            ["42161:0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9", both],
+            ["43114:0x9702230a8ea53601f5cd2dc00fdbc13d4df4a8c7", permitOnly],
+            ["43114:0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e", both],
+            ["84532:0x036cbd53842c5426634e7929541ec2318f3dcf7e", both],
+            ["421614:0x75faf114eafb1bdbe2f0316df893fd58ce46aa4d", both],
+            ["421614:0x980b62da83eff3d4576c647993b0c1d7faf17c73", permitOnly],
+            ["747474:0x203a662b0bd271a6ed5a60edfbd04bfce608fd36", permitOnly],
+            ["747474:0x2dca96907fde857dd3d816880a0df407eeb2d2f2", permitOnly],
+            ["747474:0xee7d8bcfb72bc1880d0cf19822eb0a2e6577ab62", permitOnly],
+            ["11155111:0x1c7d4b196cb0c7b01d743fbc6116a902379c7238", both],
+            ["11155111:0x768f42455a2d082e23ceef7d51e5787c82d67a39", permitOnly],
+            ["11155420:0x5fd84259d66cd46123540766be93dfe6d43130d7", both],
+        ]);
+        const configured = new Map(Object.entries(index_1.chainRegistry).flatMap(([chainId, entry]) => entry.tokens.flatMap((token) => {
+            if (!token.authorization)
+                return [];
+            const key = `${chainId}:${token.address.toLowerCase()}`;
+            (0, bun_test_1.expect)((0, viem_1.domainSeparator)({ domain: token.authorization.domain })).toBe(token.authorization.domainSeparator);
+            return [
+                [
+                    key,
+                    {
+                        standards: token.authorization.standards,
+                        eoaOnly: token.authorization.eoaOnly,
+                    },
+                ],
+            ];
+        })));
+        (0, bun_test_1.expect)([...configured.entries()].sort()).toEqual([...expected.entries()].sort());
+    });
     (0, bun_test_1.it)("rejects a key that is not a canonical chain id", () => {
         const result = (0, validation_1.validateChainConfig)({ "01": validChain() });
         (0, bun_test_1.expect)(result.hasErrors).toBe(true);
@@ -83,12 +154,171 @@ function errorsFor(chain) {
         ["an iconSlug carrying its extension", { iconSlug: "base.svg" }],
         ["an iconSlug carrying a directory", { iconSlug: "chains/base" }],
         ["an iconSlug that is not a string", { iconSlug: 42 }],
+        // A missing vendor id and a null one mean opposite things — an artifact
+        // older than the field, versus a vendor that was checked and does not serve
+        // the chain. Only the second is an answer a consumer can act on.
+        ["missing providerIds", { providerIds: undefined }],
+        ["providerIds missing a vendor", { providerIds: { alchemy: "ETH_MAINNET" } }],
+        ["an empty vendor id", { providerIds: { alchemy: "", zerion: "ethereum" } }],
+        ["a missing sessionCapable", { sessionCapable: undefined }],
     ])("rejects %s", (_label, overrides) => {
         (0, bun_test_1.expect)(errorsFor(validChain(overrides)).length).toBeGreaterThan(0);
     });
     (0, bun_test_1.it)("accepts a null explorer, the answer for a chain that has none", () => {
         (0, bun_test_1.expect)(errorsFor(validChain({ explorer: null }))).toEqual([]);
     });
+    // Katana is exactly this: Alchemy serves it over RPC but Address Activity
+    // does not carry it, so ingestion is Zerion's alone.
+    (0, bun_test_1.it)("accepts a null vendor id, the answer for a vendor that does not serve the chain", () => {
+        (0, bun_test_1.expect)(errorsFor(validChain({ providerIds: { alchemy: null, zerion: "katana" } }))).toEqual([]);
+        (0, bun_test_1.expect)(errorsFor(validChain({ providerIds: { alchemy: null, zerion: null } }))).toEqual([]);
+    });
+    (0, bun_test_1.it)("accepts a complete token-native authorization declaration", () => {
+        (0, bun_test_1.expect)(errorsFor(validChain({
+            tokens: [
+                {
+                    ...nativeToken,
+                    balanceSlot: null,
+                    approvalSlot: null,
+                    authorization: validAuthorization,
+                    address: usdcAddress,
+                },
+            ],
+        }))).toEqual([]);
+    });
+    bun_test_1.it.each([
+        ["a non-object declaration", "erc2612"],
+        [
+            "no standards",
+            {
+                ...validAuthorization,
+                standards: [],
+            },
+        ],
+        [
+            "an unknown standard",
+            {
+                ...validAuthorization,
+                standards: ["dai-permit"],
+            },
+        ],
+        [
+            "duplicate standards",
+            {
+                ...validAuthorization,
+                standards: ["erc2612", "erc2612"],
+            },
+        ],
+        [
+            "a missing domain",
+            {
+                ...validAuthorization,
+                standards: ["erc2612"],
+                domain: undefined,
+            },
+        ],
+        [
+            "an empty domain name",
+            {
+                ...validAuthorization,
+                domain: { ...validAuthorization.domain, name: "" },
+            },
+        ],
+        [
+            "a missing eoaOnly constraint",
+            {
+                ...validAuthorization,
+                eoaOnly: undefined,
+            },
+        ],
+        [
+            "a missing pinned separator",
+            {
+                ...validAuthorization,
+                domainSeparator: undefined,
+            },
+        ],
+        [
+            "a separator inconsistent with the domain",
+            {
+                ...validAuthorization,
+                domainSeparator: `0x${"00".repeat(32)}`,
+            },
+        ],
+        [
+            "a verifying contract different from the token",
+            {
+                ...validAuthorization,
+                domain: {
+                    ...validAuthorization.domain,
+                    verifyingContract: "0x0000000000000000000000000000000000000001",
+                },
+            },
+        ],
+        [
+            "a domain chain id different from the registry",
+            {
+                ...validAuthorization,
+                domain: { ...validAuthorization.domain, chainId: 10 },
+            },
+        ],
+        [
+            "both chainId and salt",
+            {
+                ...validAuthorization,
+                domain: {
+                    ...validAuthorization.domain,
+                    salt: `0x${"00".repeat(32)}`,
+                },
+            },
+        ],
+        [
+            "neither chainId nor salt",
+            {
+                ...validAuthorization,
+                domain: {
+                    name: "USD Coin",
+                    version: "2",
+                    verifyingContract: usdcAddress,
+                },
+            },
+        ],
+    ])("rejects token authorization metadata with %s", (_label, authorization) => {
+        const tokens = [
+            {
+                ...nativeToken,
+                balanceSlot: null,
+                approvalSlot: null,
+                authorization,
+                address: usdcAddress,
+            },
+        ];
+        (0, bun_test_1.expect)(errorsFor(validChain({ tokens })).length).toBeGreaterThan(0);
+    });
+    (0, bun_test_1.it)("rejects token-native EIP-712 authorization metadata on non-EVM chains", () => {
+        const tokens = [
+            {
+                ...nativeToken,
+                balanceSlot: null,
+                approvalSlot: null,
+                authorization: validAuthorization,
+                address: usdcAddress,
+            },
+        ];
+        (0, bun_test_1.expect)(errorsFor(validChain({ vmType: "svm", tokens })).some((issue) => issue.message.includes("only valid for EVM tokens"))).toBe(true);
+    });
+    (0, bun_test_1.it)("rejects token authorization metadata on virtual EVM chains", () => {
+        const tokens = [
+            {
+                ...nativeToken,
+                address: usdcAddress,
+                balanceSlot: null,
+                approvalSlot: null,
+                authorization: validAuthorization,
+            },
+        ];
+        (0, bun_test_1.expect)(errorsFor(validChain({ virtual: true, tokens })).some((issue) => issue.message.includes("not valid on a virtual chain"))).toBe(true);
+    });
     (0, bun_test_1.it)("names the offending value so the build failure is actionable", () => {
         const [error] = errorsFor(validChain({ settlementLayers: ["TELEPORT"] }));
         (0, bun_test_1.expect)(error.message).toContain("TELEPORT");

package/dist/scripts/audit-token-authorizations.d.ts

@@ -0,0 +1 @@
+export {};