@avaprotocol/sdk-js 4.0.0-dev.1 → 4.0.0-dev.2

package/dist/v4/protocols/index.d.ts

@@ -0,0 +1,132 @@
+export { aaveV3 } from "./aave-v3";
+export { aerodrome } from "./aerodrome";
+export { chainlink } from "./chainlink";
+export { compoundV3 } from "./compound-v3";
+export { erc20 } from "./erc20";
+export { ethena } from "./ethena";
+export { fraxEther } from "./frax-ether";
+export { lido } from "./lido";
+export { morphoBlue } from "./morpho";
+export { rocketPool } from "./rocket-pool";
+export { sky } from "./sky";
+export { spark } from "./spark";
+export { superfluid } from "./superfluid";
+export { uniswapV3 } from "./uniswap-v3";
+export { wrapped } from "./wrapped";
+export { aggregatorV3Abi, erc4626VaultAbi } from "./common";
+export type { AbiFragment, AddressByChain } from "./types";
+/**
+ * Namespace export so callers can do
+ *   `Protocols.aaveV3.pool[Chains.Sepolia]`
+ *   `Protocols.uniswapV3.swapRouter02Abi`
+ * the same way `Nodes.contractRead(...)` is namespaced.
+ *
+ * Protocol naming maps from studio's `protocolId` slug to a
+ * lowerCamelCase property:
+ *   aave-v3       → aaveV3
+ *   compound-v3   → compoundV3
+ *   frax-ether    → fraxEther
+ *   morpho        → morphoBlue (the singleton's product name)
+ *   rocket-pool   → rocketPool
+ *   uniswap-v3    → uniswapV3
+ *   (others)      → same as slug, hyphen → camelCase
+ */
+export declare const Protocols: Readonly<{
+    aaveV3: Readonly<{
+        pool: Partial<Record<number, `0x${string}`>>;
+        oracle: Partial<Record<number, `0x${string}`>>;
+        wethGateway: Partial<Record<number, `0x${string}`>>;
+        eventTopics: Readonly<{
+            readonly Supply: "0x2b627736bca15cd5381dcf80b0bf11fd197d01a037c52b927a881a10fb73ba61";
+            readonly Withdraw: "0x3115d1449a7b732c986cba18244e897a450f61e1bb8d589cd2e69e6c8924f9f7";
+            readonly Borrow: "0xb3d084820fb1a9decffb176436bd02558d15fac9b0ddfed8c465bc7359d7dce0";
+            readonly Repay: "0xa534c8dbe71f871f9f3530e97a74601fea17b426cae02e1c5aee42c96c784051";
+            readonly LiquidationCall: "0xe413a321e8681d831f4dbccbca790d2952b56f977908e45be37335533e005286";
+        }>;
+        poolEventsAbi: readonly import("./types").AbiFragment[];
+        poolMethodsAbi: readonly import("./types").AbiFragment[];
+        tokens: Readonly<{
+            LINK: {
+                11155111: "0xf8Fb3713D459D7C1018BD0A49D19b4C44290EBE5";
+            };
+        }>;
+    }>;
+    aerodrome: Readonly<{
+        router: Partial<Record<number, `0x${string}`>>;
+    }>;
+    chainlink: Readonly<{
+        ethUsdFeed: Partial<Record<number, `0x${string}`>>;
+        btcUsdFeed: Partial<Record<number, `0x${string}`>>;
+        aggregatorV3Abi: readonly import("./types").AbiFragment[];
+    }>;
+    compoundV3: Readonly<{
+        cometUsdc: Partial<Record<number, `0x${string}`>>;
+    }>;
+    erc20: Readonly<{
+        approveAbi: readonly import("./types").AbiFragment[];
+    }>;
+    ethena: Readonly<{
+        susde: Partial<Record<number, `0x${string}`>>;
+        usde: Partial<Record<number, `0x${string}`>>;
+        susdeAbi: readonly import("./types").AbiFragment[];
+    }>;
+    fraxEther: Readonly<{
+        sfrxeth: Partial<Record<number, `0x${string}`>>;
+        frxeth: Partial<Record<number, `0x${string}`>>;
+        vaultAbi: readonly import("./types").AbiFragment[];
+    }>;
+    lido: Readonly<{
+        wsteth: Partial<Record<number, `0x${string}`>>;
+        steth: Partial<Record<number, `0x${string}`>>;
+        wstethAbi: readonly import("./types").AbiFragment[];
+    }>;
+    morphoBlue: Readonly<{
+        morpho: Partial<Record<number, `0x${string}`>>;
+        morphoAbi: readonly import("./types").AbiFragment[];
+    }>;
+    rocketPool: Readonly<{
+        reth: Partial<Record<number, `0x${string}`>>;
+        rethAbi: readonly import("./types").AbiFragment[];
+    }>;
+    sky: Readonly<{
+        sdai: Partial<Record<number, `0x${string}`>>;
+        vaultAbi: readonly import("./types").AbiFragment[];
+    }>;
+    spark: Readonly<{
+        pool: Partial<Record<number, `0x${string}`>>;
+    }>;
+    superfluid: Readonly<{
+        cfaForwarder: Partial<Record<number, `0x${string}`>>;
+        cfaForwarderAbi: readonly import("./types").AbiFragment[];
+    }>;
+    uniswapV3: Readonly<{
+        swapRouter02: Partial<Record<number, `0x${string}`>>;
+        quoterV2: Partial<Record<number, `0x${string}`>>;
+        permit2: Partial<Record<number, `0x${string}`>>;
+        factory: Partial<Record<number, `0x${string}`>>;
+        nonfungiblePositionManager: Partial<Record<number, `0x${string}`>>;
+        universalRouter: Partial<Record<number, `0x${string}`>>;
+        swapRouter02Abi: readonly import("./types").AbiFragment[];
+        quoterV2Abi: readonly import("./types").AbiFragment[];
+        factoryAbi: readonly import("./types").AbiFragment[];
+        tokens: Readonly<{
+            WETH: {
+                11155111: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14";
+                1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
+                8453: "0x4200000000000000000000000000000000000006";
+                84532: "0x4200000000000000000000000000000000000006";
+            };
+            USDC: {
+                11155111: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238";
+                1: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+                8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+                84532: "0x036CbD53842c5426634e7929541eC2318f3dCF7e";
+            };
+        }>;
+    }>;
+    wrapped: Readonly<{
+        weth: Partial<Record<number, `0x${string}`>>;
+        wethAbi: readonly import("./types").AbiFragment[];
+    }>;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/v4/protocols/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/v4/protocols/index.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,GAAG,EAAE,MAAM,OAAO,CAAC;AAC5B,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC5D,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAkB3D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBpB,CAAC"}

package/dist/v4/protocols/index.js

@@ -0,0 +1,87 @@
+// Protocols — the data-only DeFi catalog. Per-protocol per-chain
+// contract addresses, ABI fragments, and event-topic hashes that
+// template authors and tests need without re-deriving or duplicating
+// the same constants across consumers.
+//
+// Why this lives in the SDK:
+// - Template e2e tests (tests/v4/templates/*.test.ts) used to
+//   hard-code the same pool / reserve / router addresses + ABIs
+//   that Studio already maintained. As more v3 templates port over,
+//   the duplication compounds.
+// - Studio's catalog (studio/app/lib/contracts/protocols/) is
+//   currently the canonical source for richer UI metadata, but it
+//   carries UX shape (slug / label / description / KnownProtocol
+//   envelopes / ProtocolActionInput components) that pure data
+//   consumers don't need. This module ships only the static data
+//   — addresses, ABIs, topics — leaving studio's UX layer in place.
+// - Other partner SDKs, server-side indexers, and devtools can read
+//   the same whitelist without taking a Studio dependency.
+//
+// Roadmap: studio's `buildWorkflowFromAction` request-builder and
+// the UI `KnownProtocol` envelopes stay in studio for now — they
+// ride on shapes still iterating with the v4 cutover. Studio
+// migrates over to consume from this catalog once that lands.
+export { aaveV3 } from "./aave-v3";
+export { aerodrome } from "./aerodrome";
+export { chainlink } from "./chainlink";
+export { compoundV3 } from "./compound-v3";
+export { erc20 } from "./erc20";
+export { ethena } from "./ethena";
+export { fraxEther } from "./frax-ether";
+export { lido } from "./lido";
+export { morphoBlue } from "./morpho";
+export { rocketPool } from "./rocket-pool";
+export { sky } from "./sky";
+export { spark } from "./spark";
+export { superfluid } from "./superfluid";
+export { uniswapV3 } from "./uniswap-v3";
+export { wrapped } from "./wrapped";
+export { aggregatorV3Abi, erc4626VaultAbi } from "./common";
+import { aaveV3 } from "./aave-v3";
+import { aerodrome } from "./aerodrome";
+import { chainlink } from "./chainlink";
+import { compoundV3 } from "./compound-v3";
+import { erc20 } from "./erc20";
+import { ethena } from "./ethena";
+import { fraxEther } from "./frax-ether";
+import { lido } from "./lido";
+import { morphoBlue } from "./morpho";
+import { rocketPool } from "./rocket-pool";
+import { sky } from "./sky";
+import { spark } from "./spark";
+import { superfluid } from "./superfluid";
+import { uniswapV3 } from "./uniswap-v3";
+import { wrapped } from "./wrapped";
+/**
+ * Namespace export so callers can do
+ *   `Protocols.aaveV3.pool[Chains.Sepolia]`
+ *   `Protocols.uniswapV3.swapRouter02Abi`
+ * the same way `Nodes.contractRead(...)` is namespaced.
+ *
+ * Protocol naming maps from studio's `protocolId` slug to a
+ * lowerCamelCase property:
+ *   aave-v3       → aaveV3
+ *   compound-v3   → compoundV3
+ *   frax-ether    → fraxEther
+ *   morpho        → morphoBlue (the singleton's product name)
+ *   rocket-pool   → rocketPool
+ *   uniswap-v3    → uniswapV3
+ *   (others)      → same as slug, hyphen → camelCase
+ */
+export const Protocols = Object.freeze({
+    aaveV3,
+    aerodrome,
+    chainlink,
+    compoundV3,
+    erc20,
+    ethena,
+    fraxEther,
+    lido,
+    morphoBlue,
+    rocketPool,
+    sky,
+    spark,
+    superfluid,
+    uniswapV3,
+    wrapped,
+});

package/dist/v4/protocols/lido.d.ts

@@ -0,0 +1,7 @@
+import { type AbiFragment } from "./types";
+export declare const lido: Readonly<{
+    wsteth: Partial<Record<number, `0x${string}`>>;
+    steth: Partial<Record<number, `0x${string}`>>;
+    wstethAbi: readonly AbiFragment[];
+}>;
+//# sourceMappingURL=lido.d.ts.map

package/dist/v4/protocols/lido.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lido.d.ts","sourceRoot":"","sources":["../../../src/v4/protocols/lido.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,SAAS,CAAC;AAuChE,eAAO,MAAM,IAAI;;;;EAIf,CAAC"}

package/dist/v4/protocols/lido.js

@@ -0,0 +1,44 @@
+// Lido — stETH (L1 rebasing) + wstETH (wrapped). Wrap/unwrap only
+// exist on the L1 wstETH contract; the Base wstETH entry is a
+// bridged ERC-20 and supports standard ERC-20 transfers / approvals
+// only. stETH is not bridged to Base.
+import { Chains } from "../chains";
+const wsteth = {
+    [Chains.EthereumMainnet]: "0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0",
+    [Chains.BaseMainnet]: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452",
+};
+const steth = {
+    [Chains.EthereumMainnet]: "0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84",
+};
+/**
+ * wstETH wrap/unwrap + getStETHByWstETH read. L1-only — calls against
+ * the Base bridged token revert.
+ */
+const wstethAbi = Object.freeze([
+    {
+        inputs: [{ internalType: "uint256", name: "_stETHAmount", type: "uint256" }],
+        name: "wrap",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "uint256", name: "_wstETHAmount", type: "uint256" }],
+        name: "unwrap",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "uint256", name: "_wstETHAmount", type: "uint256" }],
+        name: "getStETHByWstETH",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+]);
+export const lido = Object.freeze({
+    wsteth,
+    steth,
+    wstethAbi,
+});

package/dist/v4/protocols/morpho.d.ts

@@ -0,0 +1,6 @@
+import { type AbiFragment } from "./types";
+export declare const morphoBlue: Readonly<{
+    morpho: Partial<Record<number, `0x${string}`>>;
+    morphoAbi: readonly AbiFragment[];
+}>;
+//# sourceMappingURL=morpho.d.ts.map

package/dist/v4/protocols/morpho.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"morpho.d.ts","sourceRoot":"","sources":["../../../src/v4/protocols/morpho.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,SAAS,CAAC;AAmFhE,eAAO,MAAM,UAAU;;;EAGrB,CAAC"}

package/dist/v4/protocols/morpho.js

@@ -0,0 +1,89 @@
+// Morpho Blue — permissionless lending singleton. Same address on
+// every supported chain. Every market is addressed by a `MarketParams`
+// tuple (loanToken, collateralToken, oracle, irm, lltv); lending calls
+// pass that struct plus an amount in either `assets` or `shares`
+// (one is zero).
+import { Chains } from "../chains";
+const morpho = {
+    [Chains.EthereumMainnet]: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
+    [Chains.BaseMainnet]: "0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb",
+};
+/**
+ * Morpho Blue minimal write+read surface. Each write takes the full
+ * `MarketParams` tuple as the first argument; the `data` callback
+ * bytes default to `0x` in template usage.
+ */
+const morphoAbi = Object.freeze([
+    {
+        inputs: [
+            {
+                components: [
+                    { internalType: "address", name: "loanToken", type: "address" },
+                    { internalType: "address", name: "collateralToken", type: "address" },
+                    { internalType: "address", name: "oracle", type: "address" },
+                    { internalType: "address", name: "irm", type: "address" },
+                    { internalType: "uint256", name: "lltv", type: "uint256" },
+                ],
+                internalType: "struct MarketParams",
+                name: "marketParams",
+                type: "tuple",
+            },
+            { internalType: "uint256", name: "assets", type: "uint256" },
+            { internalType: "uint256", name: "shares", type: "uint256" },
+            { internalType: "address", name: "onBehalf", type: "address" },
+            { internalType: "bytes", name: "data", type: "bytes" },
+        ],
+        name: "supply",
+        outputs: [
+            { internalType: "uint256", name: "assetsSupplied", type: "uint256" },
+            { internalType: "uint256", name: "sharesSupplied", type: "uint256" },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                components: [
+                    { internalType: "address", name: "loanToken", type: "address" },
+                    { internalType: "address", name: "collateralToken", type: "address" },
+                    { internalType: "address", name: "oracle", type: "address" },
+                    { internalType: "address", name: "irm", type: "address" },
+                    { internalType: "uint256", name: "lltv", type: "uint256" },
+                ],
+                internalType: "struct MarketParams",
+                name: "marketParams",
+                type: "tuple",
+            },
+            { internalType: "uint256", name: "assets", type: "uint256" },
+            { internalType: "uint256", name: "shares", type: "uint256" },
+            { internalType: "address", name: "onBehalf", type: "address" },
+            { internalType: "address", name: "receiver", type: "address" },
+        ],
+        name: "borrow",
+        outputs: [
+            { internalType: "uint256", name: "assetsBorrowed", type: "uint256" },
+            { internalType: "uint256", name: "sharesBorrowed", type: "uint256" },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "bytes32", name: "id", type: "bytes32" },
+            { internalType: "address", name: "user", type: "address" },
+        ],
+        name: "position",
+        outputs: [
+            { internalType: "uint256", name: "supplyShares", type: "uint256" },
+            { internalType: "uint128", name: "borrowShares", type: "uint128" },
+            { internalType: "uint128", name: "collateral", type: "uint128" },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+]);
+export const morphoBlue = Object.freeze({
+    morpho,
+    morphoAbi,
+});

package/dist/v4/protocols/rocket-pool.d.ts

@@ -0,0 +1,6 @@
+import { type AbiFragment } from "./types";
+export declare const rocketPool: Readonly<{
+    reth: Partial<Record<number, `0x${string}`>>;
+    rethAbi: readonly AbiFragment[];
+}>;
+//# sourceMappingURL=rocket-pool.d.ts.map

package/dist/v4/protocols/rocket-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rocket-pool.d.ts","sourceRoot":"","sources":["../../../src/v4/protocols/rocket-pool.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,SAAS,CAAC;AAgChE,eAAO,MAAM,UAAU;;;EAGrB,CAAC"}

package/dist/v4/protocols/rocket-pool.js

@@ -0,0 +1,36 @@
+// Rocket Pool — rETH liquid-staking token. L1 rETH supports burn /
+// getExchangeRate / getEthValue; Base rETH is a bridged ERC-20 and
+// only exposes the standard ERC-20 surface.
+import { Chains } from "../chains";
+const reth = {
+    [Chains.EthereumMainnet]: "0xae78736Cd615f374D3085123A210448E74Fc6393",
+    [Chains.BaseMainnet]: "0xB6fe221Fe9EeF5aBa221c348bA20A1Bf5e73624c",
+};
+/** L1-only `burn` + rate/value reads. */
+const rethAbi = Object.freeze([
+    {
+        inputs: [{ internalType: "uint256", name: "_rethAmount", type: "uint256" }],
+        name: "burn",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "getExchangeRate",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "uint256", name: "_rethAmount", type: "uint256" }],
+        name: "getEthValue",
+        outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+        stateMutability: "view",
+        type: "function",
+    },
+]);
+export const rocketPool = Object.freeze({
+    reth,
+    rethAbi,
+});

package/dist/v4/protocols/sky.d.ts

@@ -0,0 +1,6 @@
+export declare const sky: Readonly<{
+    sdai: Partial<Record<number, `0x${string}`>>;
+    /** Standard ERC-4626 surface — sDAI conforms exactly. */
+    vaultAbi: readonly import("./types").AbiFragment[];
+}>;
+//# sourceMappingURL=sky.d.ts.map

package/dist/v4/protocols/sky.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sky.d.ts","sourceRoot":"","sources":["../../../src/v4/protocols/sky.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,GAAG;;IAEd,yDAAyD;;EAEzD,CAAC"}

package/dist/v4/protocols/sky.js

@@ -0,0 +1,13 @@
+// Sky Protocol (formerly MakerDAO) — sDAI savings vault. Standard
+// ERC-4626 wrapper over the Dai Savings Rate (no cooldown), so the
+// shared vault ABI applies cleanly.
+import { Chains } from "../chains";
+import { erc4626VaultAbi } from "./common";
+const sdai = {
+    [Chains.EthereumMainnet]: "0x83F20F44975D03b1b09e64809B757c47f942BEeA",
+};
+export const sky = Object.freeze({
+    sdai,
+    /** Standard ERC-4626 surface — sDAI conforms exactly. */
+    vaultAbi: erc4626VaultAbi,
+});

package/dist/v4/protocols/spark.d.ts

@@ -0,0 +1,4 @@
+export declare const spark: Readonly<{
+    pool: Partial<Record<number, `0x${string}`>>;
+}>;
+//# sourceMappingURL=spark.d.ts.map

package/dist/v4/protocols/spark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spark.d.ts","sourceRoot":"","sources":["../../../src/v4/protocols/spark.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,KAAK;;EAEhB,CAAC"}

package/dist/v4/protocols/spark.js

@@ -0,0 +1,15 @@
+// Spark Protocol — SparkLend money market, an AAVE V3 fork.
+//
+// Because Spark forked AAVE V3 unchanged, the Pool contract surface
+// is identical: `supply`, `withdraw`, `borrow`, `repay`,
+// `setUserUseReserveAsCollateral`, `getUserAccountData` — same
+// signatures as `Protocols.aaveV3.poolMethodsAbi`. Templates that
+// target Spark can pass `aaveV3.poolMethodsAbi` directly; we don't
+// re-vendor a copy. Only the addresses differ.
+import { Chains } from "../chains";
+const pool = {
+    [Chains.EthereumMainnet]: "0xC13e21B648A5Ee794902342038FF3aDAB66BE987",
+};
+export const spark = Object.freeze({
+    pool,
+});

package/dist/v4/protocols/superfluid.d.ts

@@ -0,0 +1,6 @@
+import { type AbiFragment } from "./types";
+export declare const superfluid: Readonly<{
+    cfaForwarder: Partial<Record<number, `0x${string}`>>;
+    cfaForwarderAbi: readonly AbiFragment[];
+}>;
+//# sourceMappingURL=superfluid.d.ts.map

package/dist/v4/protocols/superfluid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"superfluid.d.ts","sourceRoot":"","sources":["../../../src/v4/protocols/superfluid.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,SAAS,CAAC;AAmChE,eAAO,MAAM,UAAU;;;EAGrB,CAAC"}

package/dist/v4/protocols/superfluid.js

@@ -0,0 +1,39 @@
+// Superfluid — money streaming via the CFAv1Forwarder. Deployed at
+// the same address on every Superfluid network (Ethereum, Base,
+// Polygon, Optimism, ...). Flow rates are tokens-per-second as int96.
+import { Chains } from "../chains";
+const cfaForwarder = {
+    [Chains.EthereumMainnet]: "0xcfA132E353cB4E398080B9700609bb008eceB125",
+    [Chains.BaseMainnet]: "0xcfA132E353cB4E398080B9700609bb008eceB125",
+};
+/** CFAv1Forwarder minimal write surface — `setFlowrate` + `createFlow`. */
+const cfaForwarderAbi = Object.freeze([
+    {
+        inputs: [
+            { internalType: "address", name: "token", type: "address" },
+            { internalType: "address", name: "receiver", type: "address" },
+            { internalType: "int96", name: "flowrate", type: "int96" },
+        ],
+        name: "setFlowrate",
+        outputs: [{ internalType: "bool", name: "", type: "bool" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "token", type: "address" },
+            { internalType: "address", name: "sender", type: "address" },
+            { internalType: "address", name: "receiver", type: "address" },
+            { internalType: "int96", name: "flowrate", type: "int96" },
+            { internalType: "bytes", name: "userData", type: "bytes" },
+        ],
+        name: "createFlow",
+        outputs: [{ internalType: "bool", name: "", type: "bool" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+]);
+export const superfluid = Object.freeze({
+    cfaForwarder,
+    cfaForwarderAbi,
+});

package/dist/v4/protocols/types.d.ts

@@ -0,0 +1,17 @@
+export interface AbiFragment {
+    readonly name?: string;
+    readonly type: string;
+    readonly stateMutability?: string;
+    readonly anonymous?: boolean;
+    readonly inputs?: readonly unknown[];
+    readonly outputs?: readonly unknown[];
+    readonly [key: string]: unknown;
+}
+import { type ChainId } from "../chains";
+/**
+ * Per-chain address map. Use `ChainId` constants from `Chains.*` for
+ * the keys at the call site; `Partial` because not every protocol
+ * ships on every chain.
+ */
+export type AddressByChain = Partial<Record<ChainId, `0x${string}`>>;
+//# sourceMappingURL=types.d.ts.map

package/dist/v4/protocols/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/v4/protocols/types.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACrC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAMtC,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACjC;AAED,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,MAAM,EAAE,CAAC,CAAC,CAAC"}

package/dist/v4/protocols/types.js

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

package/dist/v4/protocols/uniswap-v3.d.ts

@@ -0,0 +1,27 @@
+import { type AbiFragment } from "./types";
+export declare const uniswapV3: Readonly<{
+    swapRouter02: Partial<Record<number, `0x${string}`>>;
+    quoterV2: Partial<Record<number, `0x${string}`>>;
+    permit2: Partial<Record<number, `0x${string}`>>;
+    factory: Partial<Record<number, `0x${string}`>>;
+    nonfungiblePositionManager: Partial<Record<number, `0x${string}`>>;
+    universalRouter: Partial<Record<number, `0x${string}`>>;
+    swapRouter02Abi: readonly AbiFragment[];
+    quoterV2Abi: readonly AbiFragment[];
+    factoryAbi: readonly AbiFragment[];
+    tokens: Readonly<{
+        WETH: {
+            11155111: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14";
+            1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
+            8453: "0x4200000000000000000000000000000000000006";
+            84532: "0x4200000000000000000000000000000000000006";
+        };
+        USDC: {
+            11155111: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238";
+            1: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
+            8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+            84532: "0x036CbD53842c5426634e7929541eC2318f3dCF7e";
+        };
+    }>;
+}>;
+//# sourceMappingURL=uniswap-v3.d.ts.map

package/dist/v4/protocols/uniswap-v3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniswap-v3.d.ts","sourceRoot":"","sources":["../../../src/v4/protocols/uniswap-v3.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,KAAK,WAAW,EAAuB,MAAM,SAAS,CAAC;AAqLhE,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;EAWpB,CAAC"}