@gibs/bridge-sdk 1.13.1 → 1.18.0

package/dist/claims.js

@@ -0,0 +1,140 @@
+import { encodeFunctionData, isHex, numberToHex } from 'viem';
+import * as abis from './abis.js';
+const strip0x = (input) => input.replace(/^0x/, '');
+/**
+ * Splits one 65-byte validator signature into its `v`, `r` and `s` parts.
+ *
+ * @param rawSignature - the signature as the indexer stores it, with or without a `0x` prefix
+ * @returns the three parts, hex without prefixes
+ */
+export const signatureToVRS = (rawSignature) => {
+    const signature = strip0x(rawSignature);
+    const word = 32;
+    const word2 = word * 2;
+    const word4 = word2 * 2;
+    const r = signature.slice(0, word2);
+    const s = signature.slice(word2, word4);
+    const v = signature.slice(word4);
+    return { v, r, s };
+};
+/**
+ * Packs signatures in the layout the bridge's `executeSignatures` reads: one
+ * count byte, then every `v`, then every `r`, then every `s`.
+ *
+ * @param signatures - the split signatures, in the order the validators signed
+ * @returns the packed signatures as one hex string
+ */
+export const packSignatures = (signatures) => {
+    const length = strip0x(numberToHex(signatures.length));
+    const countByte = length.length === 1 ? `0${length}` : length;
+    const v = signatures.map((signature) => signature.v).join('');
+    const r = signatures.map((signature) => signature.r).join('');
+    const s = signatures.map((signature) => signature.s).join('');
+    return `0x${countByte}${v}${r}${s}`;
+};
+/**
+ * The calldata for a release that pays no delivery tip: a direct call to the
+ * destination bridge.
+ *
+ * @param options.encodedData - the bridge message, `UserRequest.encodedData`
+ * @param options.encodedSignatures - the output of {@link packSignatures}
+ * @returns the calldata for `safeExecuteSignaturesWithAutoGasLimit`
+ */
+export const encodeReleaseWithoutTipData = ({ encodedData, encodedSignatures, }) => encodeFunctionData({
+    abi: abis.relayTokensDirect,
+    functionName: 'safeExecuteSignaturesWithAutoGasLimit',
+    args: [encodedData, encodedSignatures],
+});
+/**
+ * The calldata for a release sent through the pathway's destination output
+ * router, the path a fee-director (delivery) request uses.
+ *
+ * @param options.validator - the pathway's validator contract
+ * @param options.encodedData - the bridge message, `UserRequest.encodedData`
+ * @param options.encodedSignatures - the output of {@link packSignatures}
+ * @returns the calldata for the router's `safeExecuteSignaturesWithAutoGasLimit`
+ */
+export const encodeReleaseToRouterData = ({ validator, encodedData, encodedSignatures, }) => encodeFunctionData({
+    abi: abis.outputRouter,
+    functionName: 'safeExecuteSignaturesWithAutoGasLimit',
+    args: [validator, encodedData, encodedSignatures],
+});
+/**
+ * The one place a claim's target and calldata come from. The interface's
+ * release hook and {@link buildClaimTransaction} both call it.
+ *
+ * @param options.encodedData - the bridge message
+ * @param options.signatures - the raw validator signatures, in signing order
+ * @param options.destinationAmbAddress - the destination bridge, used by the `direct` route
+ * @param options.via - which contract receives the claim
+ * @returns the target contract and the calldata
+ */
+export const claimCall = ({ encodedData, signatures, destinationAmbAddress, via, }) => {
+    const encodedSignatures = packSignatures(signatures.map(signatureToVRS));
+    if (via.kind === 'router') {
+        return {
+            to: via.destinationRouter,
+            data: encodeReleaseToRouterData({ validator: via.validator, encodedData, encodedSignatures }),
+        };
+    }
+    return { to: destinationAmbAddress, data: encodeReleaseWithoutTipData({ encodedData, encodedSignatures }) };
+};
+const isSignatureList = (value) => Array.isArray(value) && value.every((entry) => typeof entry === 'string' && isHex(entry));
+const refused = (refusal) => ({ kind: 'refused', refusal });
+/**
+ * Builds the manual-claim transaction for one bridge request, or refuses with
+ * a typed reason.
+ *
+ * The checks run in this order: request type, delivery, signing, then the
+ * stored signature count. A delivered request is refused before the signing
+ * check, because delivery also sets `finishedSigning`.
+ *
+ * ASSUMPTION: the signatures are only complete when every validator sent
+ * `submitSignature` directly to the home bridge. The indexer drops a
+ * signature sent any other way; see this module's head note. This builder
+ * catches the drop by comparing the stored list with the required-signature
+ * threshold, or with `confirmedSignatures` when the record carries no threshold.
+ *
+ * @param options.request - the indexer's `UserRequest` record
+ * @param options.via - the claim target; see {@link ClaimRoute}
+ * @returns a `claim` plan whose transaction runs on the destination chain, or a refusal
+ */
+export const buildClaimTransaction = ({ request, via, }) => {
+    if (request.type !== 'signature')
+        return refused({ reason: 'wrong-type', type: request.type });
+    if (request.delivered)
+        return refused({ reason: 'already-delivered' });
+    if (!request.finishedSigning)
+        return refused({ reason: 'not-signed-yet' });
+    if (!isSignatureList(request.signatures))
+        return refused({ reason: 'malformed-request', field: 'signatures' });
+    if (!isHex(request.encodedData))
+        return refused({ reason: 'malformed-request', field: 'encodedData' });
+    if (!isHex(request.destinationAmbAddress)) {
+        return refused({ reason: 'malformed-request', field: 'destinationAmbAddress' });
+    }
+    const needed = Number(request.requiredSignatures?.value ?? request.confirmedSignatures);
+    const stored = request.signatures.length;
+    if (stored < needed)
+        return refused({ reason: 'signatures-incomplete', stored, needed });
+    const { to, data } = claimCall({
+        encodedData: request.encodedData,
+        signatures: request.signatures,
+        destinationAmbAddress: request.destinationAmbAddress,
+        via,
+    });
+    return {
+        kind: 'claim',
+        transaction: {
+            chainId: Number(request.destinationChainId),
+            kind: 'claim',
+            to,
+            data,
+            value: 0n,
+            // The calldata itself asks the bridge to pick its own gas limit
+            // (`safeExecuteSignaturesWithAutoGasLimit`); the wallet estimates the rest.
+            gasLimit: null,
+            waitForReceipt: false,
+        },
+    };
+};

package/dist/config.d.ts

@@ -1,4 +1,5 @@
 import { type Hex } from 'viem';
+import type { SwapVenues } from './swap-venues.js';
 import type { BridgeKey, Token, TokenOut } from './types.js';
 /**
  * Add here your chain id as hex, be sure to add your chain in the chainsMetadata object too
@@ -33,10 +34,48 @@ export declare const Providers: {
 export type Provider = (typeof Providers)[keyof typeof Providers];
 /** A map of chains to native asset out addresses */
 export declare const nativeAssetOut: Record<Chains, Hex>;
+/**
+ * Four PulseChain mainnet tokens that no other constant in this package
+ * names. The PulseX carrier routes swaps through them
+ * (`routing/carriers/pulsex-paths.ts`), and the interface builds its
+ * PulseChain hub nodes from the two stablecoins.
+ *
+ * Each address was already in the repository before it moved here: USDC and
+ * USDT from the interface's `HUB_STABLECOIN_ADDRESSES`
+ * (`packages/ui/src/lib/state/useRouteSearch.ts`), PLSX and HEX from
+ * `scripts/route-parity-corpus.ts`. Each one was read on chain again on
+ * 2026-10-06 (`symbol()`, `decimals()`): PLSX 18, HEX 8, USDC 6, USDT 6.
+ * `getAddress` checksums them at load, so a mistyped character fails the
+ * build rather than silently matching nothing.
+ */
+export declare const pulsechainTokenAddresses: Readonly<{
+    /** PulseX, the exchange's own token. */
+    PLSX: `0x${string}`;
+    /** HEX. */
+    HEX: `0x${string}`;
+    /** USD Coin, bridged from Ethereum. */
+    USDC: `0x${string}`;
+    /** Tether USD, bridged from Ethereum. */
+    USDT: `0x${string}`;
+}>;
 /** A map of chains to deprecated native asset out addresses */
 export declare const deprecatedNativeAssetOut: Partial<Record<Chains, Set<Hex>>>;
-/** A map of chains to uni v2 router addresses */
-export declare const uniV2Routers: Record<Chains, Hex[]>;
+/**
+ * The swap venues the package ships with: PulseX V1 then V2 on PulseChain.
+ * Frozen. A caller who wants other routers passes its own
+ * {@link SwapVenues} (see `resolveSwapVenues`); this table is never mutated.
+ *
+ * Each factory is the router's own `router.factory()` read on chain — see
+ * {@link uniV2Factories}'s doc. The fee is 29 basis points for both
+ * deployments (measured, same doc).
+ */
+export declare const defaultSwapVenues: SwapVenues;
+/**
+ * A map of chains to uni v2 router addresses. Frozen. PulseChain's entries
+ * derive from {@link defaultSwapVenues}, so the two cannot drift. Kept for
+ * compatibility; to swap on other routers pass `swapVenues` instead.
+ */
+export declare const uniV2Routers: Readonly<Record<Chains, readonly Hex[]>>;
 /**
  * Each {@link uniV2Routers} entry's OWN factory address, same index, same
  * chain — `router.factory()` read live from `one.valve.city` on 2026-09-24.
@@ -61,7 +100,7 @@ export declare const uniV2Routers: Record<Chains, Hex[]>;
  * salt collision) and worth this note so a future reader does not assume a
  * transcription error and "fix" it back to something wrong.
  */
-export declare const uniV2Factories: Record<Chains, Hex[]>;
+export declare const uniV2Factories: Readonly<Record<Chains, readonly Hex[]>>;
 /** A map of chains to native token symbols */
 export declare const nativeTokenSymbol: Record<Chains, string>;
 /** A map of chains to native token names */

package/dist/config.js

@@ -1,4 +1,3 @@
-import * as _ from 'lodash-es';
 import { getAddress, isAddress, isAddressEqual, keccak256, stringToHex, zeroAddress, } from 'viem';
 /**
  * Add here your chain id as hex, be sure to add your chain in the chainsMetadata object too
@@ -44,16 +43,41 @@ export const nativeAssetOut = {
     [Chains.SEP]: '0x7b79995e5f793A07Bc00c21412e50Ecae098E7f9',
     [Chains.V4PLS]: '0x70499adEBB11Efd915E3b69E700c331778628707',
 };
+/**
+ * Four PulseChain mainnet tokens that no other constant in this package
+ * names. The PulseX carrier routes swaps through them
+ * (`routing/carriers/pulsex-paths.ts`), and the interface builds its
+ * PulseChain hub nodes from the two stablecoins.
+ *
+ * Each address was already in the repository before it moved here: USDC and
+ * USDT from the interface's `HUB_STABLECOIN_ADDRESSES`
+ * (`packages/ui/src/lib/state/useRouteSearch.ts`), PLSX and HEX from
+ * `scripts/route-parity-corpus.ts`. Each one was read on chain again on
+ * 2026-10-06 (`symbol()`, `decimals()`): PLSX 18, HEX 8, USDC 6, USDT 6.
+ * `getAddress` checksums them at load, so a mistyped character fails the
+ * build rather than silently matching nothing.
+ */
+export const pulsechainTokenAddresses = Object.freeze({
+    /** PulseX, the exchange's own token. */
+    PLSX: getAddress('0x95b303987a60c71504d99aa1b13b4da07b0790ab'),
+    /** HEX. */
+    HEX: getAddress('0x2b591e99afe9f32eaa6214f7b7629768c40eeb39'),
+    /** USD Coin, bridged from Ethereum. */
+    USDC: getAddress('0x15d38573d2feeb82e7ad5187ab8c1d52810b1f07'),
+    /** Tether USD, bridged from Ethereum. */
+    USDT: getAddress('0x0cb6f5a34ad42ec934882a05265a7d5f59b51a2f'),
+});
 /** A map of chains to deprecated native asset out addresses */
 export const deprecatedNativeAssetOut = {
     [Chains.PLS]: new Set(['0x97Ac4a2439A47c07ad535bb1188c989dae755341']),
 };
-/** A map of chains to uni v2 router addresses */
-export const uniV2Routers = {
-    [Chains.PLS]: [
-        '0x98bf93ebf5c380C0e6Ae8e192A7e2AE08edAcc02',
-        '0x165C3410fC91EF562C50559f7d2289fEbed552d9',
-    ],
+/**
+ * Routers on chains where this package knows the router but has not verified
+ * a factory, so no {@link SwapVenue} can be built for them. They stay in
+ * {@link uniV2Routers} for the native-price reads (`chain-info.ts`,
+ * `readAmountOut`) that need only a router.
+ */
+const routersWithoutVenue = {
     [Chains.ETH]: ['0x7a250d5630b4cf539739df2c5dacb4c659f2488d'],
     [Chains.BNB]: ['0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F'],
     [Chains.SEP]: ['0xeE567Fe1712Faf6149d80dA1E6934E354124CfE3'],
@@ -62,6 +86,43 @@ export const uniV2Routers = {
         '0x636f6407B90661b73b1C0F7e24F4C79f624d0738',
     ],
 };
+/**
+ * The swap venues the package ships with: PulseX V1 then V2 on PulseChain.
+ * Frozen. A caller who wants other routers passes its own
+ * {@link SwapVenues} (see `resolveSwapVenues`); this table is never mutated.
+ *
+ * Each factory is the router's own `router.factory()` read on chain — see
+ * {@link uniV2Factories}'s doc. The fee is 29 basis points for both
+ * deployments (measured, same doc).
+ */
+export const defaultSwapVenues = Object.freeze({
+    [Number(Chains.PLS)]: Object.freeze([
+        Object.freeze({
+            kind: 'uniswap-v2',
+            chainId: Number(Chains.PLS),
+            router: '0x98bf93ebf5c380C0e6Ae8e192A7e2AE08edAcc02',
+            factory: '0x1715a3E4A142d8b698131108995174F37aEBA10D',
+            feeBasisPoints: 29,
+            label: 'PulseX V1',
+        }),
+        Object.freeze({
+            kind: 'uniswap-v2',
+            chainId: Number(Chains.PLS),
+            router: '0x165C3410fC91EF562C50559f7d2289fEbed552d9',
+            factory: '0x29eA7545DEf87022BAdc76323F373EA1e707C523',
+            feeBasisPoints: 29,
+            label: 'PulseX V2',
+        }),
+    ]),
+});
+/** One chain's routers: its default venues' routers, else the router-only entries. */
+const defaultRoutersFor = (chain) => defaultSwapVenues[Number(chain)]?.map((venue) => venue.router) ?? routersWithoutVenue[chain] ?? [];
+/**
+ * A map of chains to uni v2 router addresses. Frozen. PulseChain's entries
+ * derive from {@link defaultSwapVenues}, so the two cannot drift. Kept for
+ * compatibility; to swap on other routers pass `swapVenues` instead.
+ */
+export const uniV2Routers = Object.freeze(Object.fromEntries(Object.values(Chains).map((chain) => [chain, Object.freeze([...defaultRoutersFor(chain)])])));
 /**
  * Each {@link uniV2Routers} entry's OWN factory address, same index, same
  * chain — `router.factory()` read live from `one.valve.city` on 2026-09-24.
@@ -86,16 +147,10 @@ export const uniV2Routers = {
  * salt collision) and worth this note so a future reader does not assume a
  * transcription error and "fix" it back to something wrong.
  */
-export const uniV2Factories = {
-    [Chains.PLS]: [
-        '0x1715a3E4A142d8b698131108995174F37aEBA10D',
-        '0x29eA7545DEf87022BAdc76323F373EA1e707C523',
-    ],
-    [Chains.ETH]: [],
-    [Chains.BNB]: [],
-    [Chains.SEP]: [],
-    [Chains.V4PLS]: [],
-};
+export const uniV2Factories = Object.freeze(Object.fromEntries(Object.values(Chains).map((chain) => [
+    chain,
+    Object.freeze((defaultSwapVenues[Number(chain)] ?? []).map((venue) => venue.factory)),
+])));
 /** A map of chains to native token symbols */
 export const nativeTokenSymbol = {
     [Chains.PLS]: 'PLS',
@@ -335,12 +390,23 @@ export const inferBridgeKey = ({ currentKey, provider, fromChain, toChain, isPro
  * @param isProd - whether this is a production build; testnets are off when true
  * @returns the group keyed by destination chain, or undefined when unknown
  */
-export const pathwayGroup = (provider, chain, isProd) => _.get(pathways, [provider, chain]) ||
-    (!isProd ? _.get(testnetPathways, [provider, chain]) : undefined);
+export const pathwayGroup = (provider, chain, isProd) => pathways[provider]?.[chain] || (!isProd ? testnetPathways[provider]?.[chain] : undefined);
+/**
+ * Reads one pathway out of a provider, chain and chain map.
+ *
+ * Every level is optional at runtime: the testnet map leaves whole providers
+ * out, and a caller can hold a bridge key built from untrusted input.
+ *
+ * @param config - the pathway map to read
+ * @param bridgeKey - the provider, origin chain and destination chain
+ * @returns the pathway, or undefined when any level is missing
+ */
+const lookupPathway = (config, [provider, from, to]) => config[provider]?.[from]?.[to];
 export const pathway = (bridgeKey, isProd, assetInAddress) => {
     if (!bridgeKey)
         return;
-    let pathway = _.get(pathways, bridgeKey) || (!isProd ? _.get(testnetPathways, bridgeKey) : undefined);
+    let pathway = lookupPathway(pathways, bridgeKey) ||
+        (!isProd ? lookupPathway(testnetPathways, bridgeKey) : undefined);
     if (assetInAddress) {
         const addr = getAddress(assetInAddress);
         if (pathway?.settingOverrides?.[addr]) {
@@ -362,7 +428,7 @@ export const defaultAssetIn = ($bridgeKey, isProd) => {
     if (!$bridgeKey)
         return null;
     const conf = pathway($bridgeKey, isProd);
-    const defaultAssetIn = _.get(conf, ['bridgedNativeAssetOut']);
+    const defaultAssetIn = conf?.bridgedNativeAssetOut;
     return defaultAssetIn;
 };
 /**

package/dist/consolidated-quote.d.ts

@@ -1,22 +1,26 @@
-import type { Hex } from 'viem';
+import { type Hex } from 'viem';
 import type { DestinationCall } from './destination-calldata.js';
 import type { Ecosystem } from './ecosystems.js';
 import { type EvmDeposit, type OriginDeposit } from './origin-deposit.js';
 import type { ProviderId, ProviderQuoteContext } from './providers.js';
 import { type QuoteFee } from './quote-fees.js';
+import type { ApprovalRequirement } from './settings.js';
 import type { RouteStep, Token } from './types.js';
 /**
- * The LI.FI `integrator` sent when a request leaves
- * {@link ConsolidatedQuoteRequest.lifiIntegrator} out.
+ * Gibs Finance's own LI.FI `integrator` label.
  *
- * KEPT AS A DEFAULT BECAUSE IT COSTS THE CALLER NOTHING. LI.FI's `integrator`
- * is an optional label: it changes neither the quote nor the rate limit, and it
- * moves no money unless a `fee` rides with it. A fee is the one case where the
- * label decides who gets paid, so a request that charges a fee must name its
- * own integrator — see {@link lifiAttribution}.
+ * NOT A DEFAULT. A request that leaves
+ * {@link ConsolidatedQuoteRequest.lifiIntegrator} out sends no `integrator`
+ * at all. An integrator label is attribution: LI.FI records the traffic under
+ * it, and pays any `fee` to the account behind it. A wallet that builds on this
+ * package must not attribute its users' routes to Gibs Finance without
+ * choosing to. The Gibs interface passes this value explicitly.
  */
 export declare const lifiIntegrator = "gibs.finance";
-/** Referral fee charged by this integrator on LI.FI routes (0.001 = 0.1%). */
+/**
+ * The referral fee Gibs Finance charges on its own LI.FI routes (0.001 = 0.1%).
+ * No builder applies it. A request carries a fee only when it sets `lifiFee`.
+ */
 export declare const lifiReferralFeePercent = 0.001;
 /**
  * LI.FI's HTTP origin when the interface's `PUBLIC_LIFI_API_URL` build flag is
@@ -235,11 +239,10 @@ export type ConsolidatedQuoteRequest = {
      */
     lifiFee?: number;
     /**
-     * The LI.FI `integrator` label. Left out, {@link lifiIntegrator} is sent;
-     * `null` omits the field; a string is sent as-is. REQUIRED (as a string)
+     * The LI.FI `integrator` label. Left out or `null`, the field is not sent; a
+     * string is sent as-is. REQUIRED (as a string)
      * whenever {@link lifiFee} is positive: LI.FI pays a fee to the account behind
-     * the integrator label, so a fee under the default label would pay Gibs
-     * Finance, not you.
+     * the integrator label, so a fee needs a label that is yours.
      */
     lifiIntegrator?: string | null;
     /**
@@ -298,7 +301,7 @@ export type LifiContractCallsRequestBody = {
     toToken: Hex;
     toAmount: string;
     toFallbackAddress: Hex;
-    /** Omitted when the request set `lifiIntegrator: null`. */
+    /** Present only when the request names a `lifiIntegrator`. */
     integrator?: string;
     /** Referral fee as a decimal fraction (e.g. 0.001 = 0.1%). Omitted when not charging a fee. */
     fee?: number;
@@ -313,7 +316,7 @@ export type LifiContractCallsRequestBody = {
  * @param request - the consolidated request's attribution fields
  * @returns the fields to merge into the request; empty when none apply
  * @throws when a positive `lifiFee` arrives without an explicit `lifiIntegrator`
- *   string — that fee would otherwise be paid to the default integrator
+ *   string — LI.FI would have nobody of yours to pay it to
  */
 export declare const lifiAttribution: (request: Pick<ConsolidatedQuoteRequest, "lifiFee" | "lifiIntegrator">) => {
     integrator?: string;
@@ -427,6 +430,97 @@ export type ConsolidatedQuote = {
  * path must never silently proceed on a Solana or Bitcoin payload.
  */
 export declare const evmDepositOf: (quote: ConsolidatedQuote) => EvmDeposit;
+/** Why an aggregator's origin deposit is refused before anything is approved or sent. */
+export type AggregatorOriginRefusal = {
+    reason: 'not-evm-deposit';
+    depositFamily: string;
+} | {
+    reason: 'chain-mismatch';
+    depositChainId: number;
+    requestChainId: number;
+} | {
+    reason: 'unverified-provider';
+    provider: string;
+} | {
+    reason: 'unverified-chain';
+    provider: string;
+    chainId: number;
+} | {
+    reason: 'spender-not-allowed';
+    provider: string;
+    spender: Hex;
+} | {
+    reason: 'deposit-target-not-allowed';
+    provider: string;
+    target: Hex;
+} | {
+    reason: 'deposit-shape';
+    provider: string;
+    detail: string;
+} | {
+    reason: 'amount-mismatch';
+    provider: string;
+    /** Which figure disagreed: the quote's own, the native value, or the amount inside the calldata. */
+    field: 'quote-from-amount' | 'deposit-value' | 'calldata-amount';
+    expected: bigint;
+    actual: bigint;
+} | {
+    reason: 'recipient-mismatch';
+    provider: string;
+    /** Which address disagreed: the native payee, the transfer payee, or the token a deposit names. */
+    field: 'deposit-to' | 'transfer-to' | 'calldata-token';
+    expected: string;
+    actual: string;
+} | {
+    reason: 'lifi-guard';
+    detail: string;
+};
+/**
+ * What an aggregator's Ethereum origin deposit asks the wallet to send: the
+ * approval it needs first, if any, and the deposit itself. Both are checked
+ * before they are returned.
+ */
+export type AggregatorOriginCalls = {
+    kind: 'calls';
+    approval: ApprovalRequirement | null;
+    deposit: EvmDeposit;
+} | {
+    kind: 'refused';
+    refusal: AggregatorOriginRefusal;
+};
+/**
+ * Reads the approval and the deposit off an aggregator quote with an Ethereum
+ * origin, after checking both against what this code knows about the
+ * provider. The interface's aggregator press (`stores/consolidated-execute.ts`)
+ * and the SDK's execution planner both read them here, so neither can sign a
+ * call the other would refuse.
+ *
+ * WHAT IS CHECKED, BEFORE ANYTHING IS APPROVED OR SENT:
+ * - Every provider: when the request names the amount to send
+ *   (`request.fromAmount`), the quote's own `fromAmount` must equal it.
+ * - LI.FI: `verifyLifiEvmExecution`: the Diamond for the chain, a known
+ *   facet call, calldata that matches the request, and the decoded amount
+ *   pulled from the reader equal to the amount to send.
+ * - Relay: the deposit target and the spender are Relay's depository for the
+ *   chain (`relayDepositoryByChainId`). A native deposit carries the amount
+ *   as `value` through `depositNative`; a token deposit carries no value and
+ *   is `depositErc20` for the request's token and the amount.
+ * - NEAR Intents: no spender, and a plain payment of the amount to send to the
+ *   quote's own deposit address (`quote.quoteId`), native or `transfer`.
+ * - Any other provider is refused. Its spender is unknown.
+ *
+ * The approval is for exactly the amount to send (the request's, else the
+ * quote's when the route is solved backwards and the request names none), on
+ * the request's origin chain. The native coin needs none.
+ *
+ * @param options.quote - the live quote to sign
+ * @param options.request - the request it answered
+ * @returns the checked approval and deposit, or why they are refused
+ */
+export declare const aggregatorOriginCalls: ({ quote, request, }: {
+    quote: ConsolidatedQuote;
+    request: ConsolidatedQuoteRequest;
+}) => AggregatorOriginCalls;
 /**
  * Normalizes a quote response from the contract-calls endpoint.
  *