@galacticcouncil/xc-cfg 2.3.0-pr350-7caff1d → 2.3.0

package/build/assets.d.ts

@@ -50,6 +50,7 @@ export declare const weth: Asset;
 export declare const weth_wh: Asset;
 export declare const wbtc: Asset;
 export declare const wbtc_wh: Asset;
+export declare const wsol: Asset;
 export declare const wsteth: Asset;
 export declare const wud: Asset;
 export declare const assets: Asset[];

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

@@ -0,0 +1,12 @@
+export declare const NTT_DEFAULT_INSTRUCTIONS = "0x00";
+export declare const NTT_TRIMMED_DECIMALS = 8;
+export declare const EXECUTOR_API = "https://executor.labsapis.com";
+/**
+ * Names the ntt message an Executor request is paying to deliver.
+ *
+ * The sequence is the manager's `nextMessageSequence()` read at build time,
+ * so a transfer through the same manager landing in between leaves the
+ * request pointing at the wrong message. It relays nothing then, and the
+ * transfer stays claimable by hand.
+ */
+export declare const encodeNttRequest: (srcWormholeId: number, nttManager: string, sequence: bigint) => `0x${string}`;

package/build/bridges/wormhole/constants.spec.d.ts

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

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

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

package/build/builders/ExtrinsicBuilder.d.ts

@@ -11,8 +11,8 @@ export declare function ExtrinsicBuilder(): {
     balances: () => {
         transferAll: (keepAlive?: boolean) => ExtrinsicConfigBuilder;
     };
-    ethereumXcm: () => {
-        transact: (config: import("@galacticcouncil/xc-core").ContractConfigBuilder) => ExtrinsicConfigBuilder;
+    evm: () => {
+        call: (contract: import("@galacticcouncil/xc-core").ContractConfigBuilder) => ExtrinsicConfigBuilder;
     };
     polkadotXcm: () => {
         limitedReserveTransferAssets: () => ExtrinsicConfigBuilder;
@@ -29,14 +29,6 @@ export declare function ExtrinsicBuilder(): {
                 viaSnowbridge: () => ExtrinsicConfigBuilder;
             };
         };
-        send: () => {
-            transact: (opts: {
-                fee: number;
-            }) => ExtrinsicConfigBuilder;
-            transferAsset: (opts: {
-                fee: number;
-            }) => ExtrinsicConfigBuilder;
-        };
     };
     router: () => {
         buy: (opts: {

package/build/builders/FeeAmountBuilder.d.ts

@@ -13,6 +13,20 @@ declare function XcmPaymentApi(): {
         reserve?: AnyParachain;
     }) => FeeAmountConfigBuilder;
 };
+declare function Wormhole(): {
+    /**
+     * Native gas an executor-delivered NTT transfer pays on top of itself -
+     * the wormhole delivery price plus what the Executor charges to redeem
+     * on the far side.
+     *
+     * Declared as the route's destination fee because an erc20 source pays it
+     * out of a balance the amount never competes for, so
+     * {@link EvmPlatform.estimateFee} deliberately leaves the call value out.
+     * A native gas source must NOT use this - there the value is already part
+     * of the source fee, and charging it twice inflates the route minimum.
+     */
+    quoteExecutorCost: () => FeeAmountConfigBuilder;
+};
 declare function Basejump(): {
     quoteFee: () => FeeAmountConfigBuilder;
 };
@@ -20,5 +34,6 @@ export declare function FeeAmountBuilder(): {
     Basejump: typeof Basejump;
     XcmPaymentApi: typeof XcmPaymentApi;
     Snowbridge: typeof Snowbridge;
+    Wormhole: typeof Wormhole;
 };
 export {};

package/build/builders/contracts/Wormhole/Ntt.d.ts

@@ -1,4 +1,6 @@
 import { ContractConfigBuilder } from '@galacticcouncil/xc-core';
 export declare const Ntt: () => {
     transfer: () => ContractConfigBuilder;
+    transferWithExecutor: () => ContractConfigBuilder;
+    transferViaExecutor: () => ContractConfigBuilder;
 };

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

@@ -1,5 +1,7 @@
 export declare function Wormhole(): {
     Ntt: () => {
         transfer: () => import("@galacticcouncil/xc-core").ContractConfigBuilder;
+        transferWithExecutor: () => import("@galacticcouncil/xc-core").ContractConfigBuilder;
+        transferViaExecutor: () => import("@galacticcouncil/xc-core").ContractConfigBuilder;
     };
 };

package/build/builders/extrinsics/evm.d.ts

@@ -0,0 +1,4 @@
+import { ContractConfigBuilder, ExtrinsicConfigBuilder } from '@galacticcouncil/xc-core';
+export declare const evm: () => {
+    call: (contract: ContractConfigBuilder) => ExtrinsicConfigBuilder;
+};

package/build/builders/extrinsics/evm.spec.d.ts

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

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

@@ -1,4 +1,3 @@
-export { ethereumXcm } from './ethereumXcm';
 export { polkadotXcm } from './polkadotXcm';
 export { xTokens } from './xTokens';
 export * from './builder';

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

@@ -5,9 +5,6 @@ type TransferOpts = {
     transferType: XcmTransferType;
     executionFee?: number;
 };
-type TransactOpts = {
-    fee: number;
-};
 declare function execute(messageBuilder: XcmMessageBuilder): ExtrinsicConfigBuilder;
 declare function execute(): {
     viaSnowbridge: () => ExtrinsicConfigBuilder;
@@ -19,9 +16,5 @@ export declare const polkadotXcm: () => {
     transferAssets: () => ExtrinsicConfigBuilder;
     transferAssetsUsingTypeAndThen: (opts: TransferOpts) => ExtrinsicConfigBuilder;
     execute: typeof execute;
-    send: () => {
-        transact: (opts: TransactOpts) => ExtrinsicConfigBuilder;
-        transferAsset: (opts: TransactOpts) => ExtrinsicConfigBuilder;
-    };
 };
 export {};

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

@@ -1,6 +1,6 @@
-import { Asset, Parachain, TxWeight } from '@galacticcouncil/xc-core';
+import { Asset, Parachain } from '@galacticcouncil/xc-core';
 import { SizedHex } from 'polkadot-api';
-import { XcmV3Junctions, XcmV3Junction, XcmV3MultiassetFungibility, XcmV4Instruction, XcmV4AssetAssetFilter, XcmV3WeightLimit, XcmV2OriginKind } from '@galacticcouncil/descriptors';
+import { XcmV3Junctions, XcmV3Junction, XcmV4Instruction, XcmV4AssetAssetFilter } from '@galacticcouncil/descriptors';
 import { XcmTransferType, XcmVersion } from './types';
 export declare const isSnowbridgeTransfer: (assetLocation: any) => boolean;
 export declare const toDest: (version: XcmVersion, source: Parachain, destination: Parachain) => {
@@ -201,146 +201,3 @@ export declare const toReserveXcmOnDest: (version: XcmVersion, account: any, des
         type: "DepositReserveAsset";
     }))[];
 };
-/**
- * Instructions are executed in 3 steps:
- *
- * 1) WithdrawAsset - Withdraw fee asset from the target account
- * 2) BuyExecution - Buy execution with the fee asset
- * 3) Transact - Destination (Transact) chain call execution
- *
- * Note that DepositAsset using AllCounted and not All, since All
- * has too high of a gas requirement.
- *
- * @param version - XCM Version
- * @param account - destination account (receiver)
- * @param transactFeeLocation - transact fee xcm location
- * @param transactFeeAmount - transact fee amount
- * @param transactCall - transact calldata
- * @param transactWeight - transact weight
- * @returns xcm transact message instructions
- */
-export declare const toTransactMessage: (version: XcmVersion, account: any, transactFeeLocation: {
-    parents: number;
-    interior: XcmV3Junctions;
-}, transactFeeAmount: any, transactCall: Uint8Array, transactWeight: TxWeight) => {
-    type: XcmVersion;
-    value: (({
-        type: "BuyExecution";
-        value: {
-            fees: {
-                id: {
-                    parents: number;
-                    interior: XcmV3Junctions;
-                };
-                fun: XcmV3MultiassetFungibility;
-            };
-            weight_limit: XcmV3WeightLimit;
-        };
-    } & {
-        type: "BuyExecution";
-    }) | ({
-        type: "DepositAsset";
-        value: {
-            assets: XcmV4AssetAssetFilter;
-            beneficiary: {
-                parents: number;
-                interior: XcmV3Junctions;
-            };
-        };
-    } & {
-        type: "DepositAsset";
-    }) | ({
-        type: "WithdrawAsset";
-        value: {
-            id: {
-                parents: number;
-                interior: XcmV3Junctions;
-            };
-            fun: XcmV3MultiassetFungibility;
-        }[];
-    } & {
-        type: "WithdrawAsset";
-    }) | ({
-        type: "Transact";
-        value: {
-            call: Uint8Array<ArrayBufferLike>;
-            origin_kind: XcmV2OriginKind;
-            require_weight_at_most: {
-                ref_time: bigint;
-                proof_size: bigint;
-            };
-        };
-    } & {
-        type: "Transact";
-    }) | ({
-        type: "RefundSurplus";
-        value: undefined;
-    } & {
-        type: "RefundSurplus";
-    }))[];
-};
-export declare const toTransferMessage: (version: XcmVersion, account: any, transferAssetLocation: {
-    parents: number;
-    interior: XcmV3Junctions;
-}, transferAssetAmount: any, transferFeeAmount: any, receiver: any) => {
-    type: XcmVersion;
-    value: (({
-        type: "BuyExecution";
-        value: {
-            fees: {
-                id: {
-                    parents: number;
-                    interior: XcmV3Junctions;
-                };
-                fun: XcmV3MultiassetFungibility;
-            };
-            weight_limit: XcmV3WeightLimit;
-        };
-    } & {
-        type: "BuyExecution";
-    }) | ({
-        type: "DepositAsset";
-        value: {
-            assets: XcmV4AssetAssetFilter;
-            beneficiary: {
-                parents: number;
-                interior: XcmV3Junctions;
-            };
-        };
-    } & {
-        type: "DepositAsset";
-    }) | ({
-        type: "WithdrawAsset";
-        value: {
-            id: {
-                parents: number;
-                interior: XcmV3Junctions;
-            };
-            fun: XcmV3MultiassetFungibility;
-        }[];
-    } & {
-        type: "WithdrawAsset";
-    }) | ({
-        type: "RefundSurplus";
-        value: undefined;
-    } & {
-        type: "RefundSurplus";
-    }) | ({
-        type: "TransferAsset";
-        value: {
-            assets: {
-                id: {
-                    parents: number;
-                    interior: XcmV3Junctions;
-                };
-                fun: XcmV3MultiassetFungibility;
-            }[];
-            beneficiary: {
-                parents: number;
-                interior: XcmV3Junctions;
-            };
-        };
-    } & {
-        type: "TransferAsset";
-    }))[];
-};

package/build/clients/index.d.ts

@@ -1,3 +1,4 @@
 export * from './base';
-export * from './bridge';
 export * from './chain';
+export * from './ntt';
+export * from './wormhole';

package/build/clients/ntt/NttEvmClient.d.ts

@@ -0,0 +1,13 @@
+import { AnyChain, AnyEvmChain, Asset } from '@galacticcouncil/xc-core';
+import { ExecutorBudget } from '../wormhole';
+import { NttClient, NttRateLimit } from './types';
+export declare class NttEvmClient implements NttClient {
+    private readonly chain;
+    private readonly asset?;
+    constructor(chain: AnyEvmChain, asset?: Asset | undefined);
+    getOutboundLimit(): Promise<NttRateLimit>;
+    getInboundLimit(from: AnyChain): Promise<NttRateLimit>;
+    /** An evm redeem holds nothing - receiveMessage moves no value. */
+    getRedeemBudget(): Promise<ExecutorBudget>;
+    private getLimit;
+}

package/build/clients/ntt/NttSolanaClient.d.ts

@@ -0,0 +1,22 @@
+import { AnyChain, Asset, SolanaChain } from '@galacticcouncil/xc-core';
+import { ExecutorBudget } from '../wormhole';
+import { NttClient, NttRateLimit } from './types';
+export declare class NttSolanaClient implements NttClient {
+    private readonly chain;
+    private readonly asset?;
+    constructor(chain: SolanaChain, asset?: Asset | undefined);
+    getOutboundLimit(): Promise<NttRateLimit>;
+    getInboundLimit(from: AnyChain): Promise<NttRateLimit>;
+    /**
+     * An svm redeem mints into the recipient's associated token account and the
+     * relayer opens it when missing, so its rent is charged only then -
+     * mirroring upstream, which adds it on `getAccountInfo(ata) === null`.
+     *
+     * Budgeting it unconditionally would be simpler, but the executor charges
+     * source native for lamports it fronts, so every transfer to an existing
+     * account would pay for rent nobody spends.
+     */
+    getRedeemBudget(recipient?: string): Promise<ExecutorBudget>;
+    private getLimit;
+    private rateLimitPda;
+}

package/build/clients/ntt/NttSuiClient.d.ts

@@ -0,0 +1,13 @@
+import { AnyChain, Asset, SuiChain } from '@galacticcouncil/xc-core';
+import { ExecutorBudget } from '../wormhole';
+import { NttClient, NttRateLimit } from './types';
+export declare class NttSuiClient implements NttClient {
+    private readonly chain;
+    private readonly asset?;
+    constructor(chain: SuiChain, asset?: Asset | undefined);
+    getOutboundLimit(): Promise<NttRateLimit>;
+    getInboundLimit(from: AnyChain): Promise<NttRateLimit>;
+    /** A sui redeem holds nothing - the coin is minted to the recipient. */
+    getRedeemBudget(): Promise<ExecutorBudget>;
+    private getLimit;
+}

package/build/clients/ntt/index.d.ts

@@ -0,0 +1,18 @@
+import { AnyChain, Asset } from '@galacticcouncil/xc-core';
+import { NttEvmClient } from './NttEvmClient';
+import { NttSolanaClient } from './NttSolanaClient';
+import { NttSuiClient } from './NttSuiClient';
+import { NttClient } from './types';
+export * from './types';
+export { NttEvmClient, NttSolanaClient, NttSuiClient };
+/**
+ * Ntt deployment on a chain, for an asset.
+ *
+ * Keyed on the chain the question is about, not the direction of travel:
+ * hydration -> sui asks sui for both the inbound limit and the redeem budget,
+ * and it is sui's answer that binds.
+ *
+ * @param asset - omit only when the budget is wanted and the destination asset
+ * is not resolved yet; the rate limits need it.
+ */
+export declare function nttClient(chain: AnyChain, asset?: Asset): NttClient;

package/build/clients/ntt/index.spec.d.ts

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

package/build/clients/ntt/types.d.ts

@@ -0,0 +1,45 @@
+import { AnyChain, Asset, NttTokenDef } from '@galacticcouncil/xc-core';
+import { ExecutorBudget } from '../wormhole';
+/**
+ * Rate limit of one direction of an ntt manager.
+ *
+ * `capacity` is the headroom right now - the manager refills it linearly over
+ * `windowMs`. A `windowMs` of 0 means the direction is not metered at all.
+ */
+export interface NttRateLimit {
+    capacity: bigint;
+    limit: bigint;
+    windowMs: number;
+    capacityAtLastTx: bigint;
+    lastTxMs: number;
+}
+/**
+ * The ntt deployment on one chain, for one asset.
+ *
+ * Both halves of a transfer read the same deployment: the rate limits decide
+ * whether it is allowed through, the redeem budget decides what delivering it
+ * costs. Keyed on the chain the question is about - an inbound limit and a
+ * redeem budget are both destination-side.
+ */
+export interface NttClient {
+    getOutboundLimit(): Promise<NttRateLimit>;
+    getInboundLimit(from: AnyChain): Promise<NttRateLimit>;
+    /**
+     * What the Executor must reserve to redeem this transfer.
+     *
+     * @param recipient - whose accounts the redeem may have to open. Without it
+     * the budget assumes the worst case rather than reading chain.
+     */
+    getRedeemBudget(recipient?: string): Promise<ExecutorBudget>;
+}
+export declare const UNMETERED: NttRateLimit;
+/**
+ * Deployment for the asset this client was built for.
+ *
+ * Resolved per call rather than in the constructor: a redeem budget on an evm
+ * or sui destination never reads the registry, so constructing a client for an
+ * unregistered asset must not throw on its own.
+ */
+export declare function nttDef(chain: AnyChain, asset?: Asset): NttTokenDef;
+/** Mirrors the manager's linear refill (rate_limit::capacity_at). */
+export declare function capacityAt(limit: bigint, capacityAtLastTx: bigint, lastTxTimestamp: bigint, now: bigint, duration: bigint): bigint;

package/build/clients/wormhole/ExecutorClient.d.ts

@@ -0,0 +1,50 @@
+/**
+ * What the Executor is asked to reserve to deliver on a destination.
+ *
+ * `gasLimit` budgets execution, `msgValue` budgets what the executor must
+ * hold. Both are destination units - evm gas, svm compute units, sui MIST -
+ * so neither has a value that is meaningful across chains.
+ */
+export interface ExecutorBudget {
+    gasLimit: bigint;
+    msgValue: bigint;
+}
+export type ExecutorQuote = {
+    /** Quoter-signed cost attestation, passed through to the shim. */
+    signedQuote: `0x${string}`;
+    /** What the Executor charges for delivery, in source chain native. */
+    estimatedCost: bigint;
+    /** Serialized delivery request the quote was priced for. */
+    relayInstructions: `0x${string}`;
+};
+/**
+ * Off-chain Executor quoting service.
+ *
+ * A signed quote carries its own expiry (an hour, currently) and the executor
+ * rejects a stale one, so quotes are reused only while comfortably live.
+ */
+export declare class ExecutorClient {
+    /** Live quotes, keyed by what they were priced for. */
+    private readonly quotes;
+    /**
+     * Price the delivery of one NTT transfer.
+     *
+     * @param srcWormholeId - source chain wormhole id
+     * @param dstWormholeId - destination chain wormhole id
+     * @param budget - what the executor must reserve on the destination, from
+     * {@link ExecutorBudget}. Both halves are keyed here: a quote is only
+     * honoured for the instructions it priced.
+     */
+    quote(srcWormholeId: number, dstWormholeId: number, budget: ExecutorBudget): Promise<ExecutorQuote>;
+}
+/**
+ * Shared instance - always quote through this, never a fresh client.
+ *
+ * The route's fee builder quotes to size the funding and the contract builder
+ * quotes to spend it, and those two numbers have to be the same one. Quoting
+ * twice lets the destination gas price move in between - observed drift was
+ * 807e9 wei against a 9e9 margin - and the transfer then reverts underfunded.
+ * Separate instances would each hold their own cache and reintroduce exactly
+ * that.
+ */
+export declare const executorClient: ExecutorClient;

package/build/clients/wormhole/ExecutorClient.spec.d.ts

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

package/build/clients/wormhole/index.d.ts

@@ -0,0 +1 @@
+export * from './ExecutorClient';

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

@@ -1,3 +1,9 @@
 import { Asset, AssetRoute } from '@galacticcouncil/xc-core';
 export declare function toHydrationViaNttTemplate(assetIn: Asset, assetOut: Asset): AssetRoute;
+/**
+ * Executor-delivered variant, offered alongside the self-redeem route above
+ * for the same pair - the sender pays for delivery instead of signing a
+ * redeem on the destination. Cost is native gas on the source chain.
+ */
+export declare function toHydrationViaNttExecutorTemplate(assetIn: Asset, assetOut: Asset): AssetRoute;
 export declare function toHydrationViaBasejumpTemplate(assetIn: Asset, assetOut: Asset): AssetRoute;

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

@@ -1,4 +1,22 @@
 import { Asset, AssetRoute } from '@galacticcouncil/xc-core';
 export declare function toHydrationViaNttTemplate(assetIn: Asset, assetOut: Asset): AssetRoute;
+/**
+ * Executor-delivered variant, offered alongside the self-redeem route above
+ * for the same pair - the sender pays for delivery instead of signing a
+ * redeem on the destination.
+ *
+ * The cost is native gas on the source chain, declared as the destination fee
+ * because an erc20 source pays it from a balance the amount never competes
+ * for (which is why EvmPlatform.estimateFee leaves the call value out there).
+ */
+export declare function toHydrationViaNttExecutorTemplate(assetIn: Asset, assetOut: Asset): AssetRoute;
+/**
+ * Executor-delivered ntt out of a native gas source.
+ *
+ * The delivery price & executor cost come out of the very balance being
+ * bridged, so they are already folded into the source fee - declaring them
+ * as a destination fee too would charge the user twice.
+ */
+export declare function toHydrationViaNttExecutorNativeTemplate(assetIn: Asset, assetOut: Asset): AssetRoute;
 export declare function toHydrationViaSnowbridgeTemplate(assetIn: Asset, assetOut: Asset): AssetRoute;
 export declare function toHydrationViaSnowbridgeV1Template(assetIn: Asset, assetOut: Asset): AssetRoute;

package/build/configs/ntt.spec.d.ts

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

package/build/configs/polkadot/hydration/templates.d.ts

@@ -8,6 +8,31 @@ export declare function toHubTemplate(asset: Asset, hub: Parachain): AssetRoute;
 export declare function toHubExtTemplate(asset: Asset): AssetRoute;
 export declare function toKusamaHubTemplate(asset: Asset, destFee: number, executionFee: number): AssetRoute;
 export declare function toParaErc20Template(asset: Asset, destination: AnyParachain, transferType?: XcmTransferType): AssetRoute;
+/**
+ * Both signer origins are served, and the route declares a config for each:
+ * an ss58 signer takes the `extrinsic` (evm calls wrapped in `EVM.call`, one
+ * signature, fee quoted by the runtime in the sender's fee currency), an h160
+ * signer takes the `contract` and signs plain evm transactions.
+ */
 export declare function viaNttTemplate(assetIn: Asset, assetOut: Asset, to: AnyChain): AssetRoute;
+/**
+ * Executor-delivered variant, offered alongside the self-redeem route above
+ * for the same pair - the sender pays for delivery instead of signing a
+ * redeem on the destination.
+ *
+ * Cost is charged in weth, hydration's evm native gas - `EVM.call { value }`
+ * debits the weth balance (asset 20), not hdx - whether the transfer is signed
+ * as h160 or wrapped in EVM.call. Ntt still delivers the full amount.
+ *
+ * Must stay an 18 decimal asset: the builder returns a raw evm value, and hdx
+ * would both name the wrong balance and resolve to 12 decimals.
+ *
+ * A sender holding no weth buys it first: the same destination fee swap the
+ * xcm routes use, batched ahead of the calls. Only an ss58 origin needs it -
+ * that one pays its extrinsic fee in hdx and can hold zero weth, and is the
+ * origin whose config is an extrinsic in the first place. An h160 has nothing
+ * to batch into, but pays its own gas in weth, so it already holds some.
+ */
+export declare function viaNttExecutorTemplate(assetIn: Asset, assetOut: Asset, to: AnyChain): AssetRoute;
 export declare function viaSnowbridgeTemplate(assetIn: Asset, assetOut: Asset, to: AnyChain): AssetRoute;
 export declare function viaSnowbridgeV1Template(assetIn: Asset, assetOut: Asset, to: AnyChain): AssetRoute;