@galacticcouncil/xc-cfg 1.2.0 → 1.3.0-pr297-5ef0efa

package/build/bridges/snowbridge/constants.d.ts

@@ -0,0 +1,6 @@
+export type SnowbridgeFast = boolean;
+export declare const SNOWBRIDGE_BASE_DISPATCH_GAS = 80000n;
+export declare const SNOWBRIDGE_BASE_VERIFICATION_GAS = 120000n;
+export declare const SNOWBRIDGE_SUBMIT_GAS = 1000000n;
+export declare const SNOWBRIDGE_FIAT_SHAMIR_GAS = 2000000n;
+export declare const ASSETHUB_ETHER_ED = 15000000000000n;

package/build/bridges/snowbridge/index.d.ts

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './volumeFee';

package/build/bridges/snowbridge/volumeFee.d.ts

@@ -0,0 +1,35 @@
+import { Asset, Dex } from '@galacticcouncil/xc-core';
+/**
+ * Snowbridge V2 volume-based relayer fee schedule.
+ * Direction:
+ *  - Ethereum → Polkadot: add the result to `relayerFee` (5th arg of
+ *    `v2_sendMessage`).
+ *  - Polkadot → Ethereum: add the result to `etherFeeAmount`, which flows
+ *    into the AH→Ethereum InitiateTransfer `remote_fees`.
+ */
+export type FeeBand = {
+    lowerUsd: bigint;
+    upperUsd: bigint;
+    numerator: bigint;
+    denominator: bigint;
+};
+export type VolumeFeeParams = {
+    txValueUsd: bigint;
+    ethToUsdNumerator: bigint;
+    ethToUsdDenominator: bigint;
+};
+export declare const FEE_SCHEDULE: FeeBand[];
+export declare function lookupFeeRatio(txValueUsd: bigint): {
+    numerator: bigint;
+    denominator: bigint;
+};
+export declare function calculateVolumeTipInWei(params: VolumeFeeParams): bigint;
+/**
+ * Compute the Snowbridge V2 volume tip for a transfer, sourcing all USD and
+ * ETH spot prices from the supplied Dex (typically Hydration's).
+ *
+ * Returns 0 when amount is missing or non-positive — the fee builder is
+ * called once at preview render with no amount, and we don't want to bill a
+ * tip for a phantom transfer.
+ */
+export declare function getVolumeTipInWei(dex: Dex, transferAsset: Asset, transferAmount: bigint): Promise<bigint>;

package/build/builders/ContractBuilder.d.ts

@@ -11,7 +11,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,5 @@
 import { FeeAmountConfigBuilder, Parachain } from '@galacticcouncil/xc-core';
+import { SnowbridgeFast } from '../bridges/snowbridge';
 declare function TokenRelayer(): {
     calculateRelayerFee: () => FeeAmountConfigBuilder;
 };
@@ -8,9 +9,12 @@ declare function Wormhole(): {
 type SendFeeOpts = {
     hub: Parachain;
 };
+type OutboundFeeOpts = SendFeeOpts & {
+    fast?: SnowbridgeFast;
+};
 declare function Snowbridge(): {
     calculateInboundFee: (opts: SendFeeOpts) => FeeAmountConfigBuilder;
-    calculateOutboundFee: (opts: SendFeeOpts) => FeeAmountConfigBuilder;
+    calculateOutboundFee: (opts: OutboundFeeOpts) => FeeAmountConfigBuilder;
 };
 declare function XcmPaymentApi(): {
     calculateDestFee: (opts?: {

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,93 @@
+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";
+    };
+};
+/**
+ * Builds the complete XCM that AssetHub actually executes for a Snowbridge V2
+ * inbound transfer: BridgeHub's prelude (ReserveAssetDeposited + ExchangeAsset
+ * + PayFees) followed by the user XCM.
+ */
+export declare function buildSnowbridgeInboundDryRunXcm(ethChainId: number, destinationParaId: number): XcmV5Instruction[];
+export type SnowbridgeInboundXcmParams = {
+    ethChainId: number;
+    destinationParaId: number;
+    tokenAddress: string;
+    beneficiaryHex: string;
+    tokenAmount: bigint;
+    hydrationDotFee: bigint;
+    topic: SizedHex<32>;
+};
+/**
+ * Builds the XCM V5 program passed to `v2_sendMessage` for
+ * transferring ERC20/ETH from Ethereum to a Polkadot parachain.
+ *
+ * BridgeHub V2's inbound queue deposits ether + token into holding and
+ * pays for AH-side execution from its own prelude. We do NOT assume any
+ * DOT is left in holding for us — instead we explicitly swap leftover
+ * ether into the exact DOT amount needed for the destination's PayFees,
+ * then forward token + DOT downstream via InitiateTransfer.
+ *
+ * Flow:
+ * 1. SetAppendix — refund + deposit-to-beneficiary on error
+ * 2. ExchangeAsset — swap leftover ether → hydrationDotFee DOT
+ * 3. InitiateTransfer to destination parachain
+ *    - remote_fees: ReserveDeposit(DOT) sized for destination PayFees
+ *    - assets: ReserveDeposit(token) for the actual transfer
+ *    - remote_xcm: RefundSurplus + DepositAsset to beneficiary
+ * 4. RefundSurplus + DepositAsset — sweep leftover assets to beneficiary on AH
+ * 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/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/polkadot/hydration/templates.d.ts

@@ -10,4 +10,6 @@ export declare function toHubExtTemplate(asset: Asset): AssetRoute;
 export declare function toParaErc20Template(asset: Asset, destination: Parachain, transferType?: XcmTransferType): AssetRoute;
 export declare function toMoonbeamErc20Template(asset: Asset): AssetRoute;
 export declare function viaWormholeBridgeTemplate(assetIn: Asset, assetOut: Asset, to: AnyChain): AssetRoute;
-export declare function viaSnowbridgeTemplate(assetIn: Asset, assetOut: Asset, to: AnyChain): AssetRoute;
+export declare function viaSnowbridgeTemplate(assetIn: Asset, assetOut: Asset, to: AnyChain, opts?: {
+    fast?: boolean;
+}): AssetRoute;