routes: Encoding, Sauce calls and nesting

The routes namespace packages a Sauce program as an Eco intent. Base(body, options) and the other chain globals (installed by importing the root package) forward to routes.openRoute(destination, body, options), which returns a PendingSauceRoute; .nest(...) adds child intents and .reward(...) returns a BuiltIntent.

import { routes } from "@eco-incorp/sauce";

This page covers sdk/dist/routes/encode.d.ts, sdk/dist/routes/sauce-calls.d.ts, sdk/dist/routes/nest.d.ts.

Generated from the type declarations shipped in @eco-incorp/sauce 0.99.4. Each entry shows the package authors’ JSDoc and declaration for this SDK version. For runtime compatibility and deployed addresses, see architecture and deployments.

`routes.denormalizeToEvm`

Function · sdk/dist/routes/encode.d.ts Narrows a 32-byte UniversalAddress to a 20-byte EVM address. Throws (rather than silently truncating) if the leading 12 bytes aren’t zero - that shape means the address is not EVM-representable (e.g. a real SVM pubkey), and truncating it would produce a plausible-looking but wrong hash.

export declare function denormalizeToEvm(u: UniversalAddress): Hex;

`routes.encodeIntent`

Function · sdk/dist/routes/encode.d.ts Encodes an Intent’s route (for intent.destination) and reward (for intent.sourceChainId).

export declare function encodeIntent(intent: Intent): {
    route: Hex;
    reward: Hex;
};

`routes.encodeReward`

Function · sdk/dist/routes/encode.d.ts Encodes a Reward for the given chain, forking by ChainKind.

export declare function encodeReward(reward: Reward, chain: ChainKindRef): Hex;

`routes.encodeRewardEvm`

Function · sdk/dist/routes/encode.d.ts Encodes a Reward for an EVM (or TVM) source via the deployed Portal ABI shape.

export declare function encodeRewardEvm(reward: Reward): Hex;

`routes.encodeRewardSvm`

Function · sdk/dist/routes/encode.d.ts Encodes a Reward for an SVM source via the Portal IDL’s Borsh layout.

export declare function encodeRewardSvm(reward: Reward): Hex;

`routes.encodeRoute`

Function · sdk/dist/routes/encode.d.ts Encodes a Route for the given chain, forking by ChainKind.

export declare function encodeRoute(route: Route, chain: ChainKindRef): Hex;

`routes.encodeRouteEvm`

Function · sdk/dist/routes/encode.d.ts Encodes a Route for an EVM (or TVM) destination via the deployed Portal ABI shape.

export declare function encodeRouteEvm(route: Route): Hex;

`routes.encodeRouteSvm`

Function · sdk/dist/routes/encode.d.ts Encodes a Route for an SVM destination via the Portal IDL’s Borsh layout.

export declare function encodeRouteSvm(route: Route): Hex;

`routes.decodeReward`

Function · sdk/dist/routes/encode.d.ts Decodes a Reward for the given chain, forking by ChainKind.

export declare function decodeReward(encoded: Hex, chain: ChainKindRef): Reward;

`routes.decodeRewardEvm`

Function · sdk/dist/routes/encode.d.ts Decodes a Reward previously produced by encodeRewardEvm, re-normalizing addresses back to 32-byte form.

export declare function decodeRewardEvm(encoded: Hex): Reward;

`routes.decodeRewardSvm`

Function · sdk/dist/routes/encode.d.ts Decodes a Reward previously produced by encodeRewardSvm.

export declare function decodeRewardSvm(encoded: Hex): Reward;

`routes.decodeRoute`

Function · sdk/dist/routes/encode.d.ts Decodes a Route for the given chain, forking by ChainKind.

export declare function decodeRoute(encoded: Hex, chain: ChainKindRef): Route;

`routes.decodeRouteEvm`

Function · sdk/dist/routes/encode.d.ts Decodes a Route previously produced by encodeRouteEvm, re-normalizing addresses back to 32-byte form.

export declare function decodeRouteEvm(encoded: Hex): Route;

`routes.decodeRouteSvm`

Function · sdk/dist/routes/encode.d.ts Decodes a Route previously produced by encodeRouteSvm. calls[].value is reconstituted as 0n.

export declare function decodeRouteSvm(encoded: Hex): Route;

`routes.hashIntent`

Function · sdk/dist/routes/encode.d.ts Computes the eco-routes intent hash: keccak256(abi.encodePacked(uint64 destination, bytes32 routeHash, bytes32 rewardHash)), with the route encoded for intent.destination’s kind and the reward encoded for intent.sourceChainId’s kind - the asymmetry that makes a cross-VM (e.g. EVM source -> SVM destination) leg hash correctly.

export declare function hashIntent(intent: Intent): IntentHashes;

`routes.kindOf`

Function · sdk/dist/routes/encode.d.ts Resolves a ChainKindRef to a ChainKind. An explicit "evm"/"svm" literal is returned as-is (the escape hatch for a chain id not yet in the canonical registry). Anything else is looked up via requireChain, which THROWS for an unregistered id - this never silently defaults to "evm".

export declare function kindOf(ref: ChainKindRef): ChainKind;

`routes.rewardHash`

Function · sdk/dist/routes/encode.d.ts keccak256(encodeReward(reward, source)).

export declare function rewardHash(reward: Reward, source: ChainKindRef): Hex;

`routes.routeHash`

Function · sdk/dist/routes/encode.d.ts keccak256(encodeRoute(route, destination)).

export declare function routeHash(route: Route, destination: ChainKindRef): Hex;

`routes.EVM_ROUTE_PARAM`

Variable · sdk/dist/routes/encode.d.ts The deployed Portal Route tuple shape (fulfillAndProve.inputs[1]).

EVM_ROUTE_PARAM: {
    readonly name: "route";
    readonly type: "tuple";
    readonly components: readonly [
        {
            readonly name: "salt";
            readonly type: "bytes32";
        },
        {
            readonly name: "deadline";
            readonly type: "uint64";
        },
        {
            readonly name: "portal";
            readonly type: "address";
        },
        {
            readonly name: "nativeAmount";
            readonly type: "uint256";
        },
        {
            readonly name: "tokens";
            readonly type: "tuple[]";
            readonly components: readonly [
                {
                    readonly name: "token";
                    readonly type: "address";
                },
                {
                    readonly name: "amount";
                    readonly type: "uint256";
                }
            ];
        },
        {
            readonly name: "calls";
            readonly type: "tuple[]";
            readonly components: readonly [
                {
                    readonly name: "target";
                    readonly type: "address";
                },
                {
                    readonly name: "data";
                    readonly type: "bytes";
                },
                {
                    readonly name: "value";
                    readonly type: "uint256";
                }
            ];
        }
    ];
}

`routes.EVM_REWARD_PARAM`

Variable · sdk/dist/routes/encode.d.ts The deployed Portal Reward tuple shape (publish.inputs[2]).

EVM_REWARD_PARAM: {
    readonly name: "reward";
    readonly type: "tuple";
    readonly components: readonly [
        {
            readonly name: "deadline";
            readonly type: "uint64";
        },
        {
            readonly name: "creator";
            readonly type: "address";
        },
        {
            readonly name: "prover";
            readonly type: "address";
        },
        {
            readonly name: "nativeAmount";
            readonly type: "uint256";
        },
        {
            readonly name: "tokens";
            readonly type: "tuple[]";
            readonly components: readonly [
                {
                    readonly name: "token";
                    readonly type: "address";
                },
                {
                    readonly name: "amount";
                    readonly type: "uint256";
                }
            ];
        }
    ];
}

`routes.svmCallCodec`

Variable · sdk/dist/routes/encode.d.ts Portal IDL Call { target: Bytes32, data: bytes } - NO value field.

svmCallCodec: import("@solana/kit").VariableSizeCodec<{
    target: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    data: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
}, {
    target: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    data: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
} & {
    target: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    data: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
}>

`routes.svmRewardCodec`

Variable · sdk/dist/routes/encode.d.ts Portal IDL Reward { deadline, creator, prover, native_amount, tokens }, field order per the IDL.

svmRewardCodec: import("@solana/kit").VariableSizeCodec<{
    deadline: number | bigint;
    creator: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    prover: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    nativeAmount: number | bigint;
    tokens: {
        token: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
        amount: number | bigint;
    }[];
}, {
    deadline: bigint;
    creator: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    prover: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    nativeAmount: bigint;
    tokens: ({
        token: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
        amount: bigint;
    } & {
        token: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
        amount: number | bigint;
    })[];
} & {
    deadline: number | bigint;
    creator: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    prover: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    nativeAmount: number | bigint;
    tokens: {
        token: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
        amount: number | bigint;
    }[];
}>

`routes.svmRouteCodec`

Variable · sdk/dist/routes/encode.d.ts Portal IDL Route { salt, deadline, portal, native_amount, tokens, calls }, field order per the IDL.

svmRouteCodec: import("@solana/kit").VariableSizeCodec<{
    salt: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    deadline: number | bigint;
    portal: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    nativeAmount: number | bigint;
    tokens: {
        token: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
        amount: number | bigint;
    }[];
    calls: {
        target: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
        data: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    }[];
}, {
    salt: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    deadline: bigint;
    portal: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    nativeAmount: bigint;
    tokens: ({
        token: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
        amount: bigint;
    } & {
        token: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
        amount: number | bigint;
    })[];
    calls: ({
        target: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
        data: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    } & {
        target: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
        data: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    })[];
} & {
    salt: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    deadline: number | bigint;
    portal: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    nativeAmount: number | bigint;
    tokens: {
        token: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
        amount: number | bigint;
    }[];
    calls: {
        target: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
        data: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    }[];
}>

`routes.svmTokenAmountCodec`

Variable · sdk/dist/routes/encode.d.ts Portal IDL TokenAmount { token: Bytes32, amount: u64 }.

svmTokenAmountCodec: import("@solana/kit").FixedSizeCodec<{
    token: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    amount: number | bigint;
}, {
    token: import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    amount: bigint;
} & {
    token: Uint8Array<ArrayBufferLike> | import("@solana/kit").ReadonlyUint8Array<ArrayBufferLike>;
    amount: number | bigint;
}>

`routes.ChainKindRef`

Type · sdk/dist/routes/encode.d.ts Anything that can select which encoding fork to use: an explicit kind, or anything resolveChain accepts - including a native bigint chain id (eco-routes Intent.destination/sourceChainId are bigint), so a caller can pass those straight through without a silent evm mis-classification.

export type ChainKindRef = ChainKind | number | bigint | string | CanonicalChain;

`routes.IntentHashes`

Interface · sdk/dist/routes/encode.d.ts

export interface IntentHashes {
    readonly intentHash: Hex;
    readonly routeHash: Hex;
    readonly rewardHash: Hex;
}

`routes.assertSauceEvmLive`

Function · sdk/dist/routes/sauce-calls.d.ts

@deprecated This checks the historical roster only. Verify pinned release code on chain.

export declare function assertSauceEvmLive(chainId: number): V12Deployment;

`routes.buildSauceCall`

Function · sdk/dist/routes/sauce-calls.d.ts Forks on kindOf(chain) (bigint-aware; throws for an unregistered chain id rather than defaulting to evm) to build one Sauce-executing Call for either engine.

export declare function buildSauceCall(chain: ChainKindRef, params: SauceEvmCallParams | SauceSvmCallParams): CallInput;

`routes.buildSauceCalls`

Function · sdk/dist/routes/sauce-calls.d.ts Plural fork of buildSauceCall.

export declare function buildSauceCalls(chain: ChainKindRef, params: SauceEvmCallsParams | SauceSvmCallsParams): CallInput[];

`routes.buildSauceEvmCall`

Function · sdk/dist/routes/sauce-calls.d.ts One cook(engine, program) call on pot. data is produced by v12Pot.encodeCook - the exact EVM engine encoder, not re-implemented here.

export declare function buildSauceEvmCall(params: SauceEvmCallParams): CallInput;

`routes.buildSauceEvmCalls`

Function · sdk/dist/routes/sauce-calls.d.ts One Call per element of cooks, in the given order, all targeting the same pot.

export declare function buildSauceEvmCalls(params: SauceEvmCallsParams): CallInput[];

`routes.buildSauceSvmCall`

Function · sdk/dist/routes/sauce-calls.d.ts Builds ONE staged SVM route call. Merges account flags within its own instruction only - use buildSauceSvmCalls for the cross-call merge over a whole leg.

export declare function buildSauceSvmCall(params: SauceSvmCallParams): CallInput;

`routes.buildSauceSvmCalls`

Function · sdk/dist/routes/sauce-calls.d.ts RECOMMENDED entry point: builds one staged route call per executions element, with account flags OR-merged across the whole leg by default.

export declare function buildSauceSvmCalls(params: SauceSvmCallsParams): CallInput[];

`routes.mergeSvmAccountFlags`

Function · sdk/dist/routes/sauce-calls.d.ts Cross-call OR-merge of isSigner/isWritable per pubkey across every given instruction’s accounts - the Solana runtime dedupes a repeated pubkey in one transaction to the union of its flags, so a leg’s own two staged calls (e.g. swap half + settle half) sharing an account must agree on the more-permissive flags before either is built, not just within itself.

export declare function mergeSvmAccountFlags(instructions: readonly {
    accounts: readonly SauceSvmAccountMeta[];
}[]): Map<string, {
    isSigner: boolean;
    isWritable: boolean;
}>;

`routes.sauceEvmDeployPotCall`

Function · sdk/dist/routes/sauce-calls.d.ts The leading deployPot(owner, salt) call a solver issues before its first cook() on a Pot that may not exist yet. Supply kitchen explicitly or use chainId to select the pinned release Kitchen. The chain roster is historical; this helper does no RPC or current deployment verification.

export declare function sauceEvmDeployPotCall(params: SauceEvmDeployPotCallParams): CallInput;

`routes.SauceEvmCallParams`

Interface · sdk/dist/routes/sauce-calls.d.ts Verbatim re-export - sizing advice only, emits zero instructions. See the module doc above.

export interface SauceEvmCallParams {
    pot: AddressInput;
    engine: AddressInput;
    program: Hex;
    value?: bigint | number | string;
}