@galacticcouncil/xc-cfg 1.1.0 → 1.2.0-pr320-715f299

package/build/builders/ContractBuilder.d.ts

@@ -1,7 +1,9 @@
+import { Across } from './contracts/Across';
 import { Erc20 } from './contracts/Erc20';
 import { PolkadotXcm } from './contracts/PolkadotXcm';
 import { Wormhole } from './contracts/Wormhole';
 export declare function ContractBuilder(): {
+    Across: typeof Across;
     Batch: () => {
         batchAll: (configs: import("@galacticcouncil/xc-core").ContractConfigBuilder[]) => import("@galacticcouncil/xc-core").ContractConfigBuilder;
     };
@@ -11,7 +13,7 @@ export declare function ContractBuilder(): {
     };
     PolkadotXcm: typeof PolkadotXcm;
     Snowbridge: () => {
-        sendToken: () => import("@galacticcouncil/xc-core").ContractConfigBuilder;
+        v2SendMessage: () => import("@galacticcouncil/xc-core").ContractConfigBuilder;
     };
     Wormhole: typeof Wormhole;
 };

package/build/builders/ExtrinsicBuilder.d.ts

@@ -22,6 +22,12 @@ export declare function ExtrinsicBuilder(): {
         transferAssetsUsingTypeAndThen: (opts: {
             transferType: import(".").XcmTransferType;
         }) => ExtrinsicConfigBuilder;
+        execute: {
+            (messageBuilder: import("./extrinsics/xcm/polkadotXcm").XcmMessageBuilder): ExtrinsicConfigBuilder;
+            (): {
+                viaSnowbridge: () => ExtrinsicConfigBuilder;
+            };
+        };
         send: () => {
             transact: (opts: {
                 fee: number;

package/build/builders/FeeAmountBuilder.d.ts

@@ -1,4 +1,4 @@
-import { FeeAmountConfigBuilder, Parachain } from '@galacticcouncil/xc-core';
+import { EvmChain, FeeAmountConfigBuilder, Parachain } from '@galacticcouncil/xc-core';
 declare function TokenRelayer(): {
     calculateRelayerFee: () => FeeAmountConfigBuilder;
 };
@@ -20,7 +20,29 @@ declare function XcmPaymentApi(): {
 declare function Basejump(): {
     quoteFee: () => FeeAmountConfigBuilder;
 };
+type AcrossSnowbridgeFeeOpts = {
+    hub: Parachain;
+    ethereum: EvmChain;
+};
+declare function AcrossSnowbridge(): {
+    /**
+     * Across-Snowbridge inbound fee composer.
+     *
+     * Reuses `Snowbridge().calculateInboundFee()` for the Snowbridge V2 fees
+     * (executionFee, relayerFee, remoteEtherFee, remoteDotFee) which are
+     * amount-independent, then adds:
+     *   - `swapInputAmount`: how much of the L2 token the Uniswap V3 multicall
+     *     must consume to obtain `executionFee + relayerFee` ETH on Ethereum.
+     *     Padded by 33% for AMM slippage, matching Snowfork.
+     *
+     * The amount-dependent `acrossRelayerFee` is computed at build time by
+     * the contract builder (`Across/Snowbridge.sendTokenAndCall`) because
+     * the FeeAmountConfigParams shape does not carry the transfer amount.
+     */
+    calculateFee: (opts: AcrossSnowbridgeFeeOpts) => FeeAmountConfigBuilder;
+};
 export declare function FeeAmountBuilder(): {
+    AcrossSnowbridge: typeof AcrossSnowbridge;
     Basejump: typeof Basejump;
     XcmPaymentApi: typeof XcmPaymentApi;
     Snowbridge: typeof Snowbridge;

package/build/builders/contracts/Across/Snowbridge.d.ts

@@ -0,0 +1,5 @@
+import { ContractConfigBuilder } from '@galacticcouncil/xc-core';
+export declare const Snowbridge: () => {
+    sendTokenAndCall: () => ContractConfigBuilder;
+    sendEtherAndCall: () => ContractConfigBuilder;
+};

package/build/builders/contracts/Across/Snowbridge.spec.d.ts

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

package/build/builders/contracts/Across/index.d.ts

@@ -0,0 +1,6 @@
+export declare function Across(): {
+    Snowbridge: () => {
+        sendTokenAndCall: () => import("@galacticcouncil/xc-core").ContractConfigBuilder;
+        sendEtherAndCall: () => import("@galacticcouncil/xc-core").ContractConfigBuilder;
+    };
+};

package/build/builders/contracts/Across/swap.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Per-asset swap config consumed by the Across-Snowbridge L2 adaptor multicall
+ * on Ethereum: maps a source-L2 ERC20 address to its Ethereum canonical token
+ * and the Uniswap V3 pool fee tier used to swap a portion into WETH for the
+ * Snowbridge `v2_sendMessage` ether fee.
+ *
+ * Keyed by L2 chain id + lowercase L2 token address. Extend as routes land.
+ * Mirrors the Snowfork registry's `assets[l2Token].swapTokenAddress`/`swapFee`.
+ */
+export type SwapAssetEntry = {
+    swapTokenAddress: `0x${string}`;
+    swapFee: number;
+};
+export declare function getSwapEntry(l2ChainId: number, l2TokenAddress: string): SwapAssetEntry | undefined;
+export type SwapCallDataParams = {
+    router: `0x${string}`;
+    tokenIn: `0x${string}`;
+    tokenOut: `0x${string}`;
+    swapFee: number;
+    recipient: `0x${string}`;
+    amountOut: bigint;
+    amountInMaximum: bigint;
+    deadlineSeconds?: number;
+};
+export type AcrossSuggestedFeeParams = {
+    inputToken: string;
+    outputToken: string;
+    originChainId: number;
+    destinationChainId: number;
+    amount: bigint;
+    apiBaseUrl?: string;
+};
+/**
+ * Queries Across `/suggested-fees` for the relayer fee at a given input
+ * amount. Across relayer fee scales with amount; this is called at contract
+ * build time (where amount is known), not at fee-quote time.
+ *
+ * Returns 0n on any failure so the deposit can still be built; the relayer
+ * may then simply not fill at zero fee — slow fill recovers the user funds.
+ */
+export declare function fetchAcrossRelayerFee(params: AcrossSuggestedFeeParams): Promise<bigint>;
+export declare function buildAcrossSnowbridgeSwapCallData(params: SwapCallDataParams): `0x${string}`;

package/build/builders/contracts/snowbridge/codec.d.ts

@@ -0,0 +1,8 @@
+import { Codec } from 'polkadot-api';
+import { XcmVersionedXcm, XcmVersionedLocation } from '@galacticcouncil/descriptors';
+interface XcmCodecs {
+    message: Codec<XcmVersionedXcm>;
+    location: Codec<XcmVersionedLocation>;
+}
+export declare function getXcmCodecs(): Promise<XcmCodecs>;
+export {};

package/build/builders/contracts/{Snowbridge.d.ts → snowbridge/index.d.ts}

@@ -1,4 +1,4 @@
 import { ContractConfigBuilder } from '@galacticcouncil/xc-core';
 export declare const Snowbridge: () => {
-    sendToken: () => ContractConfigBuilder;
+    v2SendMessage: () => ContractConfigBuilder;
 };

package/build/builders/extrinsics/xcm/builder/Snowbridge.d.ts

@@ -0,0 +1,86 @@
+import { ExtrinsicConfigBuilderParams } from '@galacticcouncil/xc-core';
+import { XcmV5Instruction, XcmV5Junction } from '@galacticcouncil/descriptors';
+import { SizedHex } from 'polkadot-api';
+/**
+ * Location helpers for Snowbridge V2 XCM
+ */
+export declare const etherLocation: (ethChainId: number) => {
+    parents: number;
+    interior: {
+        type: "X1";
+        value: XcmV5Junction;
+    } & {
+        type: "X1";
+    };
+};
+export declare const erc20Location: (ethChainId: number, tokenAddress: string) => {
+    parents: number;
+    interior: {
+        type: "X2";
+        value: import("polkadot-api").FixedSizeArray<2, XcmV5Junction>;
+    } & {
+        type: "X2";
+    };
+};
+export type SnowbridgeInboundXcmParams = {
+    ethChainId: number;
+    destinationParaId: number;
+    tokenAddress: string;
+    beneficiaryHex: string;
+    tokenAmount: bigint;
+    remoteEtherFeeAmount: bigint;
+    remoteDotFeeAmount?: bigint;
+    topic: SizedHex<32>;
+};
+/**
+ * Builds the XCM V5 program passed to `v2_sendMessage` for
+ * transferring ERC20/ETH from Ethereum to a Polkadot parachain.
+ *
+ * If `remoteDotFeeAmount` is provided, an ExchangeAsset instruction
+ * is prepended to swap Ether for DOT on AssetHub (for parachains
+ * that require DOT as the fee asset).
+ *
+ * Flow:
+ * 1. (Optional) ExchangeAsset: swap Ether for DOT on AssetHub
+ * 2. InitiateTransfer to destination parachain
+ *    - remote_fees: ReserveDeposit(ether or DOT) for destination execution
+ *    - assets: ReserveDeposit(token) for the actual transfer
+ *    - remote_xcm: RefundSurplus + DepositAsset to beneficiary
+ * 3. RefundSurplus (reclaim unused ether on Asset Hub)
+ * 4. DepositAsset remaining ether to beneficiary on Asset Hub
+ * 5. SetTopic for tracking
+ */
+export declare function buildSnowbridgeInboundXcm(params: SnowbridgeInboundXcmParams): XcmV5Instruction[];
+export type SnowbridgeOutboundXcmParams = {
+    tokenAddress: string;
+    senderPubKey: string;
+    beneficiaryHex: string;
+    tokenAmount: bigint;
+    sourceExecutionFee: bigint;
+    dotRemoteFee: bigint;
+    dotToEtherSwapAmount: bigint;
+    etherFeeAmount: bigint;
+    topic: SizedHex<32>;
+};
+/**
+ * Builds the V5 XCM program for `polkadotXcm.execute` to transfer
+ * ERC20/ETH from a Polkadot parachain to Ethereum via Snowbridge V2.
+ *
+ * 3-leg program:
+ *
+ * Leg 1 — Source parachain:
+ *   WithdrawAsset, PayFees, SetAppendix (error recovery), InitiateTransfer → AssetHub
+ *
+ * Leg 2 — AssetHub (remote_xcm):
+ *   SetAppendix (error recovery), ExchangeAsset (DOT→Ether), InitiateTransfer → Ethereum
+ *
+ * Leg 3 — Ethereum (innermost remote_xcm):
+ *   DepositAsset to beneficiary, SetTopic
+ */
+export declare function buildSnowbridgeOutboundXcm(params: SnowbridgeOutboundXcmParams): XcmV5Instruction[];
+export declare function snowbridgeOutboundMessage(params: ExtrinsicConfigBuilderParams): {
+    type: "V5";
+    value: XcmV5Instruction[];
+} & {
+    type: "V5";
+};

package/build/builders/extrinsics/xcm/builder/buildParaERC20ReceivedV5.d.ts

@@ -0,0 +1,16 @@
+import { XcmV5Instruction } from '@galacticcouncil/descriptors';
+import { Asset, Parachain } from '@galacticcouncil/xc-core';
+/**
+ * Builds the V5 XCM program that InitiateTransfer generates on the
+ * destination parachain (e.g. Hydration). Used for weight/fee estimation.
+ *
+ * This matches what actually executes on the destination:
+ * 1. ReserveAssetDeposited(DOT)
+ * 2. PayFees(DOT)
+ * 3. ReserveAssetDeposited(token)
+ * 4. ClearOrigin
+ * 5. RefundSurplus
+ * 6. DepositAsset
+ * 7. SetTopic
+ */
+export declare function buildParaERC20ReceivedV5(asset: Asset, chain: Parachain): XcmV5Instruction[];

package/build/builders/extrinsics/xcm/builder/index.d.ts

@@ -2,3 +2,5 @@ export * from './const';
 export * from './buildParaERC20Received';
 export * from './buildERC20TransferFromPara';
 export * from './buildLimitedReserveTransfer';
+export * from './buildParaERC20ReceivedV5';
+export * from './Snowbridge';

package/build/builders/extrinsics/xcm/polkadotXcm.d.ts

@@ -1,4 +1,5 @@
-import { ExtrinsicConfigBuilder } from '@galacticcouncil/xc-core';
+import { ExtrinsicConfigBuilder, ExtrinsicConfigBuilderParams } from '@galacticcouncil/xc-core';
+export type XcmMessageBuilder = (params: ExtrinsicConfigBuilderParams) => any;
 import { XcmTransferType } from './types';
 type TransferOpts = {
     transferType: XcmTransferType;
@@ -6,12 +7,17 @@ type TransferOpts = {
 type TransactOpts = {
     fee: number;
 };
+declare function execute(messageBuilder: XcmMessageBuilder): ExtrinsicConfigBuilder;
+declare function execute(): {
+    viaSnowbridge: () => ExtrinsicConfigBuilder;
+};
 export declare const polkadotXcm: () => {
     limitedReserveTransferAssets: () => ExtrinsicConfigBuilder;
     limitedTeleportAssets: () => ExtrinsicConfigBuilder;
     reserveTransferAssets: () => ExtrinsicConfigBuilder;
     transferAssets: () => ExtrinsicConfigBuilder;
     transferAssetsUsingTypeAndThen: (opts: TransferOpts) => ExtrinsicConfigBuilder;
+    execute: typeof execute;
     send: () => {
         transact: (opts: TransactOpts) => ExtrinsicConfigBuilder;
         transferAsset: (opts: TransactOpts) => ExtrinsicConfigBuilder;

package/build/chains/evm/arbitrum.d.ts

@@ -0,0 +1,2 @@
+import { EvmChain } from '@galacticcouncil/xc-core';
+export declare const arbitrum: EvmChain;

package/build/chains/evm/index.d.ts

@@ -1,5 +1,7 @@
 import { AnyChain } from '@galacticcouncil/xc-core';
+import { arbitrum } from './arbitrum';
 import { base } from './base';
 import { ethereum } from './mainnet';
+import { optimism } from './optimism';
 export declare const evmChains: AnyChain[];
-export { base, ethereum };
+export { arbitrum, base, ethereum, optimism };

package/build/chains/evm/optimism.d.ts

@@ -0,0 +1,2 @@
+import { EvmChain } from '@galacticcouncil/xc-core';
+export declare const optimism: EvmChain;

package/build/clients/base.d.ts

@@ -1,6 +1,6 @@
 import { ChainDefinition, TypedApi } from 'polkadot-api';
 import { Asset, Parachain } from '@galacticcouncil/xc-core';
-import { hub, XcmV4Instruction } from '@galacticcouncil/descriptors';
+import { hub, XcmV4Instruction, XcmV5Instruction } from '@galacticcouncil/descriptors';
 export declare class BaseClient<C extends ChainDefinition = typeof hub> {
     readonly chain: Parachain;
     protected descriptor: C;
@@ -10,4 +10,5 @@ export declare class BaseClient<C extends ChainDefinition = typeof hub> {
     private get refApi();
     getSystemAccountBalance(address: string): Promise<bigint>;
     calculateDestinationFee(xcm: XcmV4Instruction[], asset: Asset): Promise<bigint>;
+    calculateDestinationFeeV5(xcm: XcmV5Instruction[], asset: Asset): Promise<bigint>;
 }

package/build/clients/chain/assethub.d.ts

@@ -1,5 +1,9 @@
 import { Asset, Parachain } from '@galacticcouncil/xc-core';
 import { XcmV4Instruction, Hub } from '@galacticcouncil/descriptors';
+type AssetLocation = {
+    parents: number;
+    interior: any;
+};
 import { BaseClient } from '../base';
 export declare class AssethubClient extends BaseClient<Hub> {
     constructor(chain: Parachain);
@@ -10,4 +14,8 @@ export declare class AssethubClient extends BaseClient<Hub> {
         defaultFee: bigint;
     }): Promise<bigint>;
     calculateDeliveryFee(xcm: XcmV4Instruction[], destParachainId: number): Promise<bigint>;
+    quoteDotToEther(etherLocation: AssetLocation, dotAmount: bigint): Promise<bigint>;
+    quoteEtherForDot(etherLocation: AssetLocation, dotAmount: bigint): Promise<bigint>;
+    quoteDotForExactEther(etherLocation: AssetLocation, etherAmount: bigint): Promise<bigint>;
 }
+export {};

package/build/configs/evm/base/templates.d.ts

@@ -1,3 +1,21 @@
 import { Asset, AssetRoute } from '@galacticcouncil/xc-core';
 export declare function toHydrationViaWormholeTemplate(assetIn: Asset, assetOut: Asset): AssetRoute;
 export declare function toHydrationViaBasejumpTemplate(assetIn: Asset, assetOut: Asset): AssetRoute;
+/**
+ * Across V3 fast-fill on Ethereum → Snowbridge V2 inbound to AssetHub →
+ * XCM InitiateTransfer to Hydration. End-to-end via Snowfork's deployed
+ * `SnowbridgeL2Adaptor` on Base (0x07fe4e7340976fc873b74bafe3c3e5b0e01f3665).
+ *
+ * Phase 0 — fee uses the existing Snowbridge inbound fee builder. A proper
+ * Across-aware fee builder that adds the Across relayer fee (via
+ * `@snowbridge/api/across.estimateFees`) lands with the XCM construction
+ * follow-up referenced in `xc-cfg/builders/contracts/Across/Snowbridge.ts`.
+ */
+export declare function toHydrationViaAcrossSnowbridgeTemplate(assetIn: Asset, assetOut: Asset): AssetRoute;
+/**
+ * Across V3 ETH/WETH path: identical to the ERC20 template but uses the
+ * L2 adaptor's `sendEtherAndCall` entrypoint — no Uniswap swap leg needed
+ * because the multicall on Ethereum unwraps WETH directly to fund the
+ * Snowbridge inbound fee.
+ */
+export declare function toHydrationViaAcrossSnowbridgeEtherTemplate(assetIn: Asset, assetOut: Asset): AssetRoute;