@rhinestone/relayer-sdk 0.1.0

package/dist/adapters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapters.d.ts","sourceRoot":"","sources":["../adapters.ts"],"names":[],"mappings":"AAWA;;;GAGG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASX,CAAA"}

package/dist/adapters.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adapters = void 0;
+const shared_configs_1 = require("@rhinestone/shared-configs");
+/**
+ * Collection of adapter ABIs used by the router.
+ * Each adapter handles a specific settlement layer or execution pattern.
+ */
+exports.adapters = {
+    singleCallAbi: shared_configs_1.singleCallAbi,
+    multiCallAbi: shared_configs_1.multiCallAbi,
+    directRouteAbi: shared_configs_1.directRouteAbi,
+    ecoAbi: shared_configs_1.ecoAdapterAbi,
+    sameChainAbi: shared_configs_1.sameChainAdapterAbi,
+    acrossAbi: shared_configs_1.acrossAdapterAbi,
+    intentExecutorAbi: shared_configs_1.intentExecutorAdapterAbi,
+    relayAbi: shared_configs_1.relayAdapterAbi,
+};

package/dist/address.d.ts

@@ -0,0 +1,12 @@
+import { type Address } from 'viem';
+import type { EthAddress } from './types';
+/**
+ * Validates and normalizes an address string to an EthAddress.
+ * Lowercases the address for consistent comparison.
+ *
+ * @param value - The address string to parse
+ * @returns The normalized EthAddress
+ * @throws Error if the address is invalid
+ */
+export declare function parseAddress(value: Address | string): EthAddress;
+//# sourceMappingURL=address.d.ts.map

package/dist/address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../address.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAa,MAAM,MAAM,CAAA;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,UAAU,CAKhE"}

package/dist/address.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAddress = parseAddress;
+const viem_1 = require("viem");
+const errors_1 = require("./errors");
+/**
+ * Validates and normalizes an address string to an EthAddress.
+ * Lowercases the address for consistent comparison.
+ *
+ * @param value - The address string to parse
+ * @returns The normalized EthAddress
+ * @throws Error if the address is invalid
+ */
+function parseAddress(value) {
+    if (!(0, viem_1.isAddress)(value, { strict: false })) {
+        throw new errors_1.InvalidAddressError({ value });
+    }
+    return value.toLowerCase();
+}

package/dist/errors.d.ts

@@ -0,0 +1,77 @@
+import type { Hex } from 'viem';
+/**
+ * Base error class for all relayer SDK errors.
+ * Provides structured error information with context for debugging.
+ */
+export declare class RelayerError extends Error {
+    private readonly _message;
+    private readonly _context;
+    private readonly _errorType;
+    constructor(params: {
+        message: string;
+        context?: Record<string, unknown>;
+        errorType?: string;
+    });
+    get message(): string;
+    get context(): Record<string, unknown>;
+    get errorType(): string;
+}
+/**
+ * Error thrown when an unknown adapter function selector is encountered.
+ */
+export declare class UnsupportedAdapterError extends RelayerError {
+    constructor(params: {
+        selector: Hex;
+        index: number;
+        functionName: string;
+    });
+}
+/**
+ * Error thrown when the number of relayer contexts doesn't match
+ * the number of adapter calls that require them.
+ */
+export declare class ContextMismatchError extends RelayerError {
+    constructor(params: {
+        expected: number;
+        actual: number;
+        adapterCalls: Array<{
+            name: string;
+            expectsContext: boolean;
+        }>;
+    });
+}
+/**
+ * Error thrown when an unsupported router function is called.
+ */
+export declare class UnsupportedRouteCallError extends RelayerError {
+    constructor(params: {
+        functionName: string;
+    });
+}
+/**
+ * Error thrown when the target address is not a recognized
+ * router or intent executor address.
+ */
+export declare class UnsupportedDestinationError extends RelayerError {
+    constructor(params: {
+        address: string;
+    });
+}
+/**
+ * Error thrown when an invalid Ethereum address is provided.
+ */
+export declare class InvalidAddressError extends RelayerError {
+    constructor(params: {
+        value: string;
+    });
+}
+/**
+ * Type guard to check if an error is a RelayerError.
+ */
+export declare function isRelayerError(err: unknown): err is RelayerError;
+/**
+ * Type guard to check if an error is a validation error
+ * (InvalidAddressError or ContextMismatchError).
+ */
+export declare function isValidationError(err: unknown): boolean;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAE/B;;;GAGG;AACH,qBAAa,YAAa,SAAQ,KAAK;IACrC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAyB;IAClD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;gBAEvB,MAAM,EAAE;QAClB,OAAO,EAAE,MAAM,CAAA;QACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;QACjC,SAAS,CAAC,EAAE,MAAM,CAAA;KACnB;IAQD,IAAa,OAAO,IAAI,MAAM,CAE7B;IAED,IAAI,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAErC;IAED,IAAI,SAAS,IAAI,MAAM,CAEtB;CACF;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,YAAY;gBAC3C,MAAM,EAAE;QAClB,QAAQ,EAAE,GAAG,CAAA;QACb,KAAK,EAAE,MAAM,CAAA;QACb,YAAY,EAAE,MAAM,CAAA;KACrB;CAOF;AAED;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,YAAY;gBACxC,MAAM,EAAE;QAClB,QAAQ,EAAE,MAAM,CAAA;QAChB,MAAM,EAAE,MAAM,CAAA;QACd,YAAY,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,cAAc,EAAE,OAAO,CAAA;SAAE,CAAC,CAAA;KAC/D;CAWF;AAED;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,YAAY;gBAC7C,MAAM,EAAE;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE;CAO7C;AAED;;;GAGG;AACH,qBAAa,2BAA4B,SAAQ,YAAY;gBAC/C,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE;CAOxC;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,YAAY;gBACvC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE;CAOtC;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,YAAY,CAEhE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAIvD"}

package/dist/errors.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidAddressError = exports.UnsupportedDestinationError = exports.UnsupportedRouteCallError = exports.ContextMismatchError = exports.UnsupportedAdapterError = exports.RelayerError = void 0;
+exports.isRelayerError = isRelayerError;
+exports.isValidationError = isValidationError;
+/**
+ * Base error class for all relayer SDK errors.
+ * Provides structured error information with context for debugging.
+ */
+class RelayerError extends Error {
+    _message;
+    _context;
+    _errorType;
+    constructor(params) {
+        super(params.message);
+        this._message = params.message;
+        this._context = params.context ?? {};
+        this._errorType = params.errorType ?? 'RelayerError';
+        this.name = this._errorType;
+    }
+    get message() {
+        return this._message;
+    }
+    get context() {
+        return this._context;
+    }
+    get errorType() {
+        return this._errorType;
+    }
+}
+exports.RelayerError = RelayerError;
+/**
+ * Error thrown when an unknown adapter function selector is encountered.
+ */
+class UnsupportedAdapterError extends RelayerError {
+    constructor(params) {
+        super({
+            message: `Unknown adapter call at index ${params.index}, selector: ${params.selector} for ${params.functionName}`,
+            context: params,
+            errorType: 'UnsupportedAdapterError',
+        });
+    }
+}
+exports.UnsupportedAdapterError = UnsupportedAdapterError;
+/**
+ * Error thrown when the number of relayer contexts doesn't match
+ * the number of adapter calls that require them.
+ */
+class ContextMismatchError extends RelayerError {
+    constructor(params) {
+        const message = params.expected > params.actual
+            ? `Mismatch: Expected ${params.expected} relayer contexts but only ${params.actual} were provided`
+            : `Mismatch: More contexts were provided (${params.actual}) than were consumed (${params.expected}) by the adapter calls`;
+        super({
+            message,
+            context: params,
+            errorType: 'ContextMismatchError',
+        });
+    }
+}
+exports.ContextMismatchError = ContextMismatchError;
+/**
+ * Error thrown when an unsupported router function is called.
+ */
+class UnsupportedRouteCallError extends RelayerError {
+    constructor(params) {
+        super({
+            message: `Unsupported route function call: ${params.functionName}`,
+            context: params,
+            errorType: 'UnsupportedRouteCallError',
+        });
+    }
+}
+exports.UnsupportedRouteCallError = UnsupportedRouteCallError;
+/**
+ * Error thrown when the target address is not a recognized
+ * router or intent executor address.
+ */
+class UnsupportedDestinationError extends RelayerError {
+    constructor(params) {
+        super({
+            message: `Unsupported destination address: ${params.address}`,
+            context: params,
+            errorType: 'UnsupportedDestinationError',
+        });
+    }
+}
+exports.UnsupportedDestinationError = UnsupportedDestinationError;
+/**
+ * Error thrown when an invalid Ethereum address is provided.
+ */
+class InvalidAddressError extends RelayerError {
+    constructor(params) {
+        super({
+            message: `Invalid Ethereum address: ${params.value}`,
+            context: params,
+            errorType: 'InvalidAddressError',
+        });
+    }
+}
+exports.InvalidAddressError = InvalidAddressError;
+/**
+ * Type guard to check if an error is a RelayerError.
+ */
+function isRelayerError(err) {
+    return err instanceof RelayerError;
+}
+/**
+ * Type guard to check if an error is a validation error
+ * (InvalidAddressError or ContextMismatchError).
+ */
+function isValidationError(err) {
+    return (err instanceof InvalidAddressError || err instanceof ContextMismatchError);
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { adapters } from './adapters';
+export { ContextMismatchError, InvalidAddressError, isRelayerError, isValidationError, RelayerError, UnsupportedAdapterError, UnsupportedDestinationError, UnsupportedRouteCallError, } from './errors';
+export { replaceRepaymentDestinations } from './rebalancing';
+export type { AdapterCall, DecodeRouterCallReturnType, RelayerContextRewrite, } from './router';
+export { AcrossRepaymentsRelayerContext, decodeRouterCall, EcoRepaymentsRelayerContext, functionSelectorToAdapterCallMap, NoRelayerContext, SameChainRepaymentsRelayerContext, } from './router';
+export type { RebalancingConfig, RepaymentDestination } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAErC,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,uBAAuB,EACvB,2BAA2B,EAC3B,yBAAyB,GAC1B,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAA;AAC5D,YAAY,EACV,WAAW,EACX,0BAA0B,EAC1B,qBAAqB,GACtB,MAAM,UAAU,CAAA;AAEjB,OAAO,EACL,8BAA8B,EAC9B,gBAAgB,EAChB,2BAA2B,EAC3B,gCAAgC,EAChC,gBAAgB,EAChB,iCAAiC,GAClC,MAAM,UAAU,CAAA;AAEjB,YAAY,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA"}

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SameChainRepaymentsRelayerContext = exports.NoRelayerContext = exports.functionSelectorToAdapterCallMap = exports.EcoRepaymentsRelayerContext = exports.decodeRouterCall = exports.AcrossRepaymentsRelayerContext = exports.replaceRepaymentDestinations = exports.UnsupportedRouteCallError = exports.UnsupportedDestinationError = exports.UnsupportedAdapterError = exports.RelayerError = exports.isValidationError = exports.isRelayerError = exports.InvalidAddressError = exports.ContextMismatchError = exports.adapters = void 0;
+// Adapters
+// biome-ignore lint/performance/noBarrelFile: Package entry point requires re-exports
+var adapters_1 = require("./adapters");
+Object.defineProperty(exports, "adapters", { enumerable: true, get: function () { return adapters_1.adapters; } });
+// Errors
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "ContextMismatchError", { enumerable: true, get: function () { return errors_1.ContextMismatchError; } });
+Object.defineProperty(exports, "InvalidAddressError", { enumerable: true, get: function () { return errors_1.InvalidAddressError; } });
+Object.defineProperty(exports, "isRelayerError", { enumerable: true, get: function () { return errors_1.isRelayerError; } });
+Object.defineProperty(exports, "isValidationError", { enumerable: true, get: function () { return errors_1.isValidationError; } });
+Object.defineProperty(exports, "RelayerError", { enumerable: true, get: function () { return errors_1.RelayerError; } });
+Object.defineProperty(exports, "UnsupportedAdapterError", { enumerable: true, get: function () { return errors_1.UnsupportedAdapterError; } });
+Object.defineProperty(exports, "UnsupportedDestinationError", { enumerable: true, get: function () { return errors_1.UnsupportedDestinationError; } });
+Object.defineProperty(exports, "UnsupportedRouteCallError", { enumerable: true, get: function () { return errors_1.UnsupportedRouteCallError; } });
+var rebalancing_1 = require("./rebalancing");
+Object.defineProperty(exports, "replaceRepaymentDestinations", { enumerable: true, get: function () { return rebalancing_1.replaceRepaymentDestinations; } });
+// Lower-level building blocks
+var router_1 = require("./router");
+Object.defineProperty(exports, "AcrossRepaymentsRelayerContext", { enumerable: true, get: function () { return router_1.AcrossRepaymentsRelayerContext; } });
+Object.defineProperty(exports, "decodeRouterCall", { enumerable: true, get: function () { return router_1.decodeRouterCall; } });
+Object.defineProperty(exports, "EcoRepaymentsRelayerContext", { enumerable: true, get: function () { return router_1.EcoRepaymentsRelayerContext; } });
+Object.defineProperty(exports, "functionSelectorToAdapterCallMap", { enumerable: true, get: function () { return router_1.functionSelectorToAdapterCallMap; } });
+Object.defineProperty(exports, "NoRelayerContext", { enumerable: true, get: function () { return router_1.NoRelayerContext; } });
+Object.defineProperty(exports, "SameChainRepaymentsRelayerContext", { enumerable: true, get: function () { return router_1.SameChainRepaymentsRelayerContext; } });

package/dist/rebalancing.d.ts

@@ -0,0 +1,41 @@
+import { type Address, type Hex } from 'viem';
+import type { RebalancingConfig, RepaymentDestination } from './types';
+/**
+ * Rewrites repayment destinations inside router-encoded intent calldata.
+ *
+ * Decodes the router call, walks each adapter call in the route, and replaces
+ * the relayer context (repayment address / chain) for every adapter that
+ * carries one (Across, SameChain, Eco).
+ *
+ * @param to - Target contract address of the call
+ * @param data - ABI-encoded calldata (routeFill / routeClaim / optimized variant)
+ * @param destination - The repayment destination to write into each relayer context.
+ *   Omit `chain` to preserve per-deposit origin chains (recommended for Across).
+ * @param config - Optional override for router / intent-executor addresses.
+ *   Defaults to production addresses from `@rhinestone/shared-configs`.
+ * @returns The calldata with rewritten repayment destinations
+ * @throws Error if the target address is not recognized or adapter call is unknown
+ *
+ * @example
+ * ```ts
+ * // Simple usage with defaults
+ * const rewritten = replaceRepaymentDestinations(
+ *   routerAddress,
+ *   originalCalldata,
+ *   { address: '0x...' },
+ * )
+ *
+ * // With custom config (e.g., dev deployment)
+ * const rewritten = replaceRepaymentDestinations(
+ *   routerAddress,
+ *   originalCalldata,
+ *   { address: '0x...' },
+ *   {
+ *     routerAddress: '0x...',
+ *     intentExecutorAddress: '0x...',
+ *   },
+ * )
+ * ```
+ */
+export declare function replaceRepaymentDestinations(to: Address, data: Hex, destination: RepaymentDestination, config?: RebalancingConfig): Hex;
+//# sourceMappingURL=rebalancing.d.ts.map

package/dist/rebalancing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebalancing.d.ts","sourceRoot":"","sources":["../rebalancing.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,GAAG,EAET,MAAM,MAAM,CAAA;AAYb,OAAO,KAAK,EAEV,iBAAiB,EACjB,oBAAoB,EACrB,MAAM,SAAS,CAAA;AAOhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,4BAA4B,CAC1C,EAAE,EAAE,OAAO,EACX,IAAI,EAAE,GAAG,EACT,WAAW,EAAE,oBAAoB,EACjC,MAAM,CAAC,EAAE,iBAAiB,GACzB,GAAG,CA0FL"}

package/dist/rebalancing.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceRepaymentDestinations = replaceRepaymentDestinations;
+const shared_configs_1 = require("@rhinestone/shared-configs");
+const viem_1 = require("viem");
+const address_1 = require("./address");
+const errors_1 = require("./errors");
+const router_1 = require("./router");
+const DEFAULT_ROUTER_ADDRESS = (0, address_1.parseAddress)(shared_configs_1.contractAddresses['*'].router);
+const DEFAULT_INTENT_EXECUTOR_ADDRESS = (0, address_1.parseAddress)(shared_configs_1.contractAddresses['*'].intentExecutor);
+/**
+ * Rewrites repayment destinations inside router-encoded intent calldata.
+ *
+ * Decodes the router call, walks each adapter call in the route, and replaces
+ * the relayer context (repayment address / chain) for every adapter that
+ * carries one (Across, SameChain, Eco).
+ *
+ * @param to - Target contract address of the call
+ * @param data - ABI-encoded calldata (routeFill / routeClaim / optimized variant)
+ * @param destination - The repayment destination to write into each relayer context.
+ *   Omit `chain` to preserve per-deposit origin chains (recommended for Across).
+ * @param config - Optional override for router / intent-executor addresses.
+ *   Defaults to production addresses from `@rhinestone/shared-configs`.
+ * @returns The calldata with rewritten repayment destinations
+ * @throws Error if the target address is not recognized or adapter call is unknown
+ *
+ * @example
+ * ```ts
+ * // Simple usage with defaults
+ * const rewritten = replaceRepaymentDestinations(
+ *   routerAddress,
+ *   originalCalldata,
+ *   { address: '0x...' },
+ * )
+ *
+ * // With custom config (e.g., dev deployment)
+ * const rewritten = replaceRepaymentDestinations(
+ *   routerAddress,
+ *   originalCalldata,
+ *   { address: '0x...' },
+ *   {
+ *     routerAddress: '0x...',
+ *     intentExecutorAddress: '0x...',
+ *   },
+ * )
+ * ```
+ */
+function replaceRepaymentDestinations(to, data, destination, config) {
+    // Normalize addresses internally
+    const normalizedTo = (0, address_1.parseAddress)(to);
+    const routerAddress = config?.routerAddress
+        ? (0, address_1.parseAddress)(config.routerAddress)
+        : DEFAULT_ROUTER_ADDRESS;
+    const intentExecutorAddress = config?.intentExecutorAddress
+        ? (0, address_1.parseAddress)(config.intentExecutorAddress)
+        : DEFAULT_INTENT_EXECUTOR_ADDRESS;
+    const normalizedDestination = {
+        address: (0, address_1.parseAddress)(destination.address),
+        chain: destination.chain,
+    };
+    if (normalizedTo === intentExecutorAddress) {
+        // Intent executor calls don't need repayment context modification
+        return data;
+    }
+    if (normalizedTo === routerAddress) {
+        const { functionName: routerFunctionName, args: routerCallArgs, isOptimizedRouteCall, } = (0, router_1.decodeRouterCall)(data);
+        let contextIndex = 0;
+        const relayerContextData = routerCallArgs[0];
+        const adaptersCallData = !isOptimizedRouteCall
+            ? routerCallArgs[1]
+            : (0, viem_1.decodeAbiParameters)([{ type: 'bytes[]', name: 'adapterContexts' }], routerCallArgs[1])[0];
+        // Track adapter calls for better error diagnostics
+        const adapterCalls = [];
+        for (let i = 0; i < adaptersCallData.length; i++) {
+            const adapterCallBytes = adaptersCallData[i];
+            const selector = (0, viem_1.sliceHex)(adapterCallBytes, 0, 4);
+            const adapterCall = router_1.functionSelectorToAdapterCallMap[selector];
+            if (!adapterCall) {
+                throw new errors_1.UnsupportedAdapterError({
+                    selector,
+                    index: i,
+                    functionName: routerFunctionName,
+                });
+            }
+            adapterCalls.push({
+                name: `${adapterCall.adapterName}:${adapterCall.functionName}`,
+                expectsContext: adapterCall.rewriteRelayerContext !== router_1.NoRelayerContext,
+            });
+            const rewriteF = adapterCall.rewriteRelayerContext;
+            if (rewriteF !== router_1.NoRelayerContext) {
+                if (contextIndex >= relayerContextData.length) {
+                    throw new errors_1.ContextMismatchError({
+                        expected: contextIndex + 1,
+                        actual: relayerContextData.length,
+                        adapterCalls,
+                    });
+                }
+                const currentContext = relayerContextData[contextIndex];
+                relayerContextData[contextIndex] = rewriteF(currentContext, normalizedDestination);
+                contextIndex++;
+            }
+        }
+        if (contextIndex !== relayerContextData.length) {
+            throw new errors_1.ContextMismatchError({
+                expected: contextIndex,
+                actual: relayerContextData.length,
+                adapterCalls,
+            });
+        }
+        return (0, viem_1.encodeFunctionData)({
+            functionName: routerFunctionName,
+            args: routerCallArgs,
+            abi: shared_configs_1.routerAbi,
+        });
+    }
+    throw new errors_1.UnsupportedDestinationError({ address: to });
+}

package/dist/router.d.ts

@@ -0,0 +1,68 @@
+import { routerAbi } from '@rhinestone/shared-configs';
+import type { DecodeFunctionDataReturnType, Hex } from 'viem';
+import type { InternalRepaymentDestination } from './types';
+/**
+ * Return type for decodeRouterCall, extends viem's decoded function data
+ * with metadata about whether this is an optimized route call.
+ */
+export type DecodeRouterCallReturnType = DecodeFunctionDataReturnType<typeof routerAbi> & {
+    isOptimizedRouteCall: boolean;
+};
+/**
+ * Decodes router calldata and validates it's a supported route function.
+ *
+ * @param data - The ABI-encoded router calldata
+ * @returns Decoded function data with optimization flag
+ * @throws Error if the function is not a supported route call
+ */
+export declare function decodeRouterCall(data: Hex): DecodeRouterCallReturnType;
+/**
+ * Function signature for adapter-specific relayer context rewrite functions.
+ * Takes the original encoded context and a repayment destination,
+ * returns the rewritten encoded context.
+ * @internal
+ */
+export type RelayerContextRewrite = (original: Hex, repayment: InternalRepaymentDestination) => Hex;
+/**
+ * Metadata for a single adapter function, resolved from its 4-byte selector.
+ */
+export type AdapterCall = {
+    functionName: string;
+    adapterName: string;
+    rewriteRelayerContext: RelayerContextRewrite;
+};
+/**
+ * No-op rewrite for adapters that don't need repayment context modification.
+ * @internal
+ */
+export declare const NoRelayerContext: RelayerContextRewrite;
+/**
+ * Rewrites Across adapter relayer context.
+ * Across contexts contain an array of (repaymentChain, repaymentAddress) tuples,
+ * one per deposit/origin chain.
+ *
+ * When `repayment.chain` is provided, all tuples are updated to that chain.
+ * When omitted, each tuple preserves its original repaymentChain.
+ * @internal
+ */
+export declare const AcrossRepaymentsRelayerContext: RelayerContextRewrite;
+/**
+ * Rewrites SameChain adapter relayer context.
+ * Simply encodes the new repayment address.
+ * @internal
+ */
+export declare const SameChainRepaymentsRelayerContext: RelayerContextRewrite;
+/**
+ * Rewrites Eco adapter relayer context.
+ * Simply encodes the new repayment address (claimant).
+ * @internal
+ */
+export declare const EcoRepaymentsRelayerContext: RelayerContextRewrite;
+/**
+ * Pre-built map from 4-byte function selector to adapter call metadata.
+ * Used to look up the appropriate rewrite function for each adapter call.
+ */
+export declare const functionSelectorToAdapterCallMap: Readonly<{
+    [key: Hex]: AdapterCall;
+}>;
+//# sourceMappingURL=router.d.ts.map

package/dist/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AACtD,OAAO,KAAK,EAAe,4BAA4B,EAAE,GAAG,EAAE,MAAM,MAAM,CAAA;AAU1E,OAAO,KAAK,EAAc,4BAA4B,EAAE,MAAM,SAAS,CAAA;AAQvE;;;GAGG;AACH,MAAM,MAAM,0BAA0B,GAAG,4BAA4B,CACnE,OAAO,SAAS,CACjB,GAAG;IACF,oBAAoB,EAAE,OAAO,CAAA;CAC9B,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,GAAG,GAAG,0BAA0B,CAetE;AAED;;;;;GAKG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAClC,QAAQ,EAAE,GAAG,EACb,SAAS,EAAE,4BAA4B,KACpC,GAAG,CAAA;AAER;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,MAAM,CAAA;IACnB,qBAAqB,EAAE,qBAAqB,CAAA;CAC7C,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,qBAK9B,CAAA;AAYD;;;;;;;;GAQG;AACH,eAAO,MAAM,8BAA8B,EAAE,qBAkB5C,CAAA;AAID;;;;GAIG;AACH,eAAO,MAAM,iCAAiC,EAAE,qBAK/C,CAAA;AAID;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,EAAE,qBAKzC,CAAA;AAqDD;;;GAGG;AACH,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC;IACtD,CAAC,GAAG,EAAE,GAAG,GAAG,WAAW,CAAA;CACxB,CAAmC,CAAA"}