@b3dotfun/sdk 0.1.70-alpha.19 → 0.1.70-alpha.20

package/node_modules/@b3/chain-registry/src/index.test.ts

@@ -0,0 +1,432 @@
+import { describe, expect, it } from "vitest";
+import {
+  CANONICAL_NAME_ASSETS,
+  chains,
+  looksLikeProviderTokenAddress,
+  isProviderTokenAddress,
+  isRegistryResolvedTokenIdentity,
+  isRegistryTokenIdentityCandidate,
+  isResolvedTokenIdentity,
+  isTokenIdentityCandidate,
+  matchCanonicalNativeAssetText,
+  nativeAssets,
+  looksLikeTokenAddress,
+  resolveChainIdentifier,
+  resolveDexScreenerChainIdentifier,
+  tokenAddressFamily,
+  tokenAddressKey,
+  validateChainDefinitions,
+  type ChainDefinition,
+  type NativeAssetDefinition,
+  type ResolvedTokenIdentity,
+  type TokenIdentityCandidate,
+} from "./index";
+
+const WETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
+
+function cloneChains(): ChainDefinition[] {
+  return structuredClone(chains);
+}
+
+describe("chain identifier resolution", () => {
+  it("maps names, keys, normalized aliases, and numeric ids to one chain", () => {
+    const canonical = resolveChainIdentifier("solana");
+
+    expect(canonical?.network).toBe("solana");
+    expect(resolveChainIdentifier(" SOLANA ")).toBe(canonical);
+    expect(resolveChainIdentifier("Solana Mainnet")).toBe(canonical);
+    expect(resolveChainIdentifier("7565164")).toBe(canonical);
+    expect(resolveChainIdentifier("unknown-chain")).toBeNull();
+  });
+
+  it("maps registry aliases to provider ids and preserves bounded unknown provider ids", () => {
+    expect(resolveDexScreenerChainIdentifier("eth")).toEqual({
+      identityChainId: "eth",
+      providerChainId: "ethereum",
+      chainType: "evm",
+      registryChainId: 1,
+    });
+    expect(resolveDexScreenerChainIdentifier("1")?.providerChainId).toBe("ethereum");
+    expect(resolveDexScreenerChainIdentifier("Ethereum")?.providerChainId).toBe("ethereum");
+    expect(resolveDexScreenerChainIdentifier("137")?.providerChainId).toBe("polygon");
+    expect(resolveDexScreenerChainIdentifier("43114")?.providerChainId).toBe("avalanche");
+    expect(resolveDexScreenerChainIdentifier("polygon-zkevm")?.providerChainId).toBe("polygonzkevm");
+    expect(resolveDexScreenerChainIdentifier("42170")?.providerChainId).toBe("arbitrumnova");
+    expect(resolveDexScreenerChainIdentifier("degen")?.providerChainId).toBe("degenchain");
+    expect(resolveDexScreenerChainIdentifier("metis")).toEqual({
+      identityChainId: "metis",
+      providerChainId: "metis",
+      chainType: "evm",
+      registryChainId: 1088,
+    });
+    expect(
+      Object.fromEntries(
+        chains
+          .filter(chain => [10, 4663, 8453, 42161].includes(chain.chainId))
+          .map(chain => [chain.chainId, chain.dexscreenerNetwork]),
+      ),
+    ).toEqual({
+      10: "optimism",
+      4663: "robinhood",
+      8453: "base",
+      42161: "arbitrum",
+    });
+    expect(resolveDexScreenerChainIdentifier("sui")).toEqual({
+      identityChainId: "sui",
+      providerChainId: "sui",
+      chainType: null,
+      registryChainId: null,
+    });
+    expect(resolveDexScreenerChainIdentifier("bad/provider")).toBeNull();
+    expect(resolveDexScreenerChainIdentifier("x".repeat(65))).toBeNull();
+  });
+
+  it("pins every registry chain with declared DexScreener support", () => {
+    expect(
+      Object.fromEntries(
+        chains.filter(chain => chain.dexscreenerNetwork).map(chain => [chain.network, chain.dexscreenerNetwork]),
+      ),
+    ).toEqual({
+      abstract: "abstract",
+      arbitrum: "arbitrum",
+      arbitrum_nova: "arbitrumnova",
+      avax: "avalanche",
+      base: "base",
+      berachain: "berachain",
+      blast: "blast",
+      bsc: "bsc",
+      celo: "celo",
+      cro: "cronos",
+      degen: "degenchain",
+      eth: "ethereum",
+      ftm: "fantom",
+      glmr: "moonbeam",
+      hyperevm: "hyperevm",
+      linea: "linea",
+      mantle: "mantle",
+      matic: "polygon",
+      metis: "metis",
+      mode: "mode",
+      optimism: "optimism",
+      "polygon-zkevm": "polygonzkevm",
+      robinhood: "robinhood",
+      scroll: "scroll",
+      solana: "solana",
+      soneium: "soneium",
+      sonic: "sonic",
+      unichain: "unichain",
+      worldchain: "worldchain",
+      xdai: "gnosis",
+      zksync: "zksync",
+    });
+  });
+
+  it("fails closed for registry chains without declared DexScreener support", () => {
+    const undeclaredIdentifiers = [
+      "ronin",
+      "2020",
+      "b3",
+      "8333",
+      "zircuit",
+      "48900",
+      "plume",
+      "98866",
+      "taiko",
+      "167000",
+      "zora",
+      "7777777",
+      "aurora",
+      "1313161554",
+    ];
+
+    expect(
+      Object.fromEntries(
+        undeclaredIdentifiers.map(identifier => [identifier, resolveDexScreenerChainIdentifier(identifier)]),
+      ),
+    ).toEqual(Object.fromEntries(undeclaredIdentifiers.map(identifier => [identifier, null])));
+  });
+
+  it("rejects an identifier claimed by two different chains", () => {
+    const definitions = cloneChains();
+    definitions.push({
+      ...definitions[1],
+      chainId: 999_999_999,
+      key: "OTHER",
+      name: "Other",
+      network: "ethereum",
+    });
+
+    expect(() => validateChainDefinitions(definitions)).toThrow(
+      'Chain identifier "ethereum" is claimed by both "eth" and "ethereum"',
+    );
+  });
+
+  it("rejects a provider id claimed by two different chains", () => {
+    const duplicateProviderId = cloneChains();
+    duplicateProviderId[1] = { ...duplicateProviderId[1], dexscreenerNetwork: "ethereum" };
+    expect(() => validateChainDefinitions(duplicateProviderId)).toThrow(
+      'Chain identifier "ethereum" is claimed by both "eth" and "optimism"',
+    );
+  });
+
+  it("rejects duplicate numeric ids and incomplete wrapped-native metadata", () => {
+    const duplicateId = cloneChains();
+    duplicateId[1] = { ...duplicateId[1], chainId: duplicateId[0].chainId };
+    expect(() => validateChainDefinitions(duplicateId)).toThrow(/Chain id 1 is claimed/);
+
+    const incompleteWrapped = cloneChains();
+    const solanaIndex = incompleteWrapped.findIndex(chain => chain.network === "solana");
+    incompleteWrapped[solanaIndex] = { ...incompleteWrapped[solanaIndex], dexscreenerNetwork: undefined };
+    expect(() => validateChainDefinitions(incompleteWrapped)).toThrow(/Incomplete wrapped-native metadata/);
+  });
+
+  it("rejects invalid canonical SOL and wrapped-address metadata", () => {
+    const invalidSol = cloneChains();
+    const solanaIndex = invalidSol.findIndex(chain => chain.network === "solana");
+    invalidSol[solanaIndex] = {
+      ...invalidSol[solanaIndex],
+      wrappedNativeCurrency: { name: "Wrapped SOL", symbol: "WSOL", decimals: 9 },
+    };
+    expect(() => validateChainDefinitions(invalidSol)).toThrow("Canonical Solana SOL/wSOL metadata is invalid");
+
+    const wrongFamily = cloneChains();
+    wrongFamily[0] = { ...wrongFamily[0], wrappedNative: "So11111111111111111111111111111111111111112" };
+    expect(() => validateChainDefinitions(wrongFamily)).toThrow(/Invalid wrapped-native address/);
+  });
+});
+
+describe("token identity trust boundaries", () => {
+  const futureWrappedIdentity: ResolvedTokenIdentity = {
+    kind: "wrapped-native",
+    matchedBy: "canonical",
+    chainId: "eth",
+    address: WETH,
+    marketAddress: WETH,
+    name: "Wrapped Ether",
+    symbol: "WETH",
+    nativeSymbol: "ETH",
+  };
+  const futureWrappedCandidate: TokenIdentityCandidate = {
+    chainId: "eth",
+    providerChainId: "ethereum",
+    tokenAddress: WETH,
+    name: "Wrapped Ether",
+    symbol: "WETH",
+    pairSide: "base",
+    identity: futureWrappedIdentity,
+  };
+
+  it("accepts a structurally valid future wrapped identity without local canonical metadata", () => {
+    expect(isResolvedTokenIdentity(futureWrappedIdentity)).toBe(true);
+    expect(isTokenIdentityCandidate(futureWrappedCandidate)).toBe(true);
+    expect(isRegistryResolvedTokenIdentity(futureWrappedIdentity)).toBe(false);
+    expect(isRegistryTokenIdentityCandidate(futureWrappedCandidate)).toBe(false);
+  });
+
+  it("folds token-address case only for EVM identity evidence", () => {
+    const lowercaseWeth = WETH.toLowerCase();
+    expect(
+      isResolvedTokenIdentity({
+        ...futureWrappedIdentity,
+        address: lowercaseWeth,
+      }),
+    ).toBe(true);
+    expect(
+      isTokenIdentityCandidate({
+        ...futureWrappedCandidate,
+        tokenAddress: lowercaseWeth,
+      }),
+    ).toBe(true);
+
+    const futureNativeAsset: NativeAssetDefinition = {
+      chainId: 1,
+      chain: "eth",
+      dexscreenerChain: "ethereum",
+      name: "Ethereum",
+      symbol: "ETH",
+      decimals: 18,
+      wrapped: {
+        address: WETH,
+        name: "Wrapped Ether",
+        symbol: "WETH",
+        decimals: 18,
+      },
+    };
+    const mutableNativeAssets = nativeAssets as NativeAssetDefinition[];
+    const futureAssetIndex = mutableNativeAssets.push(futureNativeAsset) - 1;
+    try {
+      const lowercaseIdentity: ResolvedTokenIdentity = {
+        ...futureWrappedIdentity,
+        address: lowercaseWeth,
+        marketAddress: lowercaseWeth,
+      };
+      expect(isRegistryResolvedTokenIdentity(lowercaseIdentity)).toBe(true);
+      expect(
+        isRegistryTokenIdentityCandidate({
+          ...futureWrappedCandidate,
+          tokenAddress: lowercaseWeth,
+          identity: lowercaseIdentity,
+        }),
+      ).toBe(true);
+    } finally {
+      mutableNativeAssets.splice(futureAssetIndex, 1);
+    }
+    const invalidUppercasePrefix = `0X${WETH.slice(2)}`;
+    expect(
+      isResolvedTokenIdentity({
+        ...futureWrappedIdentity,
+        address: invalidUppercasePrefix,
+      }),
+    ).toBe(false);
+    expect(
+      isTokenIdentityCandidate({
+        ...futureWrappedCandidate,
+        tokenAddress: invalidUppercasePrefix,
+      }),
+    ).toBe(false);
+
+    const wrappedSol = "So11111111111111111111111111111111111111112";
+    const caseMutatedWrappedSol = `s${wrappedSol.slice(1)}`;
+    const wrappedSolIdentity: ResolvedTokenIdentity = {
+      kind: "wrapped-native",
+      matchedBy: "canonical",
+      chainId: "solana",
+      address: wrappedSol,
+      marketAddress: wrappedSol,
+      name: "Wrapped SOL",
+      symbol: "WSOL",
+      nativeSymbol: "SOL",
+    };
+
+    expect(
+      isResolvedTokenIdentity({
+        ...wrappedSolIdentity,
+        address: caseMutatedWrappedSol,
+      }),
+    ).toBe(false);
+    expect(
+      isTokenIdentityCandidate({
+        chainId: "solana",
+        providerChainId: "solana",
+        tokenAddress: caseMutatedWrappedSol,
+        name: "Wrapped SOL",
+        symbol: "WSOL",
+        pairSide: "base",
+        identity: wrappedSolIdentity,
+      }),
+    ).toBe(false);
+  });
+
+  it("never promotes case-mutated wrapped Solana addresses to registry-native identity", () => {
+    const canonical = "So11111111111111111111111111111111111111112";
+    const mutation = `s${canonical.slice(1)}`;
+    const mutatedIdentity: ResolvedTokenIdentity = {
+      kind: "wrapped-native",
+      matchedBy: "canonical",
+      chainId: "solana",
+      address: mutation,
+      marketAddress: mutation,
+      name: "Wrapped SOL",
+      symbol: "WSOL",
+      nativeSymbol: "SOL",
+    };
+
+    expect(isResolvedTokenIdentity(mutatedIdentity)).toBe(true);
+    expect(isRegistryResolvedTokenIdentity(mutatedIdentity)).toBe(false);
+  });
+
+  it("rejects a known chain whose address belongs to another family", () => {
+    expect(
+      isResolvedTokenIdentity({
+        kind: "contract",
+        matchedBy: "exact",
+        chainId: "solana",
+        address: WETH,
+        marketAddress: WETH,
+        name: "Wrong family",
+        symbol: "WRONG",
+        nativeSymbol: null,
+      }),
+    ).toBe(false);
+  });
+
+  it("allows structurally valid contracts on provider chains absent from the local registry", () => {
+    expect(
+      isResolvedTokenIdentity({
+        kind: "contract",
+        matchedBy: "ranked",
+        chainId: "future-evm",
+        address: WETH,
+        marketAddress: WETH,
+        name: "Future token",
+        symbol: "FUTURE",
+        nativeSymbol: null,
+      }),
+    ).toBe(true);
+  });
+
+  it("classifies only complete EVM and 32-byte Solana token addresses", () => {
+    expect(tokenAddressFamily(WETH)).toBe("evm");
+    expect(tokenAddressFamily("So11111111111111111111111111111111111111112")).toBe("solana");
+    expect(tokenAddressFamily("0xabc")).toBeNull();
+  });
+
+  it("centralizes canonical SOL and wSOL text matching in the registry", () => {
+    expect(CANONICAL_NAME_ASSETS).toHaveLength(1);
+    const [solana] = CANONICAL_NAME_ASSETS;
+    expect(matchCanonicalNativeAssetText(solana, "$SOL")).toBe("native");
+    expect(matchCanonicalNativeAssetText(solana, "Solana")).toBe("native");
+    expect(matchCanonicalNativeAssetText(solana, "wSOL")).toBe("wrapped-native");
+    expect(matchCanonicalNativeAssetText(solana, "Wrapped SOL")).toBe("wrapped-native");
+    expect(matchCanonicalNativeAssetText(solana, "ETH")).toBeNull();
+  });
+
+  it("distinguishes explicit provider coin types from arbitrary opaque user input", () => {
+    const suiCoinType = "0x2::sui::SUI";
+    const longOpaqueAddress = `EQ${"a".repeat(46)}`;
+
+    expect(isProviderTokenAddress(suiCoinType)).toBe(true);
+    expect(looksLikeTokenAddress(suiCoinType)).toBe(false);
+    expect(looksLikeProviderTokenAddress(suiCoinType)).toBe(true);
+    expect(looksLikeProviderTokenAddress(longOpaqueAddress)).toBe(false);
+    expect(isProviderTokenAddress(longOpaqueAddress)).toBe(true);
+    expect(isProviderTokenAddress("not-token")).toBe(false);
+    expect(isProviderTokenAddress(`0x2::${"a".repeat(257)}`)).toBe(false);
+    expect(tokenAddressKey("sui", "AbCd")).toBe("AbCd");
+    expect(tokenAddressKey("future-evm", WETH)).toBe(WETH.toLowerCase());
+    expect(tokenAddressKey("eth", WETH)).toBe(WETH.toLowerCase());
+    expect(
+      isResolvedTokenIdentity({
+        kind: "contract",
+        matchedBy: "exact",
+        chainId: "sui",
+        address: suiCoinType,
+        marketAddress: suiCoinType,
+        name: "Sui",
+        symbol: "SUI",
+        nativeSymbol: null,
+      }),
+    ).toBe(true);
+    const candidate = {
+      chainId: "sui",
+      providerChainId: "sui",
+      tokenAddress: suiCoinType,
+      name: "Sui",
+      symbol: "SUI",
+      pairSide: "base",
+      identity: {
+        kind: "contract",
+        matchedBy: "exact",
+        chainId: "sui",
+        address: suiCoinType,
+        marketAddress: suiCoinType,
+        name: "Sui",
+        symbol: "SUI",
+        nativeSymbol: null,
+      },
+    };
+    expect(isRegistryTokenIdentityCandidate(candidate)).toBe(true);
+    expect(isTokenIdentityCandidate(candidate)).toBe(true);
+    expect(isTokenIdentityCandidate({ ...candidate, providerChainId: undefined })).toBe(false);
+  });
+});