@defuse-protocol/intents-sdk 0.14.0

package/dist/index.d.ts

@@ -0,0 +1,488 @@
+import { ILogger, solverRelay, RetryOptions, NearIntentsEnv, BaseError } from '@defuse-protocol/internal-utils';
+export { AssertionError, AssertionErrorType, BaseError, BaseErrorType, HttpRequestError, HttpRequestErrorType, ILogger, IntentSettlementError, IntentSettlementErrorType, NearIntentsEnv, PoaWithdrawalInvariantError, PoaWithdrawalInvariantErrorType, PoaWithdrawalNotFoundError, PoaWithdrawalNotFoundErrorType, PoaWithdrawalPendingError, PoaWithdrawalPendingErrorType, QuoteError, QuoteErrorType, RelayPublishError, RelayPublishErrorType, RetryOptions, RpcRequestError, RpcRequestErrorType, TimeoutError, TimeoutErrorType } from '@defuse-protocol/internal-utils';
+import { Intent, MultiPayload } from '@defuse-protocol/contract-types';
+export { MultiPayload } from '@defuse-protocol/contract-types';
+import * as near_api_js from 'near-api-js';
+import { BorshSchema } from 'borsher';
+import { Account } from 'viem';
+
+type HotBridgeChain = (typeof HotBridgeChains)[number];
+type HotBridgeEVMChain = Extract<HotBridgeChain, `eip155:${string}`>;
+declare const HotBridgeChains: ("eip155:56" | "eip155:137" | "tvm:-239" | "eip155:10" | "eip155:43114" | "stellar:pubnet")[];
+
+declare const BridgeNameEnum: {
+    readonly Hot: "hot";
+    readonly Poa: "poa";
+    readonly None: null;
+};
+type BridgeNameEnum = typeof BridgeNameEnum;
+type BridgeNameEnumValues = (typeof BridgeNameEnum)[keyof typeof BridgeNameEnum];
+
+declare const RouteEnum: {
+    readonly HotBridge: "hot_bridge";
+    readonly PoaBridge: "poa_bridge";
+    readonly NearWithdrawal: "near_withdrawal";
+    readonly VirtualChain: "virtual_chain";
+    readonly InternalTransfer: "internal_transfer";
+};
+type RouteEnum = typeof RouteEnum;
+type RouteEnumValues = (typeof RouteEnum)[keyof typeof RouteEnum];
+
+type IntentPrimitive = Intent;
+interface IntentPayload {
+    verifying_contract: string;
+    deadline: string;
+    nonce: string;
+    intents: IntentPrimitive[];
+    signer_id: string | undefined;
+}
+type IntentPayloadFactory = (intentParams: IntentPayload) => Promise<Partial<IntentPayload>> | Partial<IntentPayload>;
+
+type IntentHash = string;
+interface RelayParamsDefault {
+    multiPayload: MultiPayload;
+    quoteHashes?: string[];
+}
+type IntentRelayParamsFactory<RelayParams = Omit<RelayParamsDefault, "multiPayload">> = () => RelayParams | Promise<RelayParams>;
+
+interface IIntentSigner {
+    signIntent(intent: IntentPayload): Promise<MultiPayload>;
+}
+
+/**
+ * Hook function called before publishing an intent.
+ * Can be used for persistence, logging, analytics, etc.
+ *
+ * @param intentData - The intent data about to be published
+ * @returns A promise that resolves when the hook is complete
+ */
+type OnBeforePublishIntentHook<RelayParams = Omit<RelayParamsDefault, "multiPayload">> = (intentData: {
+    intentHash: IntentHash;
+    intentPayload: IntentPayload;
+    multiPayload: MultiPayload;
+    relayParams: RelayParams;
+}) => Promise<void> | void;
+
+/**
+ * CAIP2 identifiers
+ */
+declare const Chains: {
+    readonly Bitcoin: "bip122:000000000019d6689c085ae165831e93";
+    readonly Ethereum: "eip155:1";
+    readonly Base: "eip155:8453";
+    readonly Arbitrum: "eip155:42161";
+    readonly BNB: "eip155:56";
+    readonly Polygon: "eip155:137";
+    readonly Near: "near:mainnet";
+    readonly Solana: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+    readonly Tron: "tron:27Lqcw";
+    readonly Gnosis: "eip155:100";
+    readonly XRPL: "xrpl:0";
+    readonly Dogecoin: "bip122:1a91e3dace36e2be3bf030a65679fe82";
+    readonly Zcash: "zcash:0";
+    readonly Berachain: "eip155:80085";
+    readonly TON: "tvm:-239";
+    readonly Optimism: "eip155:10";
+    readonly Avalanche: "eip155:43114";
+    readonly Sui: "sui:mainnet";
+    readonly Aptos: "aptos:mainnet";
+    readonly Stellar: "stellar:pubnet";
+    readonly Cardano: "cip34:1-764824073";
+};
+type Chain = (typeof Chains)[keyof typeof Chains];
+
+interface IntentPublishResult {
+    intentHash: IntentHash;
+}
+interface WithdrawalResult {
+    feeEstimation: FeeEstimation;
+    intentHash: IntentHash;
+    intentTx: NearTxInfo;
+    destinationTx: TxInfo | TxNoInfo;
+}
+interface BatchWithdrawalResult {
+    feeEstimation: FeeEstimation[];
+    intentHash: IntentHash;
+    intentTx: NearTxInfo;
+    destinationTx: (TxInfo | TxNoInfo)[];
+}
+type IntentSettlementStatus = solverRelay.GetStatusReturnType;
+interface SignAndSendArgs {
+    intents: IntentPrimitive[];
+    payload?: IntentPayloadFactory;
+    relayParams?: IntentRelayParamsFactory;
+    signer?: IIntentSigner;
+    onBeforePublishIntent?: OnBeforePublishIntentHook;
+    logger?: ILogger;
+}
+type SignAndSendWithdrawalArgs<T extends WithdrawalParams | WithdrawalParams[]> = {
+    withdrawalParams: T;
+    feeEstimation: T extends WithdrawalParams[] ? FeeEstimation[] : FeeEstimation;
+    referral?: string;
+    intent?: Omit<SignAndSendArgs, "logger" | "intents">;
+    logger?: ILogger;
+};
+type ProcessWithdrawalArgs<T extends WithdrawalParams | WithdrawalParams[]> = {
+    withdrawalParams: T;
+    feeEstimation?: T extends WithdrawalParams[] ? FeeEstimation[] : FeeEstimation;
+    intent?: {
+        payload?: IntentPayloadFactory;
+        relayParams?: IntentRelayParamsFactory;
+        signer?: IIntentSigner;
+        onBeforePublishIntent?: OnBeforePublishIntentHook;
+    };
+    referral?: string;
+    logger?: ILogger;
+};
+interface IIntentsSDK {
+    setIntentSigner(signer: IIntentSigner): void;
+    signAndSendIntent(args: SignAndSendArgs): Promise<IntentPublishResult>;
+    waitForIntentSettlement(args: {
+        intentHash: IntentHash;
+        logger?: ILogger;
+    }): Promise<NearTxInfo>;
+    getIntentStatus(args: {
+        intentHash: IntentHash;
+        logger?: ILogger;
+    }): Promise<IntentSettlementStatus>;
+    estimateWithdrawalFee(args: {
+        withdrawalParams: WithdrawalParams;
+        quoteOptions?: {
+            waitMs: number;
+        };
+        logger?: ILogger;
+    }): Promise<FeeEstimation>;
+    estimateWithdrawalFee(args: {
+        withdrawalParams: WithdrawalParams[];
+        quoteOptions?: {
+            waitMs: number;
+        };
+        logger?: ILogger;
+    }): Promise<FeeEstimation[]>;
+    signAndSendWithdrawalIntent(args: SignAndSendWithdrawalArgs<WithdrawalParams> | SignAndSendWithdrawalArgs<WithdrawalParams[]>): Promise<IntentPublishResult>;
+    waitForWithdrawalCompletion(args: {
+        withdrawalParams: WithdrawalParams;
+        intentTx: NearTxInfo;
+        signal?: AbortSignal;
+        retryOptions?: RetryOptions;
+        logger?: ILogger;
+    }): Promise<TxInfo | TxNoInfo>;
+    waitForWithdrawalCompletion(args: {
+        withdrawalParams: WithdrawalParams[];
+        intentTx: NearTxInfo;
+        signal?: AbortSignal;
+        retryOptions?: RetryOptions;
+        logger?: ILogger;
+    }): Promise<Array<TxInfo | TxNoInfo>>;
+    createWithdrawalIntents(args: {
+        withdrawalParams: WithdrawalParams;
+        feeEstimation: FeeEstimation;
+        referral?: string;
+        logger?: ILogger;
+    }): Promise<IntentPrimitive[]>;
+    parseAssetId(assetId: string): ParsedAssetInfo;
+    processWithdrawal(args: ProcessWithdrawalArgs<WithdrawalParams>): Promise<WithdrawalResult>;
+    processWithdrawal(args: ProcessWithdrawalArgs<WithdrawalParams[]>): Promise<BatchWithdrawalResult>;
+}
+interface NearTxInfo {
+    hash: string;
+    accountId: string;
+}
+interface TxInfo {
+    hash: string;
+}
+interface TxNoInfo {
+    hash: null;
+}
+interface WithdrawalParams {
+    assetId: string;
+    amount: bigint;
+    destinationAddress: string;
+    /**
+     * XRP Leger chain specific. MEMO IS NOT SUPPORTED FOR STELLAR AND TON.
+     */
+    destinationMemo?: string | undefined;
+    feeInclusive: boolean;
+    routeConfig?: RouteConfig | undefined;
+}
+type NearWithdrawalRouteConfig = {
+    route: RouteEnum["NearWithdrawal"];
+    msg?: string;
+};
+type InternalTransferRouteConfig = {
+    route: RouteEnum["InternalTransfer"];
+};
+type VirtualChainRouteConfig = {
+    route: RouteEnum["VirtualChain"];
+    auroraEngineContractId: string;
+    proxyTokenContractId: string | null;
+};
+type PoaBridgeRouteConfig = {
+    route: RouteEnum["PoaBridge"];
+    chain: Chain;
+};
+type HotBridgeRouteConfig = {
+    route: RouteEnum["HotBridge"];
+    chain: Chain;
+};
+type RouteConfig = NearWithdrawalRouteConfig | InternalTransferRouteConfig | VirtualChainRouteConfig | PoaBridgeRouteConfig | HotBridgeRouteConfig;
+interface FeeEstimation {
+    amount: bigint;
+    quote: null | solverRelay.Quote;
+}
+interface Bridge {
+    is(routeConfig: RouteConfig): boolean;
+    supports(params: Pick<WithdrawalParams, "assetId" | "routeConfig">): boolean;
+    parseAssetId(assetId: string): ParsedAssetInfo | null;
+    /**
+     * Validates withdrawal constraints for the bridge.
+     * Each bridge implementation may have different withdrawal requirements.
+     * Some bridges (like Aurora Engine, Intents) have no restrictions and will always pass.
+     * Others (like POA) check minimum amounts, and HOT Bridge checks trustlines for Stellar.
+     * @throws {MinWithdrawalAmountError} If the amount is below the minimum required
+     * @throws {TrustlineNotFoundError} If destination address lacks required trustline
+     */
+    validateWithdrawal(args: {
+        assetId: string;
+        amount: bigint;
+        destinationAddress: string;
+        logger?: ILogger;
+    }): Promise<void>;
+    estimateWithdrawalFee<T extends Pick<WithdrawalParams, "assetId" | "destinationAddress" | "routeConfig">>(args: {
+        withdrawalParams: T;
+        quoteOptions?: {
+            waitMs: number;
+        };
+        logger?: ILogger;
+    }): Promise<FeeEstimation>;
+    createWithdrawalIntents(args: {
+        withdrawalParams: WithdrawalParams;
+        feeEstimation: FeeEstimation;
+        referral?: string;
+    }): Promise<IntentPrimitive[]>;
+    waitForWithdrawalCompletion(args: {
+        tx: NearTxInfo;
+        index: number;
+        routeConfig: RouteConfig;
+        signal?: AbortSignal;
+        retryOptions?: RetryOptions;
+        logger?: ILogger;
+    }): Promise<TxInfo | TxNoInfo>;
+}
+interface WithdrawalIdentifier {
+    routeConfig: RouteConfig;
+    index: number;
+    tx: NearTxInfo;
+}
+type ParsedAssetInfo = ({
+    blockchain: Chain;
+    bridgeName: BridgeNameEnumValues;
+    standard: "nep141";
+    contractId: string;
+} | {
+    blockchain: Chain;
+    bridgeName: BridgeNameEnumValues;
+    standard: "nep245";
+    contractId: string;
+    tokenId: string;
+}) & ({
+    native: true;
+} | {
+    address: string;
+});
+type RPCEndpointMap = Record<typeof Chains.Near | HotBridgeEVMChain, string[]> & {
+    [K in typeof Chains.Stellar]: {
+        soroban: string[];
+        horizon: string[];
+    };
+};
+type DeepPartial<T> = T extends object ? T extends Array<infer U> ? Array<DeepPartial<U>> : T extends Function ? T : {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+type PartialRPCEndpointMap = DeepPartial<RPCEndpointMap>;
+
+interface IIntentRelayer<Ticket, RelayParams = RelayParamsDefault> {
+    publishIntent(params: RelayParams, ctx?: {
+        logger?: ILogger;
+    }): Promise<Ticket>;
+    waitForSettlement(ticket: Ticket, ctx?: {
+        logger?: ILogger;
+    }): Promise<{
+        tx: NearTxInfo;
+    }>;
+}
+
+interface IntentsSDKConfig {
+    env?: NearIntentsEnv;
+    intentSigner?: IIntentSigner;
+    rpc?: PartialRPCEndpointMap;
+    referral: string;
+}
+declare class IntentsSDK implements IIntentsSDK {
+    protected env: NearIntentsEnv;
+    protected referral: string;
+    protected intentRelayer: IIntentRelayer<IntentHash>;
+    protected intentSigner?: IIntentSigner;
+    protected bridges: Bridge[];
+    constructor(args: IntentsSDKConfig);
+    setIntentSigner(signer: IIntentSigner): void;
+    createWithdrawalIntents(args: {
+        withdrawalParams: WithdrawalParams;
+        feeEstimation: FeeEstimation;
+        referral?: string;
+        logger?: ILogger;
+    }): Promise<IntentPrimitive[]>;
+    estimateWithdrawalFee(args: {
+        withdrawalParams: WithdrawalParams;
+        quoteOptions?: {
+            waitMs: number;
+        };
+        logger?: ILogger;
+    }): Promise<FeeEstimation>;
+    estimateWithdrawalFee(args: {
+        withdrawalParams: WithdrawalParams[];
+        quoteOptions?: {
+            waitMs: number;
+        };
+        logger?: ILogger;
+    }): Promise<FeeEstimation[]>;
+    protected _estimateWithdrawalFee(args: {
+        withdrawalParams: WithdrawalParams;
+        quoteOptions?: {
+            waitMs: number;
+        };
+        logger?: ILogger;
+    }): Promise<FeeEstimation>;
+    protected getWithdrawalsIdentifiers({ withdrawalParams, intentTx, }: {
+        withdrawalParams: WithdrawalParams[];
+        intentTx: NearTxInfo;
+    }): WithdrawalIdentifier[];
+    waitForWithdrawalCompletion(args: {
+        withdrawalParams: WithdrawalParams;
+        intentTx: NearTxInfo;
+        signal?: AbortSignal;
+        retryOptions?: RetryOptions;
+        logger?: ILogger;
+    }): Promise<TxInfo | TxNoInfo>;
+    waitForWithdrawalCompletion(args: {
+        withdrawalParams: WithdrawalParams[];
+        intentTx: NearTxInfo;
+        signal?: AbortSignal;
+        retryOptions?: RetryOptions;
+        logger?: ILogger;
+    }): Promise<Array<TxInfo | TxNoInfo>>;
+    parseAssetId(assetId: string): ParsedAssetInfo;
+    signAndSendIntent(args: SignAndSendArgs): Promise<IntentPublishResult>;
+    signAndSendWithdrawalIntent(args: SignAndSendWithdrawalArgs<WithdrawalParams> | SignAndSendWithdrawalArgs<WithdrawalParams[]>): Promise<IntentPublishResult>;
+    waitForIntentSettlement(args: {
+        intentHash: IntentHash;
+        logger?: ILogger;
+    }): Promise<NearTxInfo>;
+    getIntentStatus({ intentHash, logger, }: {
+        intentHash: IntentHash;
+        logger?: ILogger;
+    }): Promise<IntentSettlementStatus>;
+    processWithdrawal(args: ProcessWithdrawalArgs<WithdrawalParams>): Promise<WithdrawalResult>;
+    processWithdrawal(args: ProcessWithdrawalArgs<WithdrawalParams[]>): Promise<BatchWithdrawalResult>;
+}
+
+declare const nep413PayloadSchema: BorshSchema<{
+    message: string;
+    nonce: number[];
+    recipient: string;
+    callback_url: string | null;
+}>;
+type NEP413Payload = typeof nep413PayloadSchema extends BorshSchema<infer T> ? Omit<T, "callback_url"> & {
+    callback_url?: string | null | undefined;
+} : never;
+
+type MaybePromise<T> = T | Promise<T>;
+type SignMessageNEP413 = (nep413Payload: NEP413Payload, nep413Hash: Uint8Array) => MaybePromise<{
+    publicKey: string;
+    signature: string;
+}>;
+interface IntentSignerNEP413Config {
+    signMessage: SignMessageNEP413;
+    accountId: string;
+}
+
+interface IntentSignerNearKeypairConfig {
+    keypair: near_api_js.KeyPair;
+    accountId: string;
+}
+
+type IntentSignerViemConfig = Pick<Account, "address" | "signMessage">;
+
+declare function createIntentSignerNEP413(config: IntentSignerNEP413Config): IIntentSigner;
+declare function createIntentSignerNearKeyPair(config: IntentSignerNearKeypairConfig): IIntentSigner;
+declare function createIntentSignerViem(config: IntentSignerViemConfig): IIntentSigner;
+
+declare function createInternalTransferRoute(): InternalTransferRouteConfig;
+declare function createNearWithdrawalRoute(msg?: string): NearWithdrawalRouteConfig;
+declare function createVirtualChainRoute(auroraEngineContractId: string, proxyTokenContractId: string | null): VirtualChainRouteConfig;
+declare function createPoaBridgeRoute(chain: Chain): PoaBridgeRouteConfig;
+declare function createHotBridgeRoute(chain: Chain): HotBridgeRouteConfig;
+declare function createDefaultRoute(): undefined;
+
+type FeeExceedsAmountErrorType = FeeExceedsAmountError & {
+    name: "FeeExceedsAmountError";
+};
+declare class FeeExceedsAmountError extends BaseError {
+    feeEstimation: FeeEstimation;
+    amount: bigint;
+    constructor(feeEstimation: FeeEstimation, amount: bigint);
+}
+type MinWithdrawalAmountErrorType = MinWithdrawalAmountError & {
+    name: "MinWithdrawalAmountError";
+};
+declare class MinWithdrawalAmountError extends BaseError {
+    minAmount: bigint;
+    requestedAmount: bigint;
+    assetId: string;
+    constructor(minAmount: bigint, requestedAmount: bigint, assetId: string);
+}
+type UnsupportedDestinationMemoErrorType = UnsupportedDestinationMemoError & {
+    name: "UnsupportedDestinationMemoError";
+};
+declare class UnsupportedDestinationMemoError extends BaseError {
+    blockchain: string;
+    assetId: string;
+    constructor(blockchain: string, assetId: string);
+}
+type TrustlineNotFoundErrorType = TrustlineNotFoundError & {
+    name: "TrustlineNotFoundError";
+};
+declare class TrustlineNotFoundError extends BaseError {
+    destinationAddress: string;
+    assetId: string;
+    blockchain: string;
+    tokenAddress: string;
+    constructor(destinationAddress: string, assetId: string, blockchain: string, tokenAddress: string);
+}
+
+type HotWithdrawalPendingErrorType = HotWithdrawalPendingError & {
+    name: "HotWithdrawalPendingError";
+};
+declare class HotWithdrawalPendingError extends BaseError {
+    txHash: string;
+    index: number;
+    constructor(txHash: string, index: number);
+}
+type HotWithdrawalNotFoundErrorType = HotWithdrawalNotFoundError & {
+    name: "HotWithdrawalNotFoundError";
+};
+declare class HotWithdrawalNotFoundError extends BaseError {
+    txHash: string;
+    index: number;
+    constructor(txHash: string, index: number);
+}
+type HotWithdrawalCancelledErrorType = HotWithdrawalCancelledError & {
+    name: "HotWithdrawalCancelledError";
+};
+declare class HotWithdrawalCancelledError extends BaseError {
+    txHash: string;
+    index: number;
+    constructor(txHash: string, index: number);
+}
+
+export { type BatchWithdrawalResult, BridgeNameEnum, type BridgeNameEnumValues, type Chain, Chains, type FeeEstimation, FeeExceedsAmountError, type FeeExceedsAmountErrorType, type HotBridgeRouteConfig, HotWithdrawalCancelledError, type HotWithdrawalCancelledErrorType, HotWithdrawalNotFoundError, type HotWithdrawalNotFoundErrorType, HotWithdrawalPendingError, type HotWithdrawalPendingErrorType, type IIntentSigner, type IntentPayload, type IntentPayloadFactory, type IntentPrimitive, type IntentPublishResult, type IntentRelayParamsFactory, type IntentSettlementStatus, IntentsSDK, type IntentsSDKConfig, type InternalTransferRouteConfig, MinWithdrawalAmountError, type MinWithdrawalAmountErrorType, type NearTxInfo, type NearWithdrawalRouteConfig, type OnBeforePublishIntentHook, type ParsedAssetInfo, type PoaBridgeRouteConfig, type ProcessWithdrawalArgs, type RouteConfig, RouteEnum, type RouteEnumValues, type SignAndSendWithdrawalArgs, TrustlineNotFoundError, type TrustlineNotFoundErrorType, type TxInfo, type TxNoInfo, UnsupportedDestinationMemoError, type UnsupportedDestinationMemoErrorType, type VirtualChainRouteConfig, type WithdrawalIdentifier, type WithdrawalParams, type WithdrawalResult, createDefaultRoute, createHotBridgeRoute, createIntentSignerNEP413, createIntentSignerNearKeyPair, createIntentSignerViem, createInternalTransferRoute, createNearWithdrawalRoute, createPoaBridgeRoute, createVirtualChainRoute };