[ERC7811] ウォレットが保有資産をDAppへ返す仕組み

const response = await provider.request({
  method: "wallet_getAssets",
  params: [{
    account: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
    assetTypeFilter: ["native", "erc20"],
    chainFilter: ["0x1", "0xa"],
  }],
});

{
  "account": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
  "assetFilter": {
    "0x1": [{ "address": "native", "type": "native" }]
  },
  "assetTypeFilter": ["erc20"],
  "chainFilter": ["0xa"]
}

{
  "0x1": [
    { "address": "native", "balance": "0xde0b6b3a7640000", "type": "native" },
    {
      "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
      "balance": "0xf4240",
      "type": "erc20",
      "metadata": { "name": "USD Coin", "symbol": "USDC", "decimals": 6 }
    },
    {
      "address": "0x1111111111111111111111111111111111111111",
      "balance": "0x1",
      "type": "erc721",
      "metadata": {
        "name": "Example NFT",
        "symbol": "ENFT",
        "tokenId": "0x2a",
        "tokenURI": "ipfs://example"
      }
    }
  ]
}

{
  "0x1": { "assetDiscovery": { "supported": true } },
  "0x0": { "assetDiscovery": { "supported": true } }
}

export type Hex = `0x${string}`;
export type Address = Hex;
export type ChainId = Hex;
export type AssetType = "native" | "erc20" | "erc721";

export type AssetIdentifier = {
  address: Address | "native";
  type: AssetType;
};

export type WalletGetAssetsRequest = {
  account: Address;
  assetFilter?: Record<ChainId, AssetIdentifier[]>;
  assetTypeFilter?: AssetType[];
  chainFilter?: ChainId[];
};

export type NativeAsset = {
  address: "native";
  balance: Hex;
  type: "native";
};

export type Erc20Asset = {
  address: Address;
  balance: Hex;
  type: "erc20";
  metadata: { name: string; symbol: string; decimals: number };
};

export type Erc721Asset = {
  address: Address;
  balance: Hex;
  type: "erc721";
  metadata: {
    name: string;
    symbol: string;
    tokenId: Hex;
    tokenURI?: string;
  };
};

export type Asset = NativeAsset | Erc20Asset | Erc721Asset;
export type WalletGetAssetsResponse = Record<ChainId, Asset[]>;

export class RpcError extends Error {
  constructor(public readonly code: number, message: string) {
    super(message);
  }
}

const ADDRESS = /^0x[0-9a-fA-F]{40}$/;
const HEX_QUANTITY = /^0x(?:0|[1-9a-fA-F][0-9a-fA-F]*)$/;
const ASSET_TYPES = new Set<AssetType>(["native", "erc20", "erc721"]);

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === "object" && value !== null && !Array.isArray(value);
}

function isAddress(value: unknown): value is Address {
  return typeof value === "string" && ADDRESS.test(value);
}

function isChainId(value: unknown): value is ChainId {
  return typeof value === "string" && HEX_QUANTITY.test(value);
}

function isAssetType(value: unknown): value is AssetType {
  return typeof value === "string" && ASSET_TYPES.has(value as AssetType);
}

export function parseWalletGetAssetsParams(
  params: unknown,
): WalletGetAssetsRequest {
  if (!Array.isArray(params) || params.length !== 1 || !isRecord(params[0])) {
    throw new RpcError(-32602, "params must be [WalletGetAssetsRequest]");
  }

  const request = params[0];
  if (!isAddress(request.account)) {
    throw new RpcError(-32602, "account must be a 20-byte address");
  }

  if (
    request.chainFilter !== undefined &&
    (!Array.isArray(request.chainFilter) || !request.chainFilter.every(isChainId))
  ) {
    throw new RpcError(-32602, "chainFilter contains an invalid chain ID");
  }

  if (
    request.assetTypeFilter !== undefined &&
    (!Array.isArray(request.assetTypeFilter) ||
      !request.assetTypeFilter.every(isAssetType))
  ) {
    throw new RpcError(-32602, "assetTypeFilter contains an unknown type");
  }

  if (request.assetFilter !== undefined) {
    if (!isRecord(request.assetFilter)) {
      throw new RpcError(-32602, "assetFilter must be a record");
    }

    for (const [chainId, identifiers] of Object.entries(request.assetFilter)) {
      if (!isChainId(chainId) || !Array.isArray(identifiers)) {
        throw new RpcError(-32602, "assetFilter contains an invalid chain");
      }

      for (const identifier of identifiers) {
        if (
          !isRecord(identifier) ||
          !(identifier.address === "native" || isAddress(identifier.address)) ||
          !isAssetType(identifier.type)
        ) {
          throw new RpcError(-32602, "assetFilter contains an invalid asset");
        }
      }
    }
  }

  return request as WalletGetAssetsRequest;
}

import { getAddress } from "viem";

type AuthorizedScope = {
  methods: Set<string>;
  accountChains: Set<string>;
};

export type Authorization = {
  scopes: AuthorizedScope[];
};

export function normalizeChainId(chainId: ChainId | string): bigint {
  if (chainId.startsWith("0x")) {
    if (!isChainId(chainId)) {
      throw new RpcError(-32602, "invalid hex chain ID");
    }
    return BigInt(chainId);
  }

  if (!/^(?:0|[1-9][0-9]*)$/.test(chainId)) {
    throw new RpcError(-32602, "invalid decimal chain ID");
  }
  return BigInt(chainId);
}

function normalizeEvmAddress(address: string): string {
  if (!ADDRESS.test(address)) {
    throw new RpcError(-32602, "invalid EVM address");
  }
  return getAddress(address).toLowerCase();
}

function accountChainKey(chainId: bigint, account: string): string {
  return `${chainId}:${normalizeEvmAddress(account)}`;
}

export function addLegacyScope(
  authorization: Authorization,
  input: { methods: string[]; accounts: string[] },
): void {
  const scope: AuthorizedScope = {
    methods: new Set(input.methods),
    accountChains: new Set(),
  };

  for (const accountId of input.accounts) {
    const match = /^eip155:([0-9]+):(0x[0-9a-fA-F]{40})$/.exec(accountId);
    if (!match) {
      throw new RpcError(-32602, "invalid EIP155 CAIP-10 account");
    }
    scope.accountChains.add(
      accountChainKey(normalizeChainId(match[1]), match[2]),
    );
  }
  authorization.scopes.push(scope);
}

export function addCurrentScope(
  authorization: Authorization,
  scopeKey: string,
  input: { chains?: string[]; accounts: string[]; methods: string[] },
): void {
  if (scopeKey === "eip155:0") {
    throw new RpcError(4100, "ambiguous namespace-wide CAIP-25 authorization");
  }

  const chainIds = new Set((input.chains ?? []).map(normalizeChainId));
  const chainScope = /^eip155:([0-9]+)$/.exec(scopeKey);
  if (chainScope) {
    chainIds.add(normalizeChainId(chainScope[1]));
  } else if (scopeKey !== "eip155") {
    throw new RpcError(-32602, "unsupported CAIP-25 scope");
  }
  if (chainIds.size === 0) {
    throw new RpcError(-32602, "CAIP-25 scope has no explicit chain");
  }

  authorization.scopes.push({
    methods: new Set(input.methods),
    accountChains: new Set(
      [...chainIds].flatMap((chainId) =>
        input.accounts.map((account) => accountChainKey(chainId, account)),
      ),
    ),
  });
}

export function isAuthorized(
  authorization: Authorization,
  account: Address,
  chainIds: ChainId[],
): boolean {
  if (chainIds.length === 0) {
    const accountSuffix = `:${normalizeEvmAddress(account)}`;
    return authorization.scopes.some(
      (scope) =>
        scope.methods.has("wallet_getAssets") &&
        [...scope.accountChains].some((entry) => entry.endsWith(accountSuffix)),
    );
  }

  return chainIds.every((chainId) =>
    authorization.scopes.some(
      (scope) =>
        scope.methods.has("wallet_getAssets") &&
        scope.accountChains.has(
          accountChainKey(normalizeChainId(chainId), account),
        ),
    ),
  );
}

function assetKey(chainId: ChainId, asset: Asset): string {
  const address = asset.address.toLowerCase();
  if (asset.type === "erc721") {
    return `${chainId}:${address}:erc721:${asset.metadata.tokenId}`;
  }
  return `${chainId}:${address}:${asset.type}`;
}

function deduplicate(
  assetsByChain: WalletGetAssetsResponse,
): WalletGetAssetsResponse {
  const result: WalletGetAssetsResponse = {};

  for (const [chainId, assets] of Object.entries(assetsByChain) as [
    ChainId,
    Asset[],
  ][]) {
    const seen = new Set<string>();
    result[chainId] = assets.filter((asset) => {
      const key = assetKey(chainId, asset);
      if (seen.has(key)) return false;
      seen.add(key);
      return true;
    });
  }

  return result;
}

export function filterAssets(
  allAssets: WalletGetAssetsResponse,
  request: WalletGetAssetsRequest,
): WalletGetAssetsResponse {
  const assets = deduplicate(allAssets);

  if (request.assetFilter !== undefined) {
    const result: WalletGetAssetsResponse = {};
    for (const [chainId, identifiers] of Object.entries(
      request.assetFilter,
    ) as [ChainId, AssetIdentifier[]][]) {
      const candidates = assets[chainId] ?? [];
      result[chainId] = candidates.filter((asset) =>
        identifiers.some(
          (identifier) =>
            identifier.type === asset.type &&
            identifier.address.toLowerCase() === asset.address.toLowerCase(),
        ),
      );
    }
    return result;
  }

  const allowedChains = request.chainFilter
    ? new Set(request.chainFilter.map(normalizeChainId))
    : undefined;
  const allowedTypes = request.assetTypeFilter
    ? new Set(request.assetTypeFilter)
    : undefined;
  const result: WalletGetAssetsResponse = {};

  for (const [chainId, chainAssets] of Object.entries(assets) as [
    ChainId,
    Asset[],
  ][]) {
    if (allowedChains && !allowedChains.has(normalizeChainId(chainId))) {
      continue;
    }
    result[chainId] = chainAssets.filter(
      (asset) => !allowedTypes || allowedTypes.has(asset.type),
    );
  }
  return result;
}

export function handleWalletGetAssets(
  params: unknown,
  allAssets: WalletGetAssetsResponse,
  authorization: Authorization,
): WalletGetAssetsResponse {
  const request = parseWalletGetAssetsParams(params);
  const requestedChains = request.assetFilter
    ? (Object.keys(request.assetFilter) as ChainId[])
    : request.chainFilter ?? (Object.keys(allAssets) as ChainId[]);

  if (!isAuthorized(authorization, request.account, requestedChains)) {
    throw new RpcError(4100, "wallet_getAssets is not authorized");
  }
  return filterAssets(allAssets, request);
}

type Provider = {
  request(args: { method: string; params?: unknown }): Promise<unknown>;
};

type CapabilityMap = Record<
  ChainId,
  { assetDiscovery?: { supported?: boolean } }
>;

type DiscoveryResult =
  | { status: "ok"; assets: WalletGetAssetsResponse }
  | { status: "reauthorize" }
  | { status: "fallback" }
  | { status: "reconnect"; chainOnly: boolean }
  | { status: "invalid-request" };

function supportsAssetDiscovery(
  capabilities: CapabilityMap,
  chainId: ChainId,
): boolean {
  if (Object.hasOwn(capabilities, chainId)) {
    return capabilities[chainId]?.assetDiscovery?.supported === true;
  }
  return capabilities["0x0"]?.assetDiscovery?.supported === true;
}

function rpcCode(error: unknown): number | undefined {
  if (typeof error !== "object" || error === null || !("code" in error)) {
    return undefined;
  }
  return typeof error.code === "number" ? error.code : undefined;
}

function validateAsset(value: unknown): Asset {
  if (!isRecord(value) || !isChainId(value.balance) || !isAssetType(value.type)) {
    throw new RpcError(-32602, "wallet returned an invalid asset");
  }

  if (value.type === "native") {
    if (value.address !== "native") {
      throw new RpcError(-32602, "native asset must use the native address");
    }
    return value as NativeAsset;
  }

  if (!isAddress(value.address) || !isRecord(value.metadata)) {
    throw new RpcError(-32602, "token metadata is missing");
  }
  normalizeEvmAddress(value.address);

  const { name, symbol } = value.metadata;
  if (typeof name !== "string" || typeof symbol !== "string") {
    throw new RpcError(-32602, "token name or symbol is invalid");
  }

  if (value.type === "erc20") {
    const decimals = value.metadata.decimals;
    if (typeof decimals !== "number" || !Number.isInteger(decimals) || decimals < 0) {
      throw new RpcError(-32602, "ERC20 decimals is invalid");
    }
    return value as Erc20Asset;
  }

  const { tokenId, tokenURI } = value.metadata;
  if (
    !isChainId(tokenId) ||
    (tokenURI !== undefined && typeof tokenURI !== "string")
  ) {
    throw new RpcError(-32602, "ERC721 metadata is invalid");
  }
  return value as Erc721Asset;
}

export function validateWalletGetAssetsResponse(
  value: unknown,
): WalletGetAssetsResponse {
  if (!isRecord(value)) {
    throw new RpcError(-32602, "wallet returned an invalid response");
  }

  const result: WalletGetAssetsResponse = {};
  for (const [chainId, assets] of Object.entries(value)) {
    if (!isChainId(chainId) || !Array.isArray(assets)) {
      throw new RpcError(-32602, "wallet returned an invalid chain entry");
    }
    result[chainId] = assets.map(validateAsset);
  }
  return result;
}

export async function discoverAssets(
  provider: Provider,
  account: Address,
  chainId: ChainId,
): Promise<DiscoveryResult> {
  const capabilities = (await provider.request({
    method: "wallet_getCapabilities",
    params: [account],
  })) as CapabilityMap;

  if (!supportsAssetDiscovery(capabilities, chainId)) {
    return { status: "fallback" };
  }

  try {
    const assets = await provider.request({
      method: "wallet_getAssets",
      params: [{
        account,
        assetTypeFilter: ["native", "erc20", "erc721"],
        chainFilter: [chainId],
      } satisfies WalletGetAssetsRequest],
    });

    return {
      status: "ok",
      assets: validateWalletGetAssetsResponse(assets),
    };
  } catch (error) {
    switch (rpcCode(error)) {
      case 4100:
        return { status: "reauthorize" };
      case 4200:
        return { status: "fallback" };
      case 4900:
        return { status: "reconnect", chainOnly: false };
      case 4901:
        return { status: "reconnect", chainOnly: true };
      case -32602:
        return { status: "invalid-request" };
      default:
        throw error;
    }
  }
}

import { describe, expect, it, vi } from "vitest";
import {
  addCurrentScope,
  addLegacyScope,
  discoverAssets,
  filterAssets,
  isAuthorized,
  normalizeChainId,
  parseWalletGetAssetsParams,
  validateWalletGetAssetsResponse,
  type WalletGetAssetsResponse,
  type Authorization,
} from "./erc7811";

const ACCOUNT = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";
const OTHER = "0x1111111111111111111111111111111111111111";
const assets: WalletGetAssetsResponse = {
  "0x1": [
    { address: "native", balance: "0x10", type: "native" },
    {
      address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
      balance: "0xf4240",
      type: "erc20",
      metadata: { name: "USD Coin", symbol: "USDC", decimals: 6 },
    },
  ],
  "0xa": [{ address: "native", balance: "0x20", type: "native" }],
};

describe("wallet_getAssets", () => {
  it("1要素のparamsだけを受理する", () => {
    expect(
      parseWalletGetAssetsParams([{ account: ACCOUNT, chainFilter: ["0x1"] }]),
    ).toEqual({ account: ACCOUNT, chainFilter: ["0x1"] });

    expect(() => parseWalletGetAssetsParams({ account: ACCOUNT })).toThrowError(
      expect.objectContaining({ code: -32602 }),
    );
    expect(() => parseWalletGetAssetsParams([{
      account: ACCOUNT,
      assetTypeFilter: ["erc1155"],
    }])).toThrowError(expect.objectContaining({ code: -32602 }));
  });

  it("assetFilterが他の2つのfilterより優先される", () => {
    const result = filterAssets(assets, {
      account: ACCOUNT,
      assetFilter: { "0x1": [{ address: "native", type: "native" }] },
      assetTypeFilter: ["erc20"],
      chainFilter: ["0xa"],
    });

    expect(result).toEqual({
      "0x1": [{ address: "native", balance: "0x10", type: "native" }],
    });
  });

  it("未対応の資産typeを応答として受理しない", () => {
    expect(() => validateWalletGetAssetsResponse({
      "0x1": [{ address: "native", balance: "0x1", type: "erc1155" }],
    })).toThrowError(expect.objectContaining({ code: -32602 }));
  });

  it("hexとdecimalのchain IDを同じ値として比較できる", () => {
    expect(normalizeChainId("0x1")).toBe(1n);
    expect(normalizeChainId("1")).toBe(1n);
    expect(normalizeChainId("0xa")).toBe(10n);
  });

  it("固定版と現行版のaccount表現を同じ認可へ変換する", () => {
    const legacy: Authorization = { scopes: [] };
    addLegacyScope(legacy, {
      methods: ["wallet_getAssets"],
      accounts: [`eip155:1:${ACCOUNT}`, `eip155:10:${OTHER}`],
    });

    const current: Authorization = { scopes: [] };
    addCurrentScope(current, "eip155:1", {
      accounts: [ACCOUNT.toLowerCase()],
      methods: ["wallet_getAssets"],
    });

    expect(isAuthorized(legacy, ACCOUNT, ["0x1"])).toBe(true);
    expect(isAuthorized(legacy, ACCOUNT, ["0xa"])).toBe(false);
    expect(isAuthorized(current, ACCOUNT, ["0x1"])).toBe(true);
    expect(isAuthorized(current, ACCOUNT, ["0xa"])).toBe(false);
    expect(isAuthorized(current, ACCOUNT, [])).toBe(true);

    expect(() => addCurrentScope({ scopes: [] }, "eip155:0", {
      accounts: [ACCOUNT],
      methods: ["wallet_getAssets"],
    })).toThrowError(expect.objectContaining({ code: 4100 }));
  });

  it("別々のscopeにあるmethodとaccountを組み合わせない", () => {
    const authorization: Authorization = { scopes: [] };
    addCurrentScope(authorization, "eip155:1", {
      accounts: [ACCOUNT],
      methods: [],
    });
    addCurrentScope(authorization, "eip155:1", {
      accounts: [OTHER],
      methods: ["wallet_getAssets"],
    });

    expect(isAuthorized(authorization, ACCOUNT, ["0x1"])).toBe(false);
  });

  it("対象chainと0x0のcapabilityを順に確認する", async () => {
    const provider = {
      request: vi.fn()
        .mockResolvedValueOnce({ "0x0": { assetDiscovery: { supported: true } } })
        .mockResolvedValueOnce({ "0x1": [] }),
    };

    await expect(discoverAssets(provider, ACCOUNT, "0x1")).resolves.toEqual({
      status: "ok",
      assets: { "0x1": [] },
    });
  });

  it("対象chainのfalseを0x0のtrueで上書きしない", async () => {
    const provider = {
      request: vi.fn().mockResolvedValueOnce({
        "0x1": { assetDiscovery: { supported: false } },
        "0x0": { assetDiscovery: { supported: true } },
      }),
    };

    await expect(discoverAssets(provider, ACCOUNT, "0x1")).resolves.toEqual({
      status: "fallback",
    });
    expect(provider.request).toHaveBeenCalledTimes(1);
  });

  it.each([
    [4100, { status: "reauthorize" }],
    [4200, { status: "fallback" }],
    [4900, { status: "reconnect", chainOnly: false }],
    [4901, { status: "reconnect", chainOnly: true }],
    [-32602, { status: "invalid-request" }],
  ])("error code %sを別の結果へ変換する", async (code, expected) => {
    const provider = {
      request: vi.fn()
        .mockResolvedValueOnce({ "0x1": { assetDiscovery: { supported: true } } })
        .mockRejectedValueOnce({ code }),
    };

    await expect(discoverAssets(provider, ACCOUNT, "0x1")).resolves.toEqual(expected);
  });
});