@ekubo/yul-router-sdk 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export declare const MIN_CALCULATED_AMOUNT_THRESHOLD: bigint;
 export declare const MAX_CALCULATED_AMOUNT_THRESHOLD: bigint;
 export declare const MAX_MULTIHOP_LENGTH = 256;
 export declare const MAX_HOP_LENGTH = 256;
+export declare const YUL_ROUTER_ADDRESS: Address;
 export interface PoolKey {
     token0: Address;
     token1: Address;
@@ -30,12 +31,22 @@ export interface Ve33Hop {
     sqrtRatioLimit?: bigint;
     skipAhead?: number;
 }
+export interface SignedExclusiveSwapHop {
+    type: "signedExclusiveSwap";
+    forwardee: Address;
+    poolKey: PoolKey;
+    meta: bigint | Hex;
+    minBalanceUpdate: Hex;
+    signature: Hex;
+    sqrtRatioLimit?: bigint;
+    skipAhead?: number;
+}
 export interface WrapperHop {
     type: "wrapper";
     underlying: Address;
     wrapped: Address;
 }
-export type Hop = CoreHop | ForwardedHop | Ve33Hop | WrapperHop;
+export type Hop = CoreHop | ForwardedHop | Ve33Hop | SignedExclusiveSwapHop | WrapperHop;
 export interface MultiHop {
     specifiedAmount: bigint;
     hops: readonly Hop[];
@@ -59,4 +70,12 @@ export type Parameters = EncodeRoutesParameters;
 export declare function encodeRoute(params: EncodeRouteParameters): Hex;
 export declare function generateCalldata(params: EncodeRoutesParameters): Hex;
 export declare function encodeRoutes(params: EncodeRoutesParameters): Hex;
+export declare function encodePoolBalanceUpdate(delta0: bigint, delta1: bigint): Hex;
+export interface EncodeSignedSwapMetaParameters {
+    authorizedLocker?: Address;
+    deadline: number;
+    fee?: number;
+    nonce: bigint | number;
+}
+export declare function encodeSignedSwapMeta(params: EncodeSignedSwapMetaParameters): Hex;
 export declare function calldataSize(data: Hex): number;

package/dist/index.js

@@ -5,6 +5,7 @@ export const MIN_CALCULATED_AMOUNT_THRESHOLD = minInt128;
 export const MAX_CALCULATED_AMOUNT_THRESHOLD = maxInt128;
 export const MAX_MULTIHOP_LENGTH = 256;
 export const MAX_HOP_LENGTH = 256;
+export const YUL_ROUTER_ADDRESS = "0x000000005fdB8E48978C5c804d406b76481674E8";
 export function encodeRoute(params) {
     const { specifiedAmount, hops, ...shared } = params;
     return encodeRoutes({
@@ -73,6 +74,22 @@ export function encodeRoutes(params) {
                     currentToken = nextToken;
                     break;
                 }
+                case "signedExclusiveSwap": {
+                    const { poolKey, forwardee } = hop;
+                    const { nextToken } = resolvePoolHop(currentToken, poolKey);
+                    encodedHops.push(concatHex([
+                        "0x04",
+                        encodeAddress(forwardee),
+                        encodePoolKey(poolKey),
+                        encodeSqrtRatioLimit(hop.sqrtRatioLimit),
+                        encodeSkipAhead(hop.skipAhead),
+                        encodeUint256(hop.meta, "meta"),
+                        encodeBytes32(hop.minBalanceUpdate, "minBalanceUpdate"),
+                        encodeSignature(hop.signature),
+                    ]));
+                    currentToken = nextToken;
+                    break;
+                }
                 case "wrapper": {
                     const underlying = getAddress(hop.underlying);
                     const wrapped = getAddress(hop.wrapped);
@@ -153,6 +170,28 @@ function encodePoolKey(poolKey) {
 function encodeAddress(address) {
     return getAddress(address);
 }
+function encodeUint256(value, name) {
+    if (typeof value === "bigint") {
+        if (value < 0n || value > (1n << 256n) - 1n) {
+            throw new Error(`${name} must fit into uint256`);
+        }
+        return numberToHex(value, { size: 32 });
+    }
+    return encodeBytes32(value, name);
+}
+function encodeBytes32(value, name) {
+    if (size(value) > 32) {
+        throw new Error(`${name} must fit into bytes32`);
+    }
+    return padHex(value, { size: 32 });
+}
+function encodeSignature(signature) {
+    const signatureLength = size(signature);
+    if (signatureLength > 0xffffffff) {
+        throw new Error("signature length must fit into uint32");
+    }
+    return concatHex([numberToHex(signatureLength, { size: 4 }), signature]);
+}
 function encodeSqrtRatioLimit(value) {
     if (value === undefined || value === 0n) {
         return "0x000000000000000000000000";
@@ -177,6 +216,32 @@ function encodeInt128(value) {
     assertInt128(value, "value");
     return numberToHex(BigInt.asUintN(128, value), { size: 16 });
 }
+export function encodePoolBalanceUpdate(delta0, delta1) {
+    assertInt128(delta0, "delta0");
+    assertInt128(delta1, "delta1");
+    return numberToHex((BigInt.asUintN(128, delta0) << 128n) | BigInt.asUintN(128, delta1), {
+        size: 32,
+    });
+}
+export function encodeSignedSwapMeta(params) {
+    const { authorizedLocker = "0x0000000000000000000000000000000000000000", deadline, fee = 0, nonce } = params;
+    if (!Number.isInteger(deadline) || deadline < 0 || deadline > 0xffffffff) {
+        throw new Error("deadline must fit into uint32");
+    }
+    if (!Number.isInteger(fee) || fee < 0 || fee > 0xffffffff) {
+        throw new Error("fee must fit into uint32");
+    }
+    const nonceValue = BigInt(nonce);
+    if (nonceValue < 0n || nonceValue > (1n << 64n) - 1n) {
+        throw new Error("nonce must fit into uint64");
+    }
+    const lockerLow128 = hexToBigInt(getAddress(authorizedLocker)) & ((1n << 128n) - 1n);
+    const meta = (BigInt(deadline) << 224n) |
+        (BigInt(fee) << 192n) |
+        (nonceValue << 128n) |
+        lockerLow128;
+    return numberToHex(meta, { size: 32 });
+}
 export function calldataSize(data) {
     return size(data);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ekubo/yul-router-sdk",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -18,16 +18,15 @@
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "generate-foundry-testdata": "npm run --silent build && node scripts/generate-foundry-testdata.mjs",
-    "prepublishOnly": "npm run build && npm test",
-    "test": "vitest run"
+    "generate-foundry-testdata": "bun scripts/generate-foundry-testdata.mjs",
+    "prepublishOnly": "bun run build && bun run test",
+    "test": "bun test test/index.test.ts"
   },
   "peerDependencies": {
     "viem": "^2.31.7"
   },
   "devDependencies": {
     "typescript": "^5.8.3",
-    "viem": "^2.31.7",
-    "vitest": "^3.2.4"
+    "viem": "^2.31.7"
   }
 }