diff --git a/ensawards.org/data/apps/coinbase-exchange/index.ts b/ensawards.org/data/apps/coinbase-exchange/index.ts index 018faa23..f21e2c85 100644 --- a/ensawards.org/data/apps/coinbase-exchange/index.ts +++ b/ensawards.org/data/apps/coinbase-exchange/index.ts @@ -2,6 +2,7 @@ // for additional advice on adding and modifying apps import CoinbaseProject from "data/projects/coinbase"; +import { asInterpretedName } from "enssdk"; import { defineApp } from "../registry.ts"; import { type App, AppTypes } from "../types.ts"; @@ -18,6 +19,7 @@ const CoinbaseExchange: App = { socials: { website: new URL("https://www.coinbase.com"), twitter: new URL("https://x.com/coinbase"), + ens: asInterpretedName("coinbase.eth"), }, icon: CoinbaseIcon, ogImagePath: "coinbase-exchange/og.png", diff --git a/ensawards.org/data/apps/exodus-wallet/benchmarks/index.tsx b/ensawards.org/data/apps/exodus-wallet/benchmarks/index.tsx new file mode 100644 index 00000000..748f985f --- /dev/null +++ b/ensawards.org/data/apps/exodus-wallet/benchmarks/index.tsx @@ -0,0 +1,28 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying app benchmarks + +import ExodusWallet from "data/apps/exodus-wallet"; +import { defineAppBenchmarks } from "data/benchmarks/registry"; +import type { BestPracticeBenchmarks } from "data/ens-best-practices/types"; + +import depositAddresses from "./resolution/deposit-addresses"; +import ensv2ReadyResolution from "./resolution/ensv2-ready-resolution"; + +const benchmarks: BestPracticeBenchmarks = { + // TODO: `Contract Naming` category is temporarily hidden due to unfit content, + // and so are all benchmarks belonging to it. + // We aim to fix it as soon as we have the capacity. + // See: https://github.com/namehash/ensawards/issues/222 + "display-named-smart-contracts-mainnet": { + "mainnet-interactions-display-named-smart-contracts": undefined, + }, + "display-named-smart-contracts-l2-chains": { + "l2-chain-interactions-display-named-smart-contracts": undefined, + }, + "ensv2-ready-resolution": ensv2ReadyResolution, + "deposit-addresses": depositAddresses, +}; + +defineAppBenchmarks(ExodusWallet, benchmarks); + +export default benchmarks; diff --git a/ensawards.org/data/apps/exodus-wallet/benchmarks/resolution/deposit-addresses/at-1.png b/ensawards.org/data/apps/exodus-wallet/benchmarks/resolution/deposit-addresses/at-1.png new file mode 100644 index 00000000..6e256312 Binary files /dev/null and b/ensawards.org/data/apps/exodus-wallet/benchmarks/resolution/deposit-addresses/at-1.png differ diff --git a/ensawards.org/data/apps/exodus-wallet/benchmarks/resolution/deposit-addresses/index.tsx b/ensawards.org/data/apps/exodus-wallet/benchmarks/resolution/deposit-addresses/index.tsx new file mode 100644 index 00000000..00e32b2e --- /dev/null +++ b/ensawards.org/data/apps/exodus-wallet/benchmarks/resolution/deposit-addresses/index.tsx @@ -0,0 +1,80 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying app benchmarks + +import { type AcceptanceTestBenchmarks, BenchmarkResults } from "data/benchmarks/types"; +import contributors from "data/contributors"; +import { + buildEnsNotSupportedNote, + buildNotApplicableForFailedTest, +} from "data/ens-best-practices/resolution/deposit-addresses/notes"; + +import { parseTimestamp } from "@ensnode/ensnode-sdk"; + +import at1Proof from "./at-1.png"; + +const depositAddresses = { + "at01-resolve-onchain-name": { + result: BenchmarkResults.Fail, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildEnsNotSupportedNote({ + method: 'the "send" flow', + proof: { + image: at1Proof, + alt: "Exodus Wallet doesn't allow ENS names as the recipient in the send flow", + }, + }), + }, + "at02-resolve-name-needing-normalization": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at03-resolve-offchain-eth-subname": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at04-resolve-offchain-dns-name": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at05-resolve-name-on-other-evm-chain": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at06-resolve-bitcoin-address": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at07-resolve-solana-address": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at08-handle-invalid-address-format": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, +} as const satisfies AcceptanceTestBenchmarks; + +export default depositAddresses; diff --git a/ensawards.org/data/apps/exodus-wallet/benchmarks/resolution/ensv2-ready-resolution/at-1.png b/ensawards.org/data/apps/exodus-wallet/benchmarks/resolution/ensv2-ready-resolution/at-1.png new file mode 100644 index 00000000..77fcb42d Binary files /dev/null and b/ensawards.org/data/apps/exodus-wallet/benchmarks/resolution/ensv2-ready-resolution/at-1.png differ diff --git a/ensawards.org/data/apps/exodus-wallet/benchmarks/resolution/ensv2-ready-resolution/index.tsx b/ensawards.org/data/apps/exodus-wallet/benchmarks/resolution/ensv2-ready-resolution/index.tsx new file mode 100644 index 00000000..df5991d1 --- /dev/null +++ b/ensawards.org/data/apps/exodus-wallet/benchmarks/resolution/ensv2-ready-resolution/index.tsx @@ -0,0 +1,44 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying app benchmarks + +import type { AcceptanceTestBenchmark } from "data/acceptance-tests/types"; +import type { AcceptanceTestBenchmarks } from "data/benchmarks/types"; +import { BenchmarkResults } from "data/benchmarks/types"; +import contributors from "data/contributors"; +import { acceptanceTestDetailsContainerStyles } from "data/ens-best-practices/styles"; + +import { parseTimestamp } from "@ensnode/ensnode-sdk"; + +import { cn } from "@/utils/tailwindClassConcatenation"; + +import at1Proof from "./at-1.png"; + +const ensv2ReadyResolution = { + "correctly-resolve-ensv2-test-name-address": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.caldonia, lastUpdated: parseTimestamp("2026-06-17T03:14:00Z") }, + ], + notes: ( +
+

+ ENSv2 ready resolution was tested using the "send" flow. The wallet doesn't + support the use of ENS names at all as the recipient identifier. +
+
+ While that's a key issue that this app is encouraged to improve, this best practice is + applicable specifically to apps that already have an existing ENS integration and making + sure existing integrations are ENSv2 compatible. Therefore, for this best practice we + apply a rating of not applicable. +

+ Exodus doesn't allow ENS name as recipient in the send flow +
+ ), + } as const satisfies AcceptanceTestBenchmark, +} as const satisfies AcceptanceTestBenchmarks; + +export default ensv2ReadyResolution; diff --git a/ensawards.org/data/apps/exodus-wallet/icon.tsx b/ensawards.org/data/apps/exodus-wallet/icon.tsx new file mode 100644 index 00000000..e238f86a --- /dev/null +++ b/ensawards.org/data/apps/exodus-wallet/icon.tsx @@ -0,0 +1,102 @@ +import React from "react"; + +import { cn } from "@/utils/tailwindClassConcatenation"; + +const Icon = ({ className, ...props }: React.SVGProps) => { + const reactId = React.useId(); + const id = (name: string) => `${reactId}-${name}`; + const url = (name: string) => `url(#${id(name)})`; + + return ( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ); +}; + +export default Icon; diff --git a/ensawards.org/data/apps/exodus-wallet/index.ts b/ensawards.org/data/apps/exodus-wallet/index.ts new file mode 100644 index 00000000..d8e82e57 --- /dev/null +++ b/ensawards.org/data/apps/exodus-wallet/index.ts @@ -0,0 +1,28 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying apps + +import ExodusProject from "data/projects/exodus/index.ts"; + +import { defineApp } from "../registry.ts"; +import { type App, AppTypes } from "../types.ts"; +import ExodusWalletIcon from "./icon.tsx"; + +const ExodusWallet: App = { + id: "exodus-wallet", + appSlug: "exodus-wallet", + type: AppTypes.Wallet, + project: ExodusProject, + name: "Exodus", + description: + "A self-custodial crypto wallet for desktop, mobile, and web3 to send, manage, swap, and stake digital assets, with hardware wallet support and a debit card for spending worldwide.", + socials: { + website: new URL("https://www.exodus.com/"), + twitter: new URL("https://x.com/exodus"), + }, + icon: ExodusWalletIcon, + // TODO: Add OG images +}; + +defineApp(ExodusWallet); + +export default ExodusWallet; diff --git a/ensawards.org/data/apps/hyperliquid-defi/benchmarks/index.tsx b/ensawards.org/data/apps/hyperliquid-defi/benchmarks/index.tsx new file mode 100644 index 00000000..fac84186 --- /dev/null +++ b/ensawards.org/data/apps/hyperliquid-defi/benchmarks/index.tsx @@ -0,0 +1,28 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying app benchmarks + +import HyperliquidDeFi from "data/apps/hyperliquid-defi"; +import { defineAppBenchmarks } from "data/benchmarks/registry"; +import type { BestPracticeBenchmarks } from "data/ens-best-practices/types"; + +import depositAddresses from "./resolution/deposit-addresses"; +import ensv2ReadyResolution from "./resolution/ensv2-ready-resolution"; + +const benchmarks: BestPracticeBenchmarks = { + // TODO: `Contract Naming` category is temporarily hidden due to unfit content, + // and so are all benchmarks belonging to it. + // We aim to fix it as soon as we have the capacity. + // See: https://github.com/namehash/ensawards/issues/222 + "display-named-smart-contracts-mainnet": { + "mainnet-interactions-display-named-smart-contracts": undefined, + }, + "display-named-smart-contracts-l2-chains": { + "l2-chain-interactions-display-named-smart-contracts": undefined, + }, + "ensv2-ready-resolution": ensv2ReadyResolution, + "deposit-addresses": depositAddresses, +}; + +defineAppBenchmarks(HyperliquidDeFi, benchmarks); + +export default benchmarks; diff --git a/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/deposit-addresses/at-1-explorer.gif b/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/deposit-addresses/at-1-explorer.gif new file mode 100644 index 00000000..24e9f946 Binary files /dev/null and b/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/deposit-addresses/at-1-explorer.gif differ diff --git a/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/deposit-addresses/at-1-withdraw.png b/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/deposit-addresses/at-1-withdraw.png new file mode 100644 index 00000000..69291497 Binary files /dev/null and b/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/deposit-addresses/at-1-withdraw.png differ diff --git a/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/deposit-addresses/index.tsx b/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/deposit-addresses/index.tsx new file mode 100644 index 00000000..fbe0e3ef --- /dev/null +++ b/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/deposit-addresses/index.tsx @@ -0,0 +1,100 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying app benchmarks + +import { type AcceptanceTestBenchmarks, BenchmarkResults } from "data/benchmarks/types"; +import contributors from "data/contributors"; +import { + buildBenchmarkNote, + buildNotApplicableForFailedTest, +} from "data/ens-best-practices/resolution/deposit-addresses/notes"; +import { + vitalikAddressSpan, + vitalikEnsNameSpan, +} from "data/ens-best-practices/resolution/deposit-addresses/technicalDetails"; + +import { parseTimestamp } from "@ensnode/ensnode-sdk"; + +import at1ExplorerProof from "./at-1-explorer.gif"; +import at1WithdrawProof from "./at-1-withdraw.png"; + +const depositAddresses = { + "at01-resolve-onchain-name": { + result: BenchmarkResults.Fail, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T07:43:31Z") }, + ], + notes: buildBenchmarkNote({ + children: ( + <> + Tested using the "withdraw" flow, and the "explorer" feature of the Hyperliquid app. +
+
+ Both of them don't support the use of ENS names at all as the recipient or user + identifier, so they never resolve the expected Ethereum Mainnet address of{" "} + {vitalikEnsNameSpan} ({vitalikAddressSpan}), which we classify as a failure. + + ), + proof: [ + { + image: at1WithdrawProof, + alt: "Hyperliquid DeFi app doesn't allow ENS names as the recipient in the withdraw flow", + }, + { + image: at1ExplorerProof, + alt: "Hyperliquid DeFi app doesn't allow ENS names as the user in the explorer feature", + }, + ], + }), + }, + "at02-resolve-name-needing-normalization": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T07:43:31Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at03-resolve-offchain-eth-subname": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T07:43:31Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at04-resolve-offchain-dns-name": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T07:43:31Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at05-resolve-name-on-other-evm-chain": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T07:43:31Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at06-resolve-bitcoin-address": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T07:43:31Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at07-resolve-solana-address": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T07:43:31Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at08-handle-invalid-address-format": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T07:43:31Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, +} as const satisfies AcceptanceTestBenchmarks; + +export default depositAddresses; diff --git a/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/ensv2-ready-resolution/at-1-explorer.gif b/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/ensv2-ready-resolution/at-1-explorer.gif new file mode 100644 index 00000000..293eb922 Binary files /dev/null and b/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/ensv2-ready-resolution/at-1-explorer.gif differ diff --git a/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/ensv2-ready-resolution/at-1-withdraw.png b/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/ensv2-ready-resolution/at-1-withdraw.png new file mode 100644 index 00000000..69291497 Binary files /dev/null and b/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/ensv2-ready-resolution/at-1-withdraw.png differ diff --git a/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/ensv2-ready-resolution/index.tsx b/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/ensv2-ready-resolution/index.tsx new file mode 100644 index 00000000..566cb86a --- /dev/null +++ b/ensawards.org/data/apps/hyperliquid-defi/benchmarks/resolution/ensv2-ready-resolution/index.tsx @@ -0,0 +1,61 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying app benchmarks + +import type { AcceptanceTestBenchmark } from "data/acceptance-tests/types"; +import type { AcceptanceTestBenchmarks } from "data/benchmarks/types"; +import { BenchmarkResults } from "data/benchmarks/types"; +import contributors from "data/contributors"; +import { acceptanceTestDetailsContainerStyles } from "data/ens-best-practices/styles"; + +import { parseTimestamp } from "@ensnode/ensnode-sdk"; + +import { cn } from "@/utils/tailwindClassConcatenation"; + +import at1ExplorerProof from "./at-1-explorer.gif"; +import at1WithdrawProof from "./at-1-withdraw.png"; + +const ensv2ReadyResolution = { + "correctly-resolve-ensv2-test-name-address": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T09:30:00Z") }, + ], + notes: ( +
+

+ ENSv2 ready resolution was tested using the search tool in the "withdraw" flow. + The app doesn't support the use of ENS names at all as the recipient identifier. +
+
+ While that's a key issue that this app is encouraged to improve, this best practice is + applicable specifically to apps that already have an existing ENS integration and making + sure existing integrations are ENSv2 compatible. Therefore, for this best practice we + apply a rating of not applicable. +

+ Hyperliquid DeFi app doesn't allow ENS name as recipient in the withdraw flow + +

+ The ENSv2 ready resolution was also tested using the "explorer" feature. The app + doesn't support the use of ENS names at all as the trader identifier. +
+
+ While that's a key issue that this app is encouraged to improve, this best practice is + applicable specifically to apps that already have an existing ENS integration and making + sure existing integrations are ENSv2 compatible. Therefore, for this best practice we + apply a rating of not applicable. +

+ Hyperliquid DeFi app doesn't allow ENS name as trader in the explorer feature +
+ ), + } as const satisfies AcceptanceTestBenchmark, +} as const satisfies AcceptanceTestBenchmarks; + +export default ensv2ReadyResolution; diff --git a/ensawards.org/data/apps/hyperliquid-defi/icon.tsx b/ensawards.org/data/apps/hyperliquid-defi/icon.tsx new file mode 100644 index 00000000..55d30322 --- /dev/null +++ b/ensawards.org/data/apps/hyperliquid-defi/icon.tsx @@ -0,0 +1,22 @@ +import React from "react"; + +import { cn } from "@/utils/tailwindClassConcatenation"; + +const Icon = ({ className, ...props }: React.SVGProps) => ( + + + +); + +export default Icon; diff --git a/ensawards.org/data/apps/hyperliquid-defi/index.ts b/ensawards.org/data/apps/hyperliquid-defi/index.ts new file mode 100644 index 00000000..9f14fd2f --- /dev/null +++ b/ensawards.org/data/apps/hyperliquid-defi/index.ts @@ -0,0 +1,28 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying apps + +import HyperliquidProject from "data/projects/hyperliquid/index.ts"; + +import { defineApp } from "../registry.ts"; +import { type App, AppTypes } from "../types.ts"; +import HyperliquidIcon from "./icon.tsx"; + +const HyperliquidDeFi: App = { + id: "hyperliquid-defi", + appSlug: "hyperliquid-defi", + type: AppTypes.DeFi, + project: HyperliquidProject, + name: "Hyperliquid", + description: + "A decentralized perpetual futures and spot trading app built on the Hyperliquid layer-1 blockchain, offering onchain order-book trading with deep liquidity and low fees.", + socials: { + website: new URL("https://app.hyperliquid.xyz/"), + twitter: new URL("https://x.com/HyperliquidX"), + }, + icon: HyperliquidIcon, + // TODO: Add OG images +}; + +defineApp(HyperliquidDeFi); + +export default HyperliquidDeFi; diff --git a/ensawards.org/data/apps/pendle-defi/benchmarks/index.tsx b/ensawards.org/data/apps/pendle-defi/benchmarks/index.tsx new file mode 100644 index 00000000..d9da0bf6 --- /dev/null +++ b/ensawards.org/data/apps/pendle-defi/benchmarks/index.tsx @@ -0,0 +1,28 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying app benchmarks + +import PendleDeFi from "data/apps/pendle-defi"; +import { defineAppBenchmarks } from "data/benchmarks/registry"; +import type { BestPracticeBenchmarks } from "data/ens-best-practices/types"; + +import depositAddresses from "./resolution/deposit-addresses"; +import ensv2ReadyResolution from "./resolution/ensv2-ready-resolution"; + +const benchmarks: BestPracticeBenchmarks = { + // TODO: `Contract Naming` category is temporarily hidden due to unfit content, + // and so are all benchmarks belonging to it. + // We aim to fix it as soon as we have the capacity. + // See: https://github.com/namehash/ensawards/issues/222 + "display-named-smart-contracts-mainnet": { + "mainnet-interactions-display-named-smart-contracts": undefined, + }, + "display-named-smart-contracts-l2-chains": { + "l2-chain-interactions-display-named-smart-contracts": undefined, + }, + "ensv2-ready-resolution": ensv2ReadyResolution, + "deposit-addresses": depositAddresses, +}; + +defineAppBenchmarks(PendleDeFi, benchmarks); + +export default benchmarks; diff --git a/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/deposit-addresses/at-1-boros.gif b/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/deposit-addresses/at-1-boros.gif new file mode 100644 index 00000000..bed6e0be Binary files /dev/null and b/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/deposit-addresses/at-1-boros.gif differ diff --git a/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/deposit-addresses/at-1-v2.gif b/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/deposit-addresses/at-1-v2.gif new file mode 100644 index 00000000..30294830 Binary files /dev/null and b/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/deposit-addresses/at-1-v2.gif differ diff --git a/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/deposit-addresses/index.tsx b/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/deposit-addresses/index.tsx new file mode 100644 index 00000000..9efb4372 --- /dev/null +++ b/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/deposit-addresses/index.tsx @@ -0,0 +1,119 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying app benchmarks + +import { type AcceptanceTestBenchmarks, BenchmarkResults } from "data/benchmarks/types"; +import contributors from "data/contributors"; +import { + buildBenchmarkNote, + buildNotApplicableForFailedTest, +} from "data/ens-best-practices/resolution/deposit-addresses/notes"; +import { + vitalikAddressSpan, + vitalikEnsNameSpan, +} from "data/ens-best-practices/resolution/deposit-addresses/technicalDetails"; +import { bestPracticeTechnicalDetailsLinkStyles } from "data/ens-best-practices/styles"; + +import { parseTimestamp } from "@ensnode/ensnode-sdk"; + +import at1BorosProof from "./at-1-boros.gif"; +import at1V2Proof from "./at-1-v2.gif"; + +const depositAddresses = { + "at01-resolve-onchain-name": { + result: BenchmarkResults.Fail, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildBenchmarkNote({ + children: ( + <> + Tested using the "send" flow for the Pendle's{" "} + + Boros + {" "} + app, and the "dashboard" tool for the{" "} + + V2 + {" "} + app. +
+
+ Both of them don't support the use of ENS names at all as the recipient or user + identifier, so they never resolve the expected Ethereum Mainnet address of{" "} + {vitalikEnsNameSpan} ({vitalikAddressSpan}), which we classify as a failure. + + ), + proof: [ + { + image: at1BorosProof, + alt: "Pendle Boros DeFi app doesn't allow ENS names as the recipient in the send flow", + }, + { + image: at1V2Proof, + alt: "Pendle V2 DeFi app doesn't allow ENS names as the user in the dashboard tool", + }, + ], + }), + }, + "at02-resolve-name-needing-normalization": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at03-resolve-offchain-eth-subname": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at04-resolve-offchain-dns-name": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at05-resolve-name-on-other-evm-chain": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at06-resolve-bitcoin-address": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at07-resolve-solana-address": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at08-handle-invalid-address-format": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, +} as const satisfies AcceptanceTestBenchmarks; + +export default depositAddresses; diff --git a/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/ensv2-ready-resolution/at-1-boros.gif b/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/ensv2-ready-resolution/at-1-boros.gif new file mode 100644 index 00000000..41cfc9dc Binary files /dev/null and b/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/ensv2-ready-resolution/at-1-boros.gif differ diff --git a/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/ensv2-ready-resolution/at-1-v2.gif b/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/ensv2-ready-resolution/at-1-v2.gif new file mode 100644 index 00000000..5e69f294 Binary files /dev/null and b/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/ensv2-ready-resolution/at-1-v2.gif differ diff --git a/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/ensv2-ready-resolution/index.tsx b/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/ensv2-ready-resolution/index.tsx new file mode 100644 index 00000000..321345ca --- /dev/null +++ b/ensawards.org/data/apps/pendle-defi/benchmarks/resolution/ensv2-ready-resolution/index.tsx @@ -0,0 +1,82 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying app benchmarks + +import type { AcceptanceTestBenchmark } from "data/acceptance-tests/types"; +import type { AcceptanceTestBenchmarks } from "data/benchmarks/types"; +import { BenchmarkResults } from "data/benchmarks/types"; +import contributors from "data/contributors"; +import { + acceptanceTestDetailsContainerStyles, + bestPracticeTechnicalDetailsLinkStyles, +} from "data/ens-best-practices/styles"; + +import { parseTimestamp } from "@ensnode/ensnode-sdk"; + +import { cn } from "@/utils/tailwindClassConcatenation"; + +import at1BorosProof from "./at-1-boros.gif"; +import at1V2AppProof from "./at-1-v2.gif"; + +const ensv2ReadyResolution = { + "correctly-resolve-ensv2-test-name-address": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-18T13:40:40Z") }, + ], + notes: ( +
+

+ ENSv2 ready resolution was tested using the search tool in the "send" flow of + the Pendle's{" "} + + Boros + {" "} + app. The app doesn't support the use of ENS names at all as the recipient identifier. +
+
+ While that's a key issue that this app is encouraged to improve, this best practice is + applicable specifically to apps that already have an existing ENS integration and making + sure existing integrations are ENSv2 compatible. Therefore, for this best practice we + apply a rating of not applicable. +

+ Pendle Boros DeFi app doesn't allow ENS name as recipient in the send flow + +

+ The ENSv2 ready resolution was also tested using the "dashboard" tool of the + Pendle's{" "} + + V2 + {" "} + app. The app doesn't support the use of ENS names at all as the user identifier. +
+
+ While that's a key issue that this app is encouraged to improve, this best practice is + applicable specifically to apps that already have an existing ENS integration and making + sure existing integrations are ENSv2 compatible. Therefore, for this best practice we + apply a rating of not applicable. +

+ Pendle V2 DeFi app doesn't allow ENS name as user in the dashboard tool +
+ ), + } as const satisfies AcceptanceTestBenchmark, +} as const satisfies AcceptanceTestBenchmarks; + +export default ensv2ReadyResolution; diff --git a/ensawards.org/data/apps/pendle-defi/icon.tsx b/ensawards.org/data/apps/pendle-defi/icon.tsx new file mode 100644 index 00000000..484a8973 --- /dev/null +++ b/ensawards.org/data/apps/pendle-defi/icon.tsx @@ -0,0 +1,21 @@ +import React from "react"; + +const Icon = (props: React.SVGProps) => ( + + + + + +); + +export default Icon; diff --git a/ensawards.org/data/apps/pendle-defi/index.ts b/ensawards.org/data/apps/pendle-defi/index.ts new file mode 100644 index 00000000..7af7eecf --- /dev/null +++ b/ensawards.org/data/apps/pendle-defi/index.ts @@ -0,0 +1,28 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying apps + +import PendleProject from "data/projects/pendle/index.ts"; + +import { defineApp } from "../registry.ts"; +import { type App, AppTypes } from "../types.ts"; +import PendleIcon from "./icon.tsx"; + +const PendleDeFi: App = { + id: "pendle-defi", + appSlug: "pendle-defi", + type: AppTypes.DeFi, + project: PendleProject, + name: "Pendle", + description: + "A crypto yield trading app spanning two products: Boros, for margin trading yield with leverage, and Pendle V2, for trading spot yield and earning fixed yield.", + socials: { + website: new URL("https://www.pendle.finance/"), + twitter: new URL("https://x.com/pendle_fi"), + }, + icon: PendleIcon, + // TODO: Add OG images +}; + +defineApp(PendleDeFi); + +export default PendleDeFi; diff --git a/ensawards.org/data/apps/polymarket-defi/benchmarks/contract-naming/display-named-smart-contracts-l2-chains/index.tsx b/ensawards.org/data/apps/polymarket-defi/benchmarks/contract-naming/display-named-smart-contracts-l2-chains/index.tsx new file mode 100644 index 00000000..7812e2d3 --- /dev/null +++ b/ensawards.org/data/apps/polymarket-defi/benchmarks/contract-naming/display-named-smart-contracts-l2-chains/index.tsx @@ -0,0 +1,14 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying app benchmarks + +import type { AcceptanceTestBenchmarks } from "data/benchmarks/types"; + +// TODO: `Contract Naming` category is temporarily hidden due to unfit content, +// and so are all benchmarks belonging to it. +// We aim to fix it as soon as we have the capacity. +// See: https://github.com/namehash/ensawards/issues/222 +const displayNamedSmartContractsL2Chains = { + "l2-chain-interactions-display-named-smart-contracts": undefined, +} as const satisfies AcceptanceTestBenchmarks; + +export default displayNamedSmartContractsL2Chains; diff --git a/ensawards.org/data/apps/polymarket-defi/benchmarks/contract-naming/display-named-smart-contracts-mainnet/index.tsx b/ensawards.org/data/apps/polymarket-defi/benchmarks/contract-naming/display-named-smart-contracts-mainnet/index.tsx new file mode 100644 index 00000000..31f47c55 --- /dev/null +++ b/ensawards.org/data/apps/polymarket-defi/benchmarks/contract-naming/display-named-smart-contracts-mainnet/index.tsx @@ -0,0 +1,14 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying app benchmarks + +import type { AcceptanceTestBenchmarks } from "data/benchmarks/types"; + +// TODO: `Contract Naming` category is temporarily hidden due to unfit content, +// and so are all benchmarks belonging to it. +// We aim to fix it as soon as we have the capacity. +// See: https://github.com/namehash/ensawards/issues/222 +const displayNamedSmartContractsMainnet = { + "mainnet-interactions-display-named-smart-contracts": undefined, +} as const satisfies AcceptanceTestBenchmarks; + +export default displayNamedSmartContractsMainnet; diff --git a/ensawards.org/data/apps/polymarket-defi/benchmarks/index.tsx b/ensawards.org/data/apps/polymarket-defi/benchmarks/index.tsx new file mode 100644 index 00000000..ce9b68e3 --- /dev/null +++ b/ensawards.org/data/apps/polymarket-defi/benchmarks/index.tsx @@ -0,0 +1,26 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying app benchmarks + +import PolymarketDeFi from "data/apps/polymarket-defi"; +import { defineAppBenchmarks } from "data/benchmarks/registry"; +import type { BestPracticeBenchmarks } from "data/ens-best-practices/types"; + +import displayNamedSmartContractsL2Chains from "./contract-naming/display-named-smart-contracts-l2-chains"; +import displayNamedSmartContractsMainnet from "./contract-naming/display-named-smart-contracts-mainnet"; +import depositAddresses from "./resolution/deposit-addresses"; +import ensv2ReadyResolution from "./resolution/ensv2-ready-resolution"; + +const benchmarks: BestPracticeBenchmarks = { + // TODO: `Contract Naming` category is temporarily hidden due to unfit content, + // and so are all benchmarks belonging to it. + // We aim to fix it as soon as we have the capacity. + // See: https://github.com/namehash/ensawards/issues/222 + "display-named-smart-contracts-mainnet": displayNamedSmartContractsMainnet, + "display-named-smart-contracts-l2-chains": displayNamedSmartContractsL2Chains, + "ensv2-ready-resolution": ensv2ReadyResolution, + "deposit-addresses": depositAddresses, +}; + +defineAppBenchmarks(PolymarketDeFi, benchmarks); + +export default benchmarks; diff --git a/ensawards.org/data/apps/polymarket-defi/benchmarks/resolution/deposit-addresses/at-1.gif b/ensawards.org/data/apps/polymarket-defi/benchmarks/resolution/deposit-addresses/at-1.gif new file mode 100644 index 00000000..c43be6bb Binary files /dev/null and b/ensawards.org/data/apps/polymarket-defi/benchmarks/resolution/deposit-addresses/at-1.gif differ diff --git a/ensawards.org/data/apps/polymarket-defi/benchmarks/resolution/deposit-addresses/index.tsx b/ensawards.org/data/apps/polymarket-defi/benchmarks/resolution/deposit-addresses/index.tsx new file mode 100644 index 00000000..477788e7 --- /dev/null +++ b/ensawards.org/data/apps/polymarket-defi/benchmarks/resolution/deposit-addresses/index.tsx @@ -0,0 +1,91 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying app benchmarks + +import { type AcceptanceTestBenchmarks, BenchmarkResults } from "data/benchmarks/types"; +import contributors from "data/contributors"; +import { + buildBenchmarkNote, + buildNotApplicableForFailedTest, +} from "data/ens-best-practices/resolution/deposit-addresses/notes"; +import { + vitalikAddressSpan, + vitalikEnsNameSpan, +} from "data/ens-best-practices/resolution/deposit-addresses/technicalDetails"; + +import { parseTimestamp } from "@ensnode/ensnode-sdk"; + +import at1Proof from "./at-1.gif"; + +const depositAddresses = { + "at01-resolve-onchain-name": { + result: BenchmarkResults.Fail, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T08:34:33Z") }, + ], + notes: buildBenchmarkNote({ + children: ( + <> + Tested using the "leaderboard" feature. It doesn't support the use of ENS names at all as + the user identifier, so it never resolves the expected Ethereum Mainnet address of{" "} + {vitalikEnsNameSpan} ({vitalikAddressSpan} + ), which we classify as a failure. + + ), + proof: { + image: at1Proof, + alt: "Polymarket DeFi app doesn't resolve ENS names in the leaderboard feature", + }, + }), + }, + "at02-resolve-name-needing-normalization": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T08:34:33Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at03-resolve-offchain-eth-subname": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T08:34:33Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at04-resolve-offchain-dns-name": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T08:34:33Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at05-resolve-name-on-other-evm-chain": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T08:34:33Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at06-resolve-bitcoin-address": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T08:34:33Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at07-resolve-solana-address": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T08:34:33Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, + "at08-handle-invalid-address-format": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T08:34:33Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 1 }), + }, +} as const satisfies AcceptanceTestBenchmarks; + +export default depositAddresses; diff --git a/ensawards.org/data/apps/polymarket-defi/benchmarks/resolution/ensv2-ready-resolution/at-1.gif b/ensawards.org/data/apps/polymarket-defi/benchmarks/resolution/ensv2-ready-resolution/at-1.gif new file mode 100644 index 00000000..2baabb48 Binary files /dev/null and b/ensawards.org/data/apps/polymarket-defi/benchmarks/resolution/ensv2-ready-resolution/at-1.gif differ diff --git a/ensawards.org/data/apps/polymarket-defi/benchmarks/resolution/ensv2-ready-resolution/index.tsx b/ensawards.org/data/apps/polymarket-defi/benchmarks/resolution/ensv2-ready-resolution/index.tsx new file mode 100644 index 00000000..5893aee4 --- /dev/null +++ b/ensawards.org/data/apps/polymarket-defi/benchmarks/resolution/ensv2-ready-resolution/index.tsx @@ -0,0 +1,43 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying app benchmarks + +import type { AcceptanceTestBenchmark } from "data/acceptance-tests/types"; +import { type AcceptanceTestBenchmarks, BenchmarkResults } from "data/benchmarks/types"; +import contributors from "data/contributors"; +import { acceptanceTestDetailsContainerStyles } from "data/ens-best-practices/styles"; + +import { parseTimestamp } from "@ensnode/ensnode-sdk"; + +import { cn } from "@/utils/tailwindClassConcatenation"; + +import at1Proof from "./at-1.gif"; + +const ensv2ReadyResolution = { + "correctly-resolve-ensv2-test-name-address": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-25T08:26:00Z") }, + ], + notes: ( +
+

+ ENSv2 ready resolution was tested using the "leaderboard" feature. The app + doesn't support the use of ENS names at all as the predictor identifier. +
+
+ While that's a key issue that this app is encouraged to improve, this best practice is + applicable specifically to apps that already have an existing ENS integration and making + sure existing integrations are ENSv2 compatible. Therefore, for this best practice we + apply a rating of not applicable. +

+ Polymarket doesn't allow ENS name as predictor identifier in the leaderboard feature +
+ ), + } as const satisfies AcceptanceTestBenchmark, +} as const satisfies AcceptanceTestBenchmarks; + +export default ensv2ReadyResolution; diff --git a/ensawards.org/data/apps/polymarket-defi/icon.tsx b/ensawards.org/data/apps/polymarket-defi/icon.tsx new file mode 100644 index 00000000..39c66cab --- /dev/null +++ b/ensawards.org/data/apps/polymarket-defi/icon.tsx @@ -0,0 +1,22 @@ +import React from "react"; + +import { cn } from "@/utils/tailwindClassConcatenation"; + +const polymarketIconDataUri = + "data:image/png;base64,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"; + +const Icon = ({ className, ...props }: React.SVGProps) => ( + + + +); + +export default Icon; diff --git a/ensawards.org/data/apps/polymarket-defi/index.ts b/ensawards.org/data/apps/polymarket-defi/index.ts new file mode 100644 index 00000000..e0ec1651 --- /dev/null +++ b/ensawards.org/data/apps/polymarket-defi/index.ts @@ -0,0 +1,28 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying apps + +import PolymarketProject from "data/projects/polymarket/index.ts"; + +import { defineApp } from "../registry.ts"; +import { type App, AppTypes } from "../types.ts"; +import PolymarketIcon from "./icon.tsx"; + +const PolymarketDeFi: App = { + id: "polymarket-defi", + appSlug: "polymarket-defi", + type: AppTypes.DeFi, + project: PolymarketProject, + name: "Polymarket", + description: + "The world's largest prediction market, where users trade on the outcomes of real-world events across politics, news, culture, sports, and tech using cryptocurrency.", + socials: { + website: new URL("https://polymarket.com/"), + twitter: new URL("https://x.com/Polymarket"), + }, + icon: PolymarketIcon, + // TODO: Add OG images +}; + +defineApp(PolymarketDeFi); + +export default PolymarketDeFi; diff --git a/ensawards.org/data/apps/taho-wallet/benchmarks/index.tsx b/ensawards.org/data/apps/taho-wallet/benchmarks/index.tsx new file mode 100644 index 00000000..fce24b20 --- /dev/null +++ b/ensawards.org/data/apps/taho-wallet/benchmarks/index.tsx @@ -0,0 +1,28 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying app benchmarks + +import TahoWallet from "data/apps/taho-wallet"; +import { defineAppBenchmarks } from "data/benchmarks/registry"; +import type { BestPracticeBenchmarks } from "data/ens-best-practices/types"; + +import depositAddresses from "./resolution/deposit-addresses"; +import ensv2ReadyResolution from "./resolution/ensv2-ready-resolution"; + +const benchmarks: BestPracticeBenchmarks = { + // TODO: `Contract Naming` category is temporarily hidden due to unfit content, + // and so are all benchmarks belonging to it. + // We aim to fix it as soon as we have the capacity. + // See: https://github.com/namehash/ensawards/issues/222 + "display-named-smart-contracts-mainnet": { + "mainnet-interactions-display-named-smart-contracts": undefined, + }, + "display-named-smart-contracts-l2-chains": { + "l2-chain-interactions-display-named-smart-contracts": undefined, + }, + "ensv2-ready-resolution": ensv2ReadyResolution, + "deposit-addresses": depositAddresses, +}; + +defineAppBenchmarks(TahoWallet, benchmarks); + +export default benchmarks; diff --git a/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/at-1.png b/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/at-1.png new file mode 100644 index 00000000..aa8dc595 Binary files /dev/null and b/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/at-1.png differ diff --git a/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/at-2.png b/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/at-2.png new file mode 100644 index 00000000..1215dac8 Binary files /dev/null and b/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/at-2.png differ diff --git a/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/at-3.png b/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/at-3.png new file mode 100644 index 00000000..c6e05e99 Binary files /dev/null and b/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/at-3.png differ diff --git a/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/at-4.png b/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/at-4.png new file mode 100644 index 00000000..49f16ae6 Binary files /dev/null and b/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/at-4.png differ diff --git a/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/at-5.gif b/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/at-5.gif new file mode 100644 index 00000000..ba49cdfa Binary files /dev/null and b/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/at-5.gif differ diff --git a/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/index.tsx b/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/index.tsx new file mode 100644 index 00000000..c290bdd1 --- /dev/null +++ b/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/deposit-addresses/index.tsx @@ -0,0 +1,116 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying app benchmarks + +import { type AcceptanceTestBenchmarks, BenchmarkResults } from "data/benchmarks/types"; +import contributors from "data/contributors"; +import { + buildFailNoteForAT4, + buildNotApplicableForEvmChain, + buildNotApplicableForFailedTest, + buildNotApplicableForNonEvmChain, + buildPassNoteForAT1, + buildPassNoteForAT2, + buildPassNoteForAT3, +} from "data/ens-best-practices/resolution/deposit-addresses/notes"; + +import { parseTimestamp } from "@ensnode/ensnode-sdk"; + +import at1Proof from "./at-1.png"; +import at2Proof from "./at-2.png"; +import at3Proof from "./at-3.png"; +import at4Proof from "./at-4.png"; +import at5Proof from "./at-5.gif"; + +const method = 'the "send" flow'; + +const depositAddresses = { + "at01-resolve-onchain-name": { + result: BenchmarkResults.Pass, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildPassNoteForAT1({ + method, + proof: { + image: at1Proof, + alt: "Taho Wallet correctly resolves the address for vitalik.eth", + }, + }), + }, + "at02-resolve-name-needing-normalization": { + result: BenchmarkResults.Pass, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildPassNoteForAT2({ + method, + proof: { + image: at2Proof, + alt: "Taho Wallet correctly resolves the address for Ξthereum.eth", + }, + }), + }, + "at03-resolve-offchain-eth-subname": { + result: BenchmarkResults.Pass, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildPassNoteForAT3({ + method, + proof: { + image: at3Proof, + alt: "Taho Wallet correctly resolves the address for jesse.base.eth", + }, + }), + }, + "at04-resolve-offchain-dns-name": { + result: BenchmarkResults.Fail, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildFailNoteForAT4({ + method, + proof: { + image: at4Proof, + alt: "Taho Wallet fails to resolve the address for dperri.com", + }, + extra: 'The app showed the message "Address could not be found".', + }), + }, + "at05-resolve-name-on-other-evm-chain": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForEvmChain({ + chain: "Base", + proof: { + image: at5Proof, + alt: "Taho Wallet has no context of the Base chain in the send flow", + }, + }), + }, + "at06-resolve-bitcoin-address": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForNonEvmChain({ chain: "Bitcoin" }), + }, + "at07-resolve-solana-address": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForNonEvmChain({ chain: "Solana" }), + }, + "at08-handle-invalid-address-format": { + result: BenchmarkResults.NotApplicable, + contributions: [ + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-24T08:58:52Z") }, + ], + notes: buildNotApplicableForFailedTest({ testNumber: 5, scope: "on Base" }), + }, +} as const satisfies AcceptanceTestBenchmarks; + +export default depositAddresses; diff --git a/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/ensv2-ready-resolution/at-1.png b/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/ensv2-ready-resolution/at-1.png new file mode 100644 index 00000000..018134c4 Binary files /dev/null and b/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/ensv2-ready-resolution/at-1.png differ diff --git a/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/ensv2-ready-resolution/index.tsx b/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/ensv2-ready-resolution/index.tsx new file mode 100644 index 00000000..a0d28550 --- /dev/null +++ b/ensawards.org/data/apps/taho-wallet/benchmarks/resolution/ensv2-ready-resolution/index.tsx @@ -0,0 +1,39 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying app benchmarks + +import type { AcceptanceTestBenchmark } from "data/acceptance-tests/types"; +import type { AcceptanceTestBenchmarks } from "data/benchmarks/types"; +import { BenchmarkResults } from "data/benchmarks/types"; +import contributors from "data/contributors"; +import { acceptanceTestDetailsContainerStyles } from "data/ens-best-practices/styles"; + +import { parseTimestamp } from "@ensnode/ensnode-sdk"; + +import { cn } from "@/utils/tailwindClassConcatenation"; + +import at1Proof from "./at-1.png"; + +const ensv2ReadyResolution = { + "correctly-resolve-ensv2-test-name-address": { + result: BenchmarkResults.Fail, + contributions: [ + { from: contributors.caldonia, lastUpdated: parseTimestamp("2026-06-17T03:03:00Z") }, + { from: contributors.y3drk, lastUpdated: parseTimestamp("2026-06-18T13:28:00Z") }, + ], + notes: ( +
+

+ ENSv2 ready resolution was tested using the "send" flow. The resolved address is{" "} + NOT correct. +

+ Taho fails to resolve the name for ENSv2 +
+ ), + } as const satisfies AcceptanceTestBenchmark, +} as const satisfies AcceptanceTestBenchmarks; + +export default ensv2ReadyResolution; diff --git a/ensawards.org/data/apps/taho-wallet/icon.tsx b/ensawards.org/data/apps/taho-wallet/icon.tsx new file mode 100644 index 00000000..6263dfae --- /dev/null +++ b/ensawards.org/data/apps/taho-wallet/icon.tsx @@ -0,0 +1,20 @@ +import React from "react"; + +const tahoIconDataUri = + "data:image/png;base64,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"; + +const Icon = ({ className, ...props }: React.SVGProps) => ( + + + +); + +export default Icon; diff --git a/ensawards.org/data/apps/taho-wallet/index.ts b/ensawards.org/data/apps/taho-wallet/index.ts new file mode 100644 index 00000000..0f1df81e --- /dev/null +++ b/ensawards.org/data/apps/taho-wallet/index.ts @@ -0,0 +1,28 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying apps + +import TahoProject from "data/projects/taho/index.ts"; + +import { defineApp } from "../registry.ts"; +import { type App, AppTypes } from "../types.ts"; +import TahoWalletIcon from "./icon.tsx"; + +const TahoWallet: App = { + id: "taho-wallet", + appSlug: "taho-wallet", + type: AppTypes.Wallet, + project: TahoProject, + name: "Taho", + description: + "A community-owned, fully open-source web3 browser extension wallet with NFT galleries, low-cost swaps, and hardware wallet support.", + socials: { + website: new URL("https://taho.xyz/"), + twitter: new URL("https://x.com/taho_xyz"), + }, + icon: TahoWalletIcon, + // TODO: Add OG images +}; + +defineApp(TahoWallet); + +export default TahoWallet; diff --git a/ensawards.org/data/ens-best-practices/resolution/deposit-addresses/notes.tsx b/ensawards.org/data/ens-best-practices/resolution/deposit-addresses/notes.tsx index c2970e9b..96123da0 100644 --- a/ensawards.org/data/ens-best-practices/resolution/deposit-addresses/notes.tsx +++ b/ensawards.org/data/ens-best-practices/resolution/deposit-addresses/notes.tsx @@ -381,6 +381,25 @@ export function buildNotApplicableForNonEvmChain({ }); } +/** The app has no concept of the given EVM chain (for now, Base only). */ +export function buildNotApplicableForEvmChain({ + chain, + proof, +}: { + chain: "Base"; + proof?: ProofInput; +}) { + return buildBenchmarkNote({ + proof, + children: ( + <> + The app doesn't have context of the EVM chain {chain} and therefore we classify this + acceptance test as {notApplicableSpan}. + + ), + }); +} + /** * This test can't be evaluated because a prerequisite acceptance test failed. * `scope` describes what the app doesn't support, e.g. `"at all"` (when Acceptance diff --git a/ensawards.org/data/projects/exodus/icon.tsx b/ensawards.org/data/projects/exodus/icon.tsx new file mode 100644 index 00000000..e238f86a --- /dev/null +++ b/ensawards.org/data/projects/exodus/icon.tsx @@ -0,0 +1,102 @@ +import React from "react"; + +import { cn } from "@/utils/tailwindClassConcatenation"; + +const Icon = ({ className, ...props }: React.SVGProps) => { + const reactId = React.useId(); + const id = (name: string) => `${reactId}-${name}`; + const url = (name: string) => `url(#${id(name)})`; + + return ( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ); +}; + +export default Icon; diff --git a/ensawards.org/data/projects/exodus/index.ts b/ensawards.org/data/projects/exodus/index.ts new file mode 100644 index 00000000..6b0c87ad --- /dev/null +++ b/ensawards.org/data/projects/exodus/index.ts @@ -0,0 +1,23 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying projects + +import { defineProject } from "../registry.ts"; +import type { Project } from "../types.ts"; +import { ProjectIds } from "../types.ts"; +import ExodusIcon from "./icon.tsx"; + +const ExodusProject: Project = { + id: ProjectIds.Exodus, + name: "Exodus", + description: + "A self-custodial crypto wallet for desktop, mobile, and web3 to send, manage, swap, and stake digital assets, with hardware wallet support and a debit card for spending worldwide.", + icon: ExodusIcon, + socials: { + website: new URL("https://www.exodus.com/"), + twitter: new URL("https://x.com/exodus"), + }, +}; + +defineProject(ExodusProject); + +export default ExodusProject; diff --git a/ensawards.org/data/projects/hyperliquid/icon.tsx b/ensawards.org/data/projects/hyperliquid/icon.tsx new file mode 100644 index 00000000..55d30322 --- /dev/null +++ b/ensawards.org/data/projects/hyperliquid/icon.tsx @@ -0,0 +1,22 @@ +import React from "react"; + +import { cn } from "@/utils/tailwindClassConcatenation"; + +const Icon = ({ className, ...props }: React.SVGProps) => ( + + + +); + +export default Icon; diff --git a/ensawards.org/data/projects/hyperliquid/index.ts b/ensawards.org/data/projects/hyperliquid/index.ts new file mode 100644 index 00000000..f25c547e --- /dev/null +++ b/ensawards.org/data/projects/hyperliquid/index.ts @@ -0,0 +1,23 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying projects + +import { defineProject } from "../registry.ts"; +import type { Project } from "../types.ts"; +import { ProjectIds } from "../types.ts"; +import HyperliquidIcon from "./icon.tsx"; + +const HyperliquidProject: Project = { + id: ProjectIds.Hyperliquid, + name: "Hyperliquid", + description: + "A decentralized perpetual futures and spot exchange built on its own high-performance layer-1 blockchain, offering onchain trading with deep liquidity and a fully onchain order book.", + icon: HyperliquidIcon, + socials: { + website: new URL("https://app.hyperliquid.xyz/"), + twitter: new URL("https://x.com/HyperliquidX"), + }, +}; + +defineProject(HyperliquidProject); + +export default HyperliquidProject; diff --git a/ensawards.org/data/projects/pendle/icon.tsx b/ensawards.org/data/projects/pendle/icon.tsx new file mode 100644 index 00000000..484a8973 --- /dev/null +++ b/ensawards.org/data/projects/pendle/icon.tsx @@ -0,0 +1,21 @@ +import React from "react"; + +const Icon = (props: React.SVGProps) => ( + + + + + +); + +export default Icon; diff --git a/ensawards.org/data/projects/pendle/index.ts b/ensawards.org/data/projects/pendle/index.ts new file mode 100644 index 00000000..c0a2bdc5 --- /dev/null +++ b/ensawards.org/data/projects/pendle/index.ts @@ -0,0 +1,23 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying projects + +import { defineProject } from "../registry.ts"; +import type { Project } from "../types.ts"; +import { ProjectIds } from "../types.ts"; +import PendleIcon from "./icon.tsx"; + +const PendleProject: Project = { + id: ProjectIds.Pendle, + name: "Pendle", + description: + "A crypto yield trading platform where users can trade spot yield, earn fixed yield, or take leveraged positions on yield across a wide range of onchain and off-chain assets.", + icon: PendleIcon, + socials: { + website: new URL("https://www.pendle.finance/"), + twitter: new URL("https://x.com/pendle_fi"), + }, +}; + +defineProject(PendleProject); + +export default PendleProject; diff --git a/ensawards.org/data/projects/polymarket/icon.tsx b/ensawards.org/data/projects/polymarket/icon.tsx new file mode 100644 index 00000000..39c66cab --- /dev/null +++ b/ensawards.org/data/projects/polymarket/icon.tsx @@ -0,0 +1,22 @@ +import React from "react"; + +import { cn } from "@/utils/tailwindClassConcatenation"; + +const polymarketIconDataUri = + "data:image/png;base64,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"; + +const Icon = ({ className, ...props }: React.SVGProps) => ( + + + +); + +export default Icon; diff --git a/ensawards.org/data/projects/polymarket/index.ts b/ensawards.org/data/projects/polymarket/index.ts new file mode 100644 index 00000000..6f41ddde --- /dev/null +++ b/ensawards.org/data/projects/polymarket/index.ts @@ -0,0 +1,23 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying projects + +import { defineProject } from "../registry.ts"; +import type { Project } from "../types.ts"; +import { ProjectIds } from "../types.ts"; +import PolymarketIcon from "./icon.tsx"; + +const PolymarketProject: Project = { + id: ProjectIds.Polymarket, + name: "Polymarket", + description: + "The world's largest prediction market, where users trade on the outcomes of real-world events across politics, news, culture, sports, and tech using cryptocurrency.", + icon: PolymarketIcon, + socials: { + website: new URL("https://polymarket.com/"), + twitter: new URL("https://x.com/Polymarket"), + }, +}; + +defineProject(PolymarketProject); + +export default PolymarketProject; diff --git a/ensawards.org/data/projects/taho/icon.tsx b/ensawards.org/data/projects/taho/icon.tsx new file mode 100644 index 00000000..6263dfae --- /dev/null +++ b/ensawards.org/data/projects/taho/icon.tsx @@ -0,0 +1,20 @@ +import React from "react"; + +const tahoIconDataUri = + "data:image/png;base64,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"; + +const Icon = ({ className, ...props }: React.SVGProps) => ( + + + +); + +export default Icon; diff --git a/ensawards.org/data/projects/taho/index.ts b/ensawards.org/data/projects/taho/index.ts new file mode 100644 index 00000000..c0d47cde --- /dev/null +++ b/ensawards.org/data/projects/taho/index.ts @@ -0,0 +1,23 @@ +// Read https://github.com/namehash/ensawards/blob/main/CONTRIBUTING.md +// for additional advice on adding and modifying projects + +import { defineProject } from "../registry.ts"; +import type { Project } from "../types.ts"; +import { ProjectIds } from "../types.ts"; +import TahoIcon from "./icon.tsx"; + +const TahoProject: Project = { + id: ProjectIds.Taho, + name: "Taho", + description: + "A community-owned, fully open-source web3 browser extension wallet with NFT galleries, low-cost swaps, and hardware wallet support.", + icon: TahoIcon, + socials: { + website: new URL("https://taho.xyz/"), + twitter: new URL("https://x.com/taho_xyz"), + }, +}; + +defineProject(TahoProject); + +export default TahoProject; diff --git a/ensawards.org/data/projects/types.ts b/ensawards.org/data/projects/types.ts index 959c1c31..f42d9a01 100644 --- a/ensawards.org/data/projects/types.ts +++ b/ensawards.org/data/projects/types.ts @@ -38,6 +38,11 @@ export const ProjectIds = { Gemini: "project-gemini", Frame: "project-frame", Bybit: "project-bybit", + Exodus: "project-exodus", + Taho: "project-taho", + Pendle: "project-pendle", + Hyperliquid: "project-hyperliquid", + Polymarket: "project-polymarket", } as const; /**