@vleap/warps 3.0.0-alpha.13 → 3.0.0-alpha.130

package/dist/index.d.ts

@@ -1,75 +1,322 @@
-import { Transaction, TransactionOnNetwork, Address, TokenTransfer as TokenTransfer$1, AbiRegistry, NetworkEntrypoint } from '@multiversx/sdk-core';
-import { TypedValue, Type, OptionValue, OptionalValue, List, VariadicValue, CompositeValue, StringValue, U8Value, U16Value, U32Value, U64Value, BigUIntValue, BooleanValue, AddressValue, TokenIdentifierValue, BytesValue, TokenTransfer, Struct, CodeMetadataValue, NothingValue, Transaction as Transaction$1, Address as Address$1 } from '@multiversx/sdk-core/out';
 import QRCodeStyling from 'qr-code-styling';
 
-declare const CacheTtl: {
-    OneMinute: number;
-    OneHour: number;
-    OneDay: number;
-    OneWeek: number;
-    OneMonth: number;
-    OneYear: number;
+type WarpLanguage = 'en' | 'es' | 'fr' | 'de' | 'it' | 'pt' | 'ru' | 'zh' | 'ja' | 'ko' | 'ar' | 'hi' | 'nl' | 'sv' | 'da' | 'no' | 'fi' | 'pl' | 'tr' | 'el' | 'he' | 'th' | 'vi' | 'id' | 'ms' | 'tl' | string;
+type WarpText = string | WarpI18nText;
+type WarpI18nText = {
+    [language: string]: string;
 };
-declare const CacheKey: {
-    Warp: (env: WarpChainEnv, id: string) => string;
-    WarpAbi: (env: WarpChainEnv, id: string) => string;
-    LastWarpExecutionInputs: (env: WarpChainEnv, id: string, action: number) => string;
-    RegistryInfo: (env: WarpChainEnv, id: string) => string;
-    Brand: (env: WarpChainEnv, hash: string) => string;
-    ChainInfo: (env: WarpChainEnv, chain: WarpChain) => string;
-    ChainInfos: (env: WarpChainEnv) => string;
+
+type WarpAlertName = string;
+type WarpAlert = {
+    trigger: string;
+    subject: WarpText;
+    body: WarpText;
+    action?: string;
 };
-type CacheType = 'memory' | 'localStorage';
-declare class WarpCache {
-    private strategy;
-    constructor(type?: CacheType);
-    private selectStrategy;
-    set<T>(key: string, value: T, ttl: number): void;
-    get<T>(key: string): T | null;
-    forget(key: string): void;
-    clear(): void;
-}
+type WarpAlerts = Record<WarpAlertName, WarpAlert>;
+
+type WarpBrand = {
+    protocol: string;
+    name: WarpText;
+    description: WarpText;
+    logo: string;
+    urls?: WarpBrandUrls;
+    colors?: WarpBrandColors;
+    cta?: WarpBrandCta;
+    meta?: WarpMeta;
+};
+type WarpBrandUrls = {
+    web?: string;
+};
+type WarpBrandColors = {
+    primary?: string;
+    secondary?: string;
+};
+type WarpBrandCta = {
+    title: WarpText;
+    description: WarpText;
+    label: WarpText;
+    url: string;
+};
+
+type ClientCacheConfig = {
+    ttl?: number;
+    type?: WarpCacheType;
+};
+type WarpCacheType = 'memory' | 'localStorage';
 
 type WarpChainEnv = 'mainnet' | 'testnet' | 'devnet';
 type ProtocolName = 'warp' | 'brand' | 'abi';
 
-type WarpChain = string;
-type WarpInitConfig = {
+type WarpTrustStatus = 'unverified' | 'verified' | 'blacklisted';
+type WarpRegistryInfo = {
+    hash: string;
+    alias: string | null;
+    trust: WarpTrustStatus;
+    owner: string;
+    createdAt: number;
+    upgradedAt: number;
+    brand: string | null;
+    upgrade: string | null;
+};
+type WarpRegistryConfigInfo = {
+    unitPrice: bigint;
+    admins: string[];
+};
+
+type WarpActionExecution = {
+    success: boolean;
+    warp: Warp;
+    action: number;
+    user: string | null;
+    txHash: string | null;
+    tx: WarpAdapterGenericTransaction | null;
+    next: WarpExecutionNextInfo | null;
+    values: {
+        string: string[];
+        native: WarpNativeValue[];
+    };
+    results: WarpExecutionResults;
+    messages: WarpExecutionMessages;
+};
+type WarpExecutionNextInfo = {
+    identifier: string | null;
+    url: string;
+}[];
+type WarpExecutionResults = Record<WarpResultName, any | null>;
+type WarpExecutionMessages = Record<WarpMessageName, string | null>;
+
+type ClientIndexConfig = {
+    url?: string;
+    apiKey?: string;
+    searchParamName?: string;
+};
+type WarpSearchResult = {
+    hits: WarpSearchHit[];
+};
+type WarpSearchHit = {
+    hash: string;
+    alias: string;
+    name: string;
+    title: string;
+    description: string;
+    preview: string;
+    status: string;
+    category: string;
+    featured: boolean;
+};
+
+interface TransformRunner {
+    run(code: string, context: any): Promise<any>;
+}
+type ClientTransformConfig = {
+    runner?: TransformRunner | null;
+};
+
+type WarpWalletDetails = {
+    address: string;
+    mnemonic?: string | null;
+    privateKey?: string | null;
+};
+type WarpUserWallets = Record<WarpChain, WarpWalletDetails | string | null>;
+type WarpProviderConfig = Record<WarpChainEnv, string>;
+type WarpClientConfig = {
     env: WarpChainEnv;
     clientUrl?: string;
     currentUrl?: string;
     vars?: Record<string, string | number>;
     user?: {
-        wallet?: string;
+        wallets?: WarpUserWallets;
+    };
+    preferences?: {
+        language?: WarpLanguage;
+        explorers?: Record<WarpChain, WarpExplorerName>;
     };
+    providers?: Record<WarpChain, WarpProviderConfig>;
     schema?: {
         warp?: string;
         brand?: string;
     };
-    cache?: {
-        ttl?: number;
-        type?: CacheType;
-    };
-    registry?: {
-        contract?: string;
-    };
-    index?: {
-        url?: string;
-        apiKey?: string;
-        searchParamName?: string;
+    cache?: ClientCacheConfig;
+    transform?: ClientTransformConfig;
+    index?: ClientIndexConfig;
+    interceptors?: {
+        openLink?: (url: string) => Promise<void>;
     };
 };
 type WarpCacheConfig = {
     ttl?: number;
 };
+type AdapterFactory = (config: WarpClientConfig, fallback?: Adapter) => Adapter;
+type Adapter = {
+    chainInfo: WarpChainInfo;
+    prefix: string;
+    builder: () => CombinedWarpBuilder;
+    executor: AdapterWarpExecutor;
+    results: AdapterWarpResults;
+    serializer: AdapterWarpSerializer;
+    registry: AdapterWarpRegistry;
+    explorer: AdapterWarpExplorer;
+    abiBuilder: () => AdapterWarpAbiBuilder;
+    brandBuilder: () => AdapterWarpBrandBuilder;
+    dataLoader: AdapterWarpDataLoader;
+    wallet: AdapterWarpWallet;
+};
+type WarpAdapterGenericTransaction = any;
+type WarpAdapterGenericRemoteTransaction = any;
+type WarpAdapterGenericValue = any;
+type WarpAdapterGenericType = any;
+interface WarpTypeHandler {
+    stringToNative(value: string): any;
+    nativeToString(value: any): string;
+}
+interface AdapterTypeRegistry {
+    registerType(typeName: string, handler: WarpTypeHandler): void;
+    registerTypeAlias(typeName: string, alias: string): void;
+    hasType(typeName: string): boolean;
+    getHandler(typeName: string): WarpTypeHandler | undefined;
+    getAlias(typeName: string): string | undefined;
+    resolveType(typeName: string): string;
+    getRegisteredTypes(): string[];
+}
+interface BaseWarpBuilder {
+    createFromRaw(encoded: string, validate?: boolean): Promise<Warp>;
+    createFromUrl(url: string): Promise<Warp>;
+    setName(name: string): BaseWarpBuilder;
+    setTitle(title: string): BaseWarpBuilder;
+    setDescription(description: string): BaseWarpBuilder;
+    setPreview(preview: string): BaseWarpBuilder;
+    setActions(actions: WarpAction[]): BaseWarpBuilder;
+    addAction(action: WarpAction): BaseWarpBuilder;
+    build(): Promise<Warp>;
+}
+interface AdapterWarpBuilder {
+    createInscriptionTransaction(warp: Warp): Promise<WarpAdapterGenericTransaction>;
+    createFromTransaction(tx: WarpAdapterGenericTransaction, validate?: boolean): Promise<Warp>;
+    createFromTransactionHash(hash: string, cache?: WarpCacheConfig): Promise<Warp | null>;
+}
+type CombinedWarpBuilder = AdapterWarpBuilder & BaseWarpBuilder;
+interface AdapterWarpAbiBuilder {
+    createInscriptionTransaction(abi: WarpAbiContents): Promise<WarpAdapterGenericTransaction>;
+    createFromRaw(encoded: string): Promise<any>;
+    createFromTransaction(tx: WarpAdapterGenericTransaction): Promise<any>;
+    createFromTransactionHash(hash: string, cache?: WarpCacheConfig): Promise<any | null>;
+}
+interface AdapterWarpBrandBuilder {
+    createInscriptionTransaction(brand: WarpBrand): WarpAdapterGenericTransaction;
+    createFromTransaction(tx: WarpAdapterGenericTransaction, validate?: boolean): Promise<WarpBrand>;
+    createFromTransactionHash(hash: string, cache?: WarpCacheConfig): Promise<WarpBrand | null>;
+}
+interface AdapterWarpExecutor {
+    createTransaction(executable: WarpExecutable): Promise<WarpAdapterGenericTransaction>;
+    executeQuery(executable: WarpExecutable): Promise<WarpActionExecution>;
+}
+interface AdapterWarpResults {
+    getActionExecution(warp: Warp, actionIndex: WarpActionIndex, tx: WarpAdapterGenericRemoteTransaction): Promise<WarpActionExecution>;
+}
+interface AdapterWarpSerializer {
+    typedToString(value: WarpAdapterGenericValue): string;
+    typedToNative(value: WarpAdapterGenericValue): [WarpActionInputType, WarpNativeValue];
+    nativeToTyped(type: WarpActionInputType, value: WarpNativeValue): WarpAdapterGenericValue;
+    nativeToType(type: BaseWarpActionInputType): WarpAdapterGenericType;
+    stringToTyped(value: string): WarpAdapterGenericValue;
+}
+interface AdapterWarpRegistry {
+    init(): Promise<void>;
+    getRegistryConfig(): WarpRegistryConfigInfo;
+    createWarpRegisterTransaction(txHash: string, alias?: string | null, brand?: string | null): Promise<WarpAdapterGenericTransaction>;
+    createWarpUnregisterTransaction(txHash: string): Promise<WarpAdapterGenericTransaction>;
+    createWarpUpgradeTransaction(alias: string, txHash: string, brand?: string | null): Promise<WarpAdapterGenericTransaction>;
+    createWarpAliasSetTransaction(txHash: string, alias: string): Promise<WarpAdapterGenericTransaction>;
+    createWarpVerifyTransaction(txHash: string): Promise<WarpAdapterGenericTransaction>;
+    createWarpTransferOwnershipTransaction(txHash: string, newOwner: string): Promise<WarpAdapterGenericTransaction>;
+    createBrandRegisterTransaction(txHash: string): Promise<WarpAdapterGenericTransaction>;
+    createWarpBrandingTransaction(warpHash: string, brandHash: string): Promise<WarpAdapterGenericTransaction>;
+    getInfoByAlias(alias: string, cache?: WarpCacheConfig): Promise<{
+        registryInfo: WarpRegistryInfo | null;
+        brand: WarpBrand | null;
+    }>;
+    getInfoByHash(hash: string, cache?: WarpCacheConfig): Promise<{
+        registryInfo: WarpRegistryInfo | null;
+        brand: WarpBrand | null;
+    }>;
+    getUserWarpRegistryInfos(user?: string): Promise<WarpRegistryInfo[]>;
+    getUserBrands(user?: string): Promise<WarpBrand[]>;
+    fetchBrand(hash: string, cache?: WarpCacheConfig): Promise<WarpBrand | null>;
+}
+interface AdapterWarpExplorer {
+    getAccountUrl(address: string): string;
+    getTransactionUrl(hash: string): string;
+    getAssetUrl(identifier: string): string;
+    getContractUrl(address: string): string;
+}
+interface WarpDataLoaderOptions {
+    page?: number;
+    size?: number;
+}
+interface AdapterWarpDataLoader {
+    getAccount(address: string): Promise<WarpChainAccount>;
+    getAccountAssets(address: string): Promise<WarpChainAsset[]>;
+    getAsset(identifier: string): Promise<WarpChainAsset | null>;
+    getAction(identifier: string, awaitCompleted?: boolean): Promise<WarpChainAction | null>;
+    getAccountActions(address: string, options?: WarpDataLoaderOptions): Promise<WarpChainAction[]>;
+}
+interface AdapterWarpWallet {
+    signTransaction(tx: WarpAdapterGenericTransaction): Promise<WarpAdapterGenericTransaction>;
+    signTransactions(txs: WarpAdapterGenericTransaction[]): Promise<WarpAdapterGenericTransaction[]>;
+    signMessage(message: string): Promise<string>;
+    sendTransactions(txs: WarpAdapterGenericTransaction[]): Promise<string[]>;
+    sendTransaction(tx: WarpAdapterGenericTransaction): Promise<string>;
+    create(mnemonic: string): WarpWalletDetails;
+    generate(): WarpWalletDetails;
+    getAddress(): string | null;
+}
+
+type WarpChainAccount = {
+    chain: WarpChain;
+    address: string;
+    balance: bigint;
+};
+type WarpChainAssetValue = {
+    identifier: string;
+    amount: bigint;
+};
+type WarpChainAsset = {
+    chain: WarpChain;
+    identifier: string;
+    name: string;
+    symbol: string;
+    amount?: bigint;
+    decimals?: number;
+    logoUrl?: string | null;
+    price?: number;
+    supply?: bigint;
+};
+type WarpChainAction = {
+    chain: WarpChain;
+    id: string;
+    sender: string;
+    receiver: string;
+    value: bigint;
+    function: string;
+    status: WarpChainActionStatus;
+    createdAt: string;
+    error?: string | null;
+    tx?: WarpAdapterGenericRemoteTransaction | null;
+};
+type WarpChainActionStatus = 'pending' | 'success' | 'failed';
+
+type WarpChain = string;
+type WarpExplorerName = string;
 type WarpChainInfo = {
-    name: WarpChain;
+    name: string;
     displayName: string;
     chainId: string;
     blockTime: number;
     addressHrp: string;
-    apiUrl: string;
-    explorerUrl: string;
+    defaultApiUrl: string;
+    logoUrl: string;
+    nativeToken: WarpChainAsset;
 };
 type WarpIdType = 'hash' | 'alias';
 type WarpVarPlaceholder = string;
@@ -78,9 +325,10 @@ type WarpResulutionPath = string;
 type WarpMessageName = string;
 type Warp = {
     protocol: string;
+    chain?: WarpChain;
     name: string;
-    title: string;
-    description: string | null;
+    title: WarpText;
+    description: WarpText | null;
     bot?: string;
     preview?: string;
     vars?: Record<WarpVarPlaceholder, string>;
@@ -88,89 +336,97 @@ type Warp = {
     next?: string;
     results?: Record<WarpResultName, WarpResulutionPath>;
     messages?: Record<WarpMessageName, string>;
+    alerts?: WarpAlerts;
     meta?: WarpMeta;
 };
 type WarpMeta = {
+    chain: WarpChain;
     hash: string;
     creator: string;
     createdAt: string;
 };
 type WarpAction = WarpTransferAction | WarpContractAction | WarpQueryAction | WarpCollectAction | WarpLinkAction;
+type WarpActionIndex = number;
 type WarpActionType = 'transfer' | 'contract' | 'query' | 'collect' | 'link';
 type WarpTransferAction = {
     type: WarpActionType;
-    chain?: WarpChain;
-    label: string;
-    description?: string | null;
+    label: WarpText;
+    description?: WarpText | null;
     address?: string;
     data?: string;
     value?: string;
-    transfers?: WarpContractActionTransfer[];
+    transfers?: string[];
     inputs?: WarpActionInput[];
+    primary?: boolean;
+    auto?: boolean;
     next?: string;
 };
 type WarpContractAction = {
     type: WarpActionType;
-    chain?: WarpChain;
-    label: string;
-    description?: string | null;
-    address: string;
-    func: string | null;
-    args: string[];
+    label: WarpText;
+    description?: WarpText | null;
+    address?: string;
+    func?: string | null;
+    args?: string[];
     value?: string;
     gasLimit: number;
-    transfers?: WarpContractActionTransfer[];
+    transfers?: string[];
     abi?: string;
     inputs?: WarpActionInput[];
+    primary?: boolean;
+    auto?: boolean;
     next?: string;
 };
-type WarpContractActionTransfer = {
-    token: string;
-    nonce?: number;
-    amount?: string;
-};
 type WarpQueryAction = {
     type: WarpActionType;
-    chain?: WarpChain;
-    label: string;
-    description?: string | null;
-    address: string;
-    func: string;
-    args: string[];
+    label: WarpText;
+    description?: WarpText | null;
+    address?: string;
+    func?: string;
+    args?: string[];
     abi?: string;
     inputs?: WarpActionInput[];
+    primary?: boolean;
+    auto?: boolean;
     next?: string;
 };
 type WarpCollectAction = {
     type: WarpActionType;
-    chain?: WarpChain;
-    label: string;
-    description?: string | null;
+    label: WarpText;
+    description?: WarpText | null;
     destination: {
         url: string;
         method?: 'GET' | 'POST' | 'PUT' | 'DELETE';
         headers?: Record<string, string>;
     };
     inputs?: WarpActionInput[];
+    primary?: boolean;
+    auto?: boolean;
     next?: string;
 };
 type WarpLinkAction = {
     type: WarpActionType;
-    chain?: WarpChain;
-    label: string;
-    description?: string | null;
+    label: WarpText;
+    description?: WarpText | null;
     url: string;
     inputs?: WarpActionInput[];
+    primary?: boolean;
+    auto?: boolean;
 };
-type WarpActionInputSource = 'field' | 'query' | 'user:wallet';
-type BaseWarpActionInputType = 'string' | 'uint8' | 'uint16' | 'uint32' | 'uint64' | 'biguint' | 'bool' | 'address' | 'token' | 'codemeta' | 'hex' | 'esdt' | 'nft';
+type WarpActionInputSource = 'field' | 'query' | 'user:wallet' | 'hidden';
+type BaseWarpActionInputType = 'string' | 'uint8' | 'uint16' | 'uint32' | 'uint64' | 'uint128' | 'uint256' | 'biguint' | 'bool' | 'address' | 'hex' | string;
 type WarpActionInputType = string;
-type WarpActionInputPosition = 'receiver' | 'value' | 'transfer' | `arg:${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10}` | 'data';
+interface WarpStructValue {
+    [key: string]: WarpNativeValue;
+}
+type WarpNativeValue = string | number | bigint | boolean | WarpChainAssetValue | null | WarpNativeValue[] | WarpStructValue;
+type WarpActionInputPosition = 'receiver' | 'value' | 'transfer' | `arg:${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10}` | 'data' | 'chain' | `payload:${string}`;
 type WarpActionInputModifier = 'scale';
 type WarpActionInput = {
     name: string;
     as?: string;
-    description?: string | null;
+    label?: WarpText;
+    description?: WarpText | null;
     bot?: string;
     type: WarpActionInputType;
     position?: WarpActionInputPosition;
@@ -179,11 +435,12 @@ type WarpActionInput = {
     min?: number | WarpVarPlaceholder;
     max?: number | WarpVarPlaceholder;
     pattern?: string;
-    patternDescription?: string;
+    patternDescription?: WarpText;
     options?: string[] | {
         [key: string]: string;
     };
     modifier?: string;
+    default?: string | number | boolean;
 };
 type ResolvedInput = {
     input: WarpActionInput;
@@ -198,8 +455,19 @@ type WarpContractVerification = {
     codeHash: string;
     abi: object;
 };
+type WarpExecutable = {
+    chain: WarpChainInfo;
+    warp: Warp;
+    action: number;
+    destination: string;
+    args: string[];
+    value: bigint;
+    transfers: WarpChainAssetValue[];
+    data: string | null;
+    resolvedInputs: ResolvedInput[];
+};
 
-type WarpWarpAbi = {
+type WarpAbi = {
     protocol: string;
     content: WarpAbiContents;
     meta?: WarpMeta;
@@ -213,103 +481,16 @@ type WarpAbiContents = {
     events?: any[];
 };
 
-type Brand = {
-    protocol: string;
-    name: string;
-    description: string;
-    logo: string;
-    urls?: BrandUrls;
-    colors?: BrandColors;
-    cta?: BrandCta;
-    meta?: BrandMeta;
-};
-type BrandUrls = {
-    web?: string;
-};
-type BrandColors = {
-    primary?: string;
-    secondary?: string;
-};
-type BrandCta = {
-    title: string;
-    description: string;
-    label: string;
-    url: string;
-};
-type BrandMeta = {
-    hash: string;
-    creator: string;
-    createdAt: string;
-};
-
-type WarpTrustStatus = 'unverified' | 'verified' | 'blacklisted';
-type WarpRegistryInfo = {
-    hash: string;
-    alias: string | null;
-    trust: WarpTrustStatus;
-    owner: string;
-    createdAt: number;
-    upgradedAt: number;
-    brand: string | null;
-    upgrade: string | null;
-};
-type WarpRegistryConfigInfo = {
-    unitPrice: bigint;
-    admins: string[];
-};
-
-type WarpExecution = {
-    success: boolean;
-    warp: Warp;
-    action: number;
-    user: string | null;
-    txHash: string | null;
-    next: WarpExecutionNextInfo | null;
-    values: any[];
-    results: WarpExecutionResults;
-    messages: WarpExecutionMessages;
+type WarpSecret = {
+    key: string;
+    description?: string | null;
 };
-type WarpExecutionNextInfo = {
-    identifier: string | null;
-    url: string;
-}[];
-type WarpExecutionResults = Record<WarpResultName, any | null>;
-type WarpExecutionMessages = Record<WarpMessageName, string | null>;
 
-type WarpSearchResult = {
-    hits: WarpSearchHit[];
-};
-type WarpSearchHit = {
-    hash: string;
-    alias: string;
-    name: string;
-    title: string;
-    description: string;
-    preview: string;
-    status: string;
-    category: string;
-    featured: boolean;
+type InterpolationBag = {
+    config: WarpClientConfig;
+    chain: WarpChainInfo;
 };
 
-declare class BrandBuilder {
-    private config;
-    private pendingBrand;
-    constructor(config: WarpInitConfig);
-    createInscriptionTransaction(brand: Brand): Transaction;
-    createFromRaw(encoded: string, validateSchema?: boolean): Promise<Brand>;
-    createFromTransaction(tx: TransactionOnNetwork, validateSchema?: boolean): Promise<Brand>;
-    createFromTransactionHash(hash: string): Promise<Brand | null>;
-    setName(name: string): BrandBuilder;
-    setDescription(description: string): BrandBuilder;
-    setLogo(logo: string): BrandBuilder;
-    setUrls(urls: BrandUrls): BrandBuilder;
-    setColors(colors: BrandColors): BrandBuilder;
-    setCta(cta: BrandCta): BrandBuilder;
-    build(): Promise<Brand>;
-    private ensure;
-    private ensureValidSchema;
-}
-
 declare const WarpProtocolVersions: {
     Warp: string;
     Brand: string;
@@ -320,56 +501,41 @@ declare const WarpConfig: {
     LatestBrandSchemaUrl: string;
     DefaultClientUrl: (env: WarpChainEnv) => "https://usewarp.to" | "https://testnet.usewarp.to" | "https://devnet.usewarp.to";
     SuperClientUrls: string[];
-    MainChain: {
-        Name: string;
-        DisplayName: string;
-        ApiUrl: (env: WarpChainEnv) => "https://devnet-api.multiversx.com" | "https://testnet-api.multiversx.com" | "https://api.multiversx.com";
-        ExplorerUrl: (env: WarpChainEnv) => "https://devnet-explorer.multiversx.com" | "https://testnet-explorer.multiversx.com" | "https://explorer.multiversx.com";
-        BlockTime: (env: WarpChainEnv) => number;
-        AddressHrp: string;
-        ChainId: (env: WarpChainEnv) => "D" | "T" | "1";
-    };
-    Registry: {
-        Contract: (env: WarpChainEnv) => "erd1qqqqqqqqqqqqqpgqje2f99vr6r7sk54thg03c9suzcvwr4nfl3tsfkdl36" | "####" | "erd1qqqqqqqqqqqqqpgq3mrpj3u6q7tejv6d7eqhnyd27n9v5c5tl3ts08mffe";
-    };
     AvailableActionInputSources: WarpActionInputSource[];
     AvailableActionInputTypes: WarpActionInputType[];
     AvailableActionInputPositions: WarpActionInputPosition[];
 };
 
-type InterpolationBag = {
-    config: WarpInitConfig;
-    chain: WarpChainInfo;
-};
-declare class WarpInterpolator {
-    static apply(config: WarpInitConfig, warp: Warp): Promise<Warp>;
-    static applyGlobals(config: WarpInitConfig, warp: Warp): Promise<Warp>;
-    static applyVars(config: WarpInitConfig, warp: Warp): Warp;
-    private static applyRootGlobals;
-    private static applyActionGlobals;
+declare enum WarpChainName {
+    Multiversx = "multiversx",
+    Vibechain = "vibechain",
+    Sui = "sui",
+    Ethereum = "ethereum",
+    Base = "base",
+    Arbitrum = "arbitrum",
+    Somnia = "somnia",
+    Fastset = "fastset"
 }
-
 declare const WarpConstants: {
     HttpProtocolPrefix: string;
     IdentifierParamName: string;
     IdentifierParamSeparator: string;
+    IdentifierChainDefault: string;
     IdentifierType: {
         Alias: WarpIdType;
         Hash: WarpIdType;
     };
-    Source: {
-        UserWallet: string;
-    };
+    IdentifierAliasPrefix: string;
     Globals: {
         UserWallet: {
             Placeholder: string;
-            Accessor: (bag: InterpolationBag) => string | undefined;
+            Accessor: (bag: InterpolationBag) => string | WarpWalletDetails | null | undefined;
         };
         ChainApiUrl: {
             Placeholder: string;
             Accessor: (bag: InterpolationBag) => string;
         };
-        ChainExplorerUrl: {
+        ChainAddressHrp: {
             Placeholder: string;
             Accessor: (bag: InterpolationBag) => string;
         };
@@ -380,137 +546,377 @@ declare const WarpConstants: {
     };
     ArgParamsSeparator: string;
     ArgCompositeSeparator: string;
+    ArgListSeparator: string;
+    ArgStructSeparator: string;
     Transform: {
         Prefix: string;
     };
-    Egld: {
-        Identifier: string;
-        EsdtIdentifier: string;
-        DisplayName: string;
-        Decimals: number;
+    Source: {
+        UserWallet: string;
     };
+    Position: {
+        Payload: string;
+    };
+};
+declare const WarpInputTypes: {
+    Option: string;
+    Vector: string;
+    Tuple: string;
+    Struct: string;
+    String: string;
+    Uint8: string;
+    Uint16: string;
+    Uint32: string;
+    Uint64: string;
+    Uint128: string;
+    Uint256: string;
+    Biguint: string;
+    Bool: string;
+    Address: string;
+    Asset: string;
+    Hex: string;
 };
+declare const safeWindow: Window;
 
-declare const getMainChainInfo: (config: WarpInitConfig) => WarpChainInfo;
-declare const getChainExplorerUrl: (chain: WarpChainInfo, path?: string) => string;
+interface CryptoProvider {
+    getRandomBytes(size: number): Promise<Uint8Array>;
+}
+declare class BrowserCryptoProvider implements CryptoProvider {
+    getRandomBytes(size: number): Promise<Uint8Array>;
+}
+declare class NodeCryptoProvider implements CryptoProvider {
+    getRandomBytes(size: number): Promise<Uint8Array>;
+}
+declare function getCryptoProvider(): CryptoProvider;
+declare function setCryptoProvider(provider: CryptoProvider): void;
+declare function getRandomBytes(size: number, cryptoProvider?: CryptoProvider): Promise<Uint8Array>;
+declare function bytesToHex(bytes: Uint8Array): string;
+declare function bytesToBase64(bytes: Uint8Array): string;
+declare function getRandomHex(length: number, cryptoProvider?: CryptoProvider): Promise<string>;
+declare function testCryptoAvailability(): Promise<{
+    randomBytes: boolean;
+    environment: 'browser' | 'nodejs' | 'unknown';
+}>;
+declare function createCryptoProvider(): CryptoProvider;
+
+declare const extractWarpSecrets: (warp: Warp) => WarpSecret[];
+
+declare const findWarpAdapterForChain: (chain: WarpChain, adapters: Adapter[]) => Adapter;
+declare const findWarpAdapterByPrefix: (prefix: string, adapters: Adapter[]) => Adapter;
 declare const getLatestProtocolIdentifier: (name: ProtocolName) => string;
 declare const getWarpActionByIndex: (warp: Warp, index: number) => WarpAction;
-declare const toTypedChainInfo: (chainInfo: any) => WarpChainInfo;
-declare const shiftBigintBy: (value: bigint | string, decimals: number) => bigint;
+declare const getWarpPrimaryAction: (warp: Warp) => {
+    action: WarpAction;
+    index: number;
+};
+declare const isWarpActionAutoExecute: (action: WarpAction, warp: Warp) => boolean;
+declare const shiftBigintBy: (value: bigint | string | number, decimals: number) => bigint;
 declare const toPreviewText: (text: string, maxChars?: number) => string;
 declare const replacePlaceholders: (message: string, bag: Record<string, any>) => string;
+declare const applyResultsToMessages: (warp: Warp, results: Record<string, any>) => Record<string, string>;
 
-declare const option: (value: TypedValue | null, type?: Type) => OptionValue;
-declare const optional: (value: TypedValue | null, type?: Type) => OptionalValue;
-declare const list: (values: TypedValue[]) => List;
-declare const variadic: (values: TypedValue[]) => VariadicValue;
-declare const composite: (values: TypedValue[]) => CompositeValue;
-declare const string: (value: string) => StringValue;
-declare const u8: (value: number) => U8Value;
-declare const u16: (value: number) => U16Value;
-declare const u32: (value: number) => U32Value;
-declare const u64: (value: bigint) => U64Value;
-declare const biguint: (value: bigint | string | number) => BigUIntValue;
-declare const boolean: (value: boolean) => BooleanValue;
-declare const address: (value: string) => AddressValue;
-declare const token: (value: string) => TokenIdentifierValue;
-declare const hex: (value: string) => BytesValue;
-declare const esdt: (value: TokenTransfer) => Struct;
-declare const codemeta: (hexString: string) => CodeMetadataValue;
-declare const nothing: () => NothingValue;
-
-declare class WarpAbiBuilder {
-    private config;
-    private cache;
-    constructor(config: WarpInitConfig);
-    createInscriptionTransaction(abi: WarpAbiContents): Transaction;
-    createFromRaw(encoded: string): Promise<WarpWarpAbi>;
-    createFromTransaction(tx: TransactionOnNetwork): Promise<WarpWarpAbi>;
-    createFromTransactionHash(hash: string, cache?: WarpCacheConfig): Promise<WarpWarpAbi | null>;
-}
+declare const resolveWarpText: (text: WarpText, config?: WarpClientConfig) => string;
+declare const isWarpI18nText: (text: WarpText) => text is WarpI18nText;
+declare const createWarpI18nText: (translations: Record<string, string>) => WarpI18nText;
 
-type TxComponents = {
-    destination: Address;
-    args: string[];
-    value: bigint;
-    transfers: TokenTransfer$1[];
-    data: Buffer | null;
-    resolvedInputs: ResolvedInput[];
-};
-declare class WarpActionExecutor {
-    private config;
-    private url;
-    private serializer;
-    private contractLoader;
-    private cache;
-    constructor(config: WarpInitConfig);
-    createTransactionForExecute(warp: Warp, actionIndex: number, inputs: string[]): Promise<Transaction>;
-    getTransactionExecutionResults(warp: Warp, actionIndex: number, tx: TransactionOnNetwork): Promise<WarpExecution>;
-    executeQuery(warp: Warp, actionIndex: number, inputs: string[]): Promise<WarpExecution>;
-    executeCollect(warp: Warp, actionIndex: number, inputs: string[], extra?: Record<string, any>): Promise<WarpExecution>;
-    getTxComponentsFromInputs(chain: WarpChainInfo, action: WarpTransferAction | WarpContractAction | WarpQueryAction, inputs: string[], sender?: Address): Promise<TxComponents>;
-    getResolvedInputs(chain: WarpChainInfo, action: WarpAction, inputArgs: string[]): Promise<ResolvedInput[]>;
-    getModifiedInputs(inputs: ResolvedInput[]): ResolvedInput[];
-    preprocessInput(chain: WarpChainInfo, input: string): Promise<string>;
-    getAbiForAction(action: WarpContractAction | WarpQueryAction): Promise<AbiRegistry>;
-    private getPreparedArgs;
-    private getPreparedMessages;
-    private fetchAbi;
-    private toTypedTransfer;
-}
+declare const getWarpInfoFromIdentifier: (prefixedIdentifier: string) => {
+    chainPrefix: string;
+    type: WarpIdType;
+    identifier: string;
+    identifierBase: string;
+} | null;
+declare const extractIdentifierInfoFromUrl: (url: string) => {
+    chainPrefix: string;
+    type: WarpIdType;
+    identifier: string;
+    identifierBase: string;
+} | null;
+
+/**
+ * Splits an input string into type and value, using only the first colon as separator.
+ * This handles cases where the value itself contains colons (like SUI token IDs).
+ */
+declare const splitInput: (input: string) => [WarpActionInputType, string];
+declare const hasInputPrefix: (input: string) => boolean;
+
+declare const getNextInfo: (config: WarpClientConfig, adapters: Adapter[], warp: Warp, actionIndex: number, results: WarpExecutionResults) => WarpExecutionNextInfo | null;
+
+/**
+ * Builds a nested payload object from a position string and field value.
+ * Position strings should be in format: "payload:path.to.nested.location"
+ *
+ * @param position - The position string defining where to place the value
+ * @param fieldName - The field name to use for the value
+ * @param value - The value to place at the position
+ * @returns A nested object structure or flat object if position doesn't start with 'payload:'
+ */
+declare function buildNestedPayload(position: string, fieldName: string, value: any): any;
+/**
+ * Recursively merges a source object into a target object and returns the merged result.
+ * Existing nested objects are merged recursively, primitive values are overwritten.
+ * Does not mutate the original target or source objects.
+ *
+ * @param target - The target object to merge into
+ * @param source - The source object to merge from
+ * @returns A new object with the merged result
+ */
+declare function mergeNestedPayload(target: any, source: any): any;
+
+declare const getProviderUrl: (config: WarpClientConfig, chain: WarpChain, env: WarpChainEnv, defaultProvider: string) => string;
+declare const getProviderConfig: (config: WarpClientConfig, chain: WarpChain) => WarpProviderConfig | undefined;
 
-type WarpNativeValue = string | number | bigint | boolean | null | TokenTransfer | WarpNativeValue[];
-declare class WarpArgSerializer {
+declare class WarpSerializer {
+    private readonly typeRegistry?;
+    constructor(options?: {
+        typeRegistry?: AdapterTypeRegistry;
+    });
     nativeToString(type: WarpActionInputType, value: WarpNativeValue): string;
-    typedToString(value: TypedValue): string;
-    typedToNative(value: TypedValue): [WarpActionInputType, WarpNativeValue];
-    nativeToTyped(type: WarpActionInputType, value: WarpNativeValue): TypedValue;
-    nativeToType(type: BaseWarpActionInputType): Type;
     stringToNative(value: string): [WarpActionInputType, WarpNativeValue];
-    stringToTyped(value: string): TypedValue;
-    typeToString(type: Type): WarpActionInputType;
+    private getTypeAndValue;
 }
 
-declare class WarpBuilder {
+declare const extractCollectResults: (warp: Warp, response: any, actionIndex: number, inputs: ResolvedInput[], serializer: WarpSerializer, transformRunner?: TransformRunner | null) => Promise<{
+    values: {
+        string: string[];
+        native: any[];
+    };
+    results: WarpExecutionResults;
+}>;
+declare const evaluateResultsCommon: (warp: Warp, baseResults: WarpExecutionResults, actionIndex: number, inputs: ResolvedInput[], serializer: WarpSerializer, transformRunner?: TransformRunner | null) => Promise<WarpExecutionResults>;
+/**
+ * Parses out[N] notation and returns the action index (1-based) or null if invalid.
+ * Also handles plain "out" which defaults to action index 1.
+ */
+declare const parseResultsOutIndex: (resultPath: string) => number | null;
+
+/**
+ * Signing utilities for creating and validating signed messages
+ * Works with any crypto provider or uses automatic detection
+ */
+
+interface SignableMessage {
+    wallet: string;
+    nonce: string;
+    expiresAt: string;
+    purpose: string;
+}
+type HttpAuthHeaders = Record<string, string> & {
+    'X-Signer-Wallet': string;
+    'X-Signer-Signature': string;
+    'X-Signer-Nonce': string;
+    'X-Signer-ExpiresAt': string;
+};
+/**
+ * Creates a signable message with standard security fields
+ * This can be used for any type of proof or authentication
+ */
+declare function createSignableMessage(walletAddress: string, purpose: string, cryptoProvider?: CryptoProvider, expiresInMinutes?: number): Promise<{
+    message: string;
+    nonce: string;
+    expiresAt: string;
+}>;
+/**
+ * Creates a signable message for HTTP authentication
+ * This is a convenience function that uses the standard format
+ */
+declare function createAuthMessage(walletAddress: string, appName: string, cryptoProvider?: CryptoProvider, purpose?: string): Promise<{
+    message: string;
+    nonce: string;
+    expiresAt: string;
+}>;
+/**
+ * Creates HTTP authentication headers from a signature
+ */
+declare function createAuthHeaders(walletAddress: string, signature: string, nonce: string, expiresAt: string): HttpAuthHeaders;
+/**
+ * Creates HTTP authentication headers for a wallet using the provided signing function
+ */
+declare function createHttpAuthHeaders(walletAddress: string, signMessage: (message: string) => Promise<string>, appName: string, cryptoProvider?: CryptoProvider): Promise<HttpAuthHeaders>;
+/**
+ * Validates a signed message by checking expiration
+ */
+declare function validateSignedMessage(expiresAt: string): boolean;
+/**
+ * Parses a signed message to extract its components
+ */
+declare function parseSignedMessage(message: string): SignableMessage;
+
+declare const getWarpWalletAddress: (wallet: WarpWalletDetails | string | null | undefined) => string | null;
+declare const getWarpWalletAddressFromConfig: (config: WarpClientConfig, chain: WarpChain) => string | null;
+declare const getWarpWalletPrivateKey: (wallet: WarpWalletDetails | string | null | undefined) => string | null | undefined;
+declare const getWarpWalletMnemonic: (wallet: WarpWalletDetails | string | null | undefined) => string | null | undefined;
+declare const getWarpWalletPrivateKeyFromConfig: (config: WarpClientConfig, chain: WarpChain) => string | null;
+declare const getWarpWalletMnemonicFromConfig: (config: WarpClientConfig, chain: WarpChain) => string | null;
+
+type CodecFunc<T extends WarpNativeValue = WarpNativeValue> = (value: T) => string;
+declare const string: CodecFunc<string>;
+declare const uint8: CodecFunc<number>;
+declare const uint16: CodecFunc<number>;
+declare const uint32: CodecFunc<number>;
+declare const uint64: CodecFunc<bigint | number>;
+declare const biguint: CodecFunc<bigint | string | number>;
+declare const bool: CodecFunc<boolean>;
+declare const address: CodecFunc<string>;
+declare const asset: CodecFunc<WarpChainAssetValue & {
+    decimals?: number;
+}>;
+declare const hex: CodecFunc<string>;
+declare const option: <T extends WarpNativeValue>(codecFunc: CodecFunc<T>, value: T | null) => string;
+declare const tuple: (...values: WarpNativeValue[]) => string;
+declare const struct: CodecFunc<WarpStructValue>;
+declare const vector: CodecFunc<WarpNativeValue[]>;
+
+declare class WarpBrandBuilder {
     private config;
-    private cache;
+    private pendingBrand;
+    constructor(config: WarpClientConfig);
+    createFromRaw(encoded: string, validateSchema?: boolean): Promise<WarpBrand>;
+    setName(name: WarpText): WarpBrandBuilder;
+    setDescription(description: WarpText): WarpBrandBuilder;
+    setLogo(logo: string): WarpBrandBuilder;
+    setUrls(urls: WarpBrandUrls): WarpBrandBuilder;
+    setColors(colors: WarpBrandColors): WarpBrandBuilder;
+    setCta(cta: WarpBrandCta): WarpBrandBuilder;
+    build(): Promise<WarpBrand>;
+    private ensure;
+    private ensureWarpText;
+    private ensureValidSchema;
+}
+
+declare class WarpBuilder implements BaseWarpBuilder {
+    protected readonly config: WarpClientConfig;
     private pendingWarp;
-    constructor(config: WarpInitConfig);
-    createInscriptionTransaction(warp: Warp): Transaction;
+    constructor(config: WarpClientConfig);
     createFromRaw(encoded: string, validate?: boolean): Promise<Warp>;
-    createFromTransaction(tx: TransactionOnNetwork, validate?: boolean): Promise<Warp>;
-    createFromTransactionHash(hash: string, cache?: WarpCacheConfig): Promise<Warp | null>;
+    createFromUrl(url: string): Promise<Warp>;
+    setChain(chain: WarpChain): WarpBuilder;
     setName(name: string): WarpBuilder;
-    setTitle(title: string): WarpBuilder;
-    setDescription(description: string): WarpBuilder;
+    setTitle(title: WarpText): WarpBuilder;
+    setDescription(description: WarpText): WarpBuilder;
     setPreview(preview: string): WarpBuilder;
     setActions(actions: WarpAction[]): WarpBuilder;
     addAction(action: WarpAction): WarpBuilder;
     build(): Promise<Warp>;
     getDescriptionPreview(description: string, maxChars?: number): string;
     private ensure;
+    private ensureWarpText;
     private validate;
 }
 
-declare class WarpContractLoader {
-    private readonly config;
-    constructor(config: WarpInitConfig);
-    getContract(address: string, chain: WarpChainInfo): Promise<WarpContract | null>;
-    getVerificationInfo(address: string, chain: WarpChainInfo): Promise<WarpContractVerification | null>;
+declare const CacheTtl: {
+    OneMinute: number;
+    OneHour: number;
+    OneDay: number;
+    OneWeek: number;
+    OneMonth: number;
+    OneYear: number;
+};
+declare const WarpCacheKey: {
+    Warp: (env: WarpChainEnv, id: string) => string;
+    WarpAbi: (env: WarpChainEnv, id: string) => string;
+    WarpExecutable: (env: WarpChainEnv, id: string, action: number) => string;
+    RegistryInfo: (env: WarpChainEnv, id: string) => string;
+    Brand: (env: WarpChainEnv, hash: string) => string;
+    Asset: (env: WarpChainEnv, chain: string, identifier: string) => string;
+};
+declare class WarpCache {
+    private strategy;
+    constructor(type?: WarpCacheType);
+    private selectStrategy;
+    set<T>(key: string, value: T, ttl: number): void;
+    get<T>(key: string): T | null;
+    forget(key: string): void;
+    clear(): void;
+}
+
+type ExecutionHandlers = {
+    onExecuted?: (result: WarpActionExecution) => void | Promise<void>;
+    onError?: (params: {
+        message: string;
+    }) => void;
+    onSignRequest?: (params: {
+        message: string;
+        chain: WarpChainInfo;
+    }) => string | Promise<string>;
+    onActionExecuted?: (params: {
+        action: WarpActionIndex;
+        chain: WarpChainInfo | null;
+        execution: WarpActionExecution | null;
+        tx: WarpAdapterGenericTransaction | null;
+    }) => void;
+};
+declare class WarpExecutor {
+    private config;
+    private adapters;
+    private handlers?;
+    private factory;
+    constructor(config: WarpClientConfig, adapters: Adapter[], handlers?: ExecutionHandlers | undefined);
+    execute(warp: Warp, inputs: string[], meta?: {
+        envs?: Record<string, any>;
+        queries?: Record<string, any>;
+    }): Promise<{
+        txs: WarpAdapterGenericTransaction[];
+        chain: WarpChainInfo | null;
+        immediateExecutions: WarpActionExecution[];
+    }>;
+    executeAction(warp: Warp, actionIndex: WarpActionIndex, inputs: string[], meta?: {
+        envs?: Record<string, any>;
+        queries?: Record<string, any>;
+    }): Promise<{
+        tx: WarpAdapterGenericTransaction | null;
+        chain: WarpChainInfo | null;
+        immediateExecution: WarpActionExecution | null;
+    }>;
+    evaluateResults(warp: Warp, actions: WarpChainAction[]): Promise<void>;
+    private executeCollect;
+    private callHandler;
+}
+
+declare class WarpFactory {
+    private config;
+    private adapters;
+    private url;
+    private serializer;
+    private cache;
+    constructor(config: WarpClientConfig, adapters: Adapter[]);
+    getSerializer(): WarpSerializer;
+    createExecutable(warp: Warp, actionIndex: number, inputs: string[], meta?: {
+        envs?: Record<string, any>;
+        queries?: Record<string, any>;
+    }): Promise<WarpExecutable>;
+    getChainInfoForWarp(warp: Warp, inputs?: string[]): Promise<WarpChainInfo>;
+    getStringTypedInputs(action: WarpAction, inputs: string[]): string[];
+    getResolvedInputs(chain: WarpChain, action: WarpAction, inputArgs: string[]): Promise<ResolvedInput[]>;
+    getModifiedInputs(inputs: ResolvedInput[]): ResolvedInput[];
+    preprocessInput(chain: WarpChain, input: string): Promise<string>;
+    private getDestinationFromAction;
+    private getPreparedArgs;
+    private tryGetChainFromInputs;
 }
 
 declare class WarpIndex {
     private config;
-    constructor(config: WarpInitConfig);
+    constructor(config: WarpClientConfig);
     search(query: string, params?: Record<string, any>, headers?: Record<string, string>): Promise<WarpSearchHit[]>;
 }
 
+declare class WarpLinkBuilder {
+    private readonly config;
+    private readonly adapters;
+    constructor(config: WarpClientConfig, adapters: Adapter[]);
+    isValid(url: string): boolean;
+    build(chain: WarpChain, type: WarpIdType, id: string): string;
+    buildFromPrefixedIdentifier(identifier: string): string | null;
+    generateQrCode(chain: WarpChain, type: WarpIdType, id: string, size?: number, background?: string, color?: string, logoColor?: string): QRCodeStyling;
+}
+
 type DetectionResult = {
     match: boolean;
     url: string;
     warp: Warp | null;
+    chain: WarpChain | null;
     registryInfo: WarpRegistryInfo | null;
-    brand: Brand | null;
+    brand: WarpBrand | null;
 };
 type DetectionResultFromHtml = {
     match: boolean;
@@ -519,63 +925,88 @@ type DetectionResultFromHtml = {
         warp: Warp;
     }[];
 };
-declare class WarpLink {
+declare class WarpLinkDetecter {
     private config;
-    constructor(config: WarpInitConfig);
+    private adapters;
+    constructor(config: WarpClientConfig, adapters: Adapter[]);
     isValid(url: string): boolean;
     detectFromHtml(content: string): Promise<DetectionResultFromHtml>;
     detect(url: string, cache?: WarpCacheConfig): Promise<DetectionResult>;
-    build(type: WarpIdType, id: string): string;
-    buildFromPrefixedIdentifier(prefixedIdentifier: string): string;
-    generateQrCode(type: WarpIdType, id: string, size?: number, background?: string, color?: string, logoColor?: string): QRCodeStyling;
-    private extractIdentifierInfoFromUrl;
 }
 
-declare class WarpRegistry {
-    private config;
-    private cache;
-    registryConfig: WarpRegistryConfigInfo;
-    constructor(config: WarpInitConfig);
-    init(): Promise<void>;
-    createWarpRegisterTransaction(txHash: string, alias?: string | null, brand?: string | null): Transaction$1;
-    createWarpUnregisterTransaction(txHash: string): Transaction$1;
-    createWarpUpgradeTransaction(alias: string, txHash: string): Transaction$1;
-    createWarpAliasSetTransaction(txHash: string, alias: string): Transaction$1;
-    createWarpVerifyTransaction(txHash: string): Transaction$1;
-    createWarpTransferOwnershipTransaction(txHash: string, newOwner: string): Transaction$1;
-    createBrandRegisterTransaction(txHash: string): Transaction$1;
-    createWarpBrandingTransaction(warpHash: string, brandHash: string): Transaction$1;
-    getInfoByAlias(alias: string, cache?: WarpCacheConfig): Promise<{
-        registryInfo: WarpRegistryInfo | null;
-        brand: Brand | null;
-    }>;
-    getInfoByHash(hash: string, cache?: WarpCacheConfig): Promise<{
-        registryInfo: WarpRegistryInfo | null;
-        brand: Brand | null;
+declare class WarpClient {
+    private readonly config;
+    private adapters;
+    constructor(config: WarpClientConfig, adapters: Adapter[]);
+    getConfig(): WarpClientConfig;
+    getAdapters(): Adapter[];
+    addAdapter(adapter: Adapter): WarpClient;
+    createExecutor(handlers?: ExecutionHandlers): WarpExecutor;
+    detectWarp(urlOrId: string, cache?: WarpCacheConfig): Promise<DetectionResult>;
+    executeWarp(warpOrIdentifierOrUrl: string | Warp, inputs: string[], handlers?: ExecutionHandlers, params?: {
+        cache?: WarpCacheConfig;
+        queries?: Record<string, any>;
+    }): Promise<{
+        txs: WarpAdapterGenericTransaction[];
+        chain: WarpChainInfo | null;
+        immediateExecutions: WarpActionExecution[];
+        evaluateResults: (remoteTxs: WarpAdapterGenericRemoteTransaction[]) => Promise<void>;
     }>;
-    getUserWarpRegistryInfos(user?: string): Promise<WarpRegistryInfo[]>;
-    getUserBrands(user?: string): Promise<Brand[]>;
-    getChainInfos(cache?: WarpCacheConfig): Promise<WarpChainInfo[]>;
-    getChainInfo(chain: WarpChain, cache?: WarpCacheConfig): Promise<WarpChainInfo | null>;
-    fetchBrand(hash: string, cache?: WarpCacheConfig): Promise<Brand | null>;
-    getRegistryContractAddress(): Address$1;
-    private loadRegistryConfigs;
-    private getFactory;
-    private getController;
-    private isCurrentUserAdmin;
-}
-
-declare class WarpUtils {
-    static getInfoFromPrefixedIdentifier(prefixedIdentifier: string): {
-        type: WarpIdType;
-        identifier: string;
-        identifierBase: string;
-    } | null;
-    static getNextInfo(config: WarpInitConfig, warp: Warp, actionIndex: number, results: WarpExecutionResults): WarpExecutionNextInfo | null;
-    private static buildNextUrl;
-    private static getNestedValue;
-    static getChainInfoForAction(config: WarpInitConfig, action: WarpAction): Promise<WarpChainInfo>;
-    static getChainEntrypoint(chainInfo: WarpChainInfo, env: WarpChainEnv): NetworkEntrypoint;
+    createInscriptionTransaction(chain: WarpChain, warp: Warp): WarpAdapterGenericTransaction;
+    createFromTransaction(chain: WarpChain, tx: WarpAdapterGenericRemoteTransaction, validate?: boolean): Promise<Warp>;
+    createFromTransactionHash(hash: string, cache?: WarpCacheConfig): Promise<Warp | null>;
+    signMessage(chain: WarpChain, message: string): Promise<string>;
+    getActions(chain: WarpChain, ids: string[], awaitCompleted?: boolean): Promise<WarpChainAction[]>;
+    getExplorer(chain: WarpChain): AdapterWarpExplorer;
+    getResults(chain: WarpChain): AdapterWarpResults;
+    getRegistry(chain: WarpChain): Promise<AdapterWarpRegistry>;
+    getDataLoader(chain: WarpChain): AdapterWarpDataLoader;
+    getWallet(chain: WarpChain): AdapterWarpWallet;
+    get factory(): WarpFactory;
+    get index(): WarpIndex;
+    get linkBuilder(): WarpLinkBuilder;
+    createBuilder(chain: WarpChain): CombinedWarpBuilder;
+    createAbiBuilder(chain: WarpChain): AdapterWarpAbiBuilder;
+    createBrandBuilder(chain: WarpChain): AdapterWarpBrandBuilder;
+    createSerializer(chain: WarpChain): AdapterWarpSerializer;
+    resolveText(warpText: WarpText): string;
+}
+
+declare class WarpInterpolator {
+    private config;
+    private adapter;
+    constructor(config: WarpClientConfig, adapter: Adapter);
+    apply(config: WarpClientConfig, warp: Warp, meta?: {
+        envs?: Record<string, any>;
+        queries?: Record<string, any>;
+    }): Promise<Warp>;
+    applyGlobals(config: WarpClientConfig, warp: Warp): Promise<Warp>;
+    applyVars(config: WarpClientConfig, warp: Warp, meta?: {
+        envs?: Record<string, any>;
+        queries?: Record<string, any>;
+    }): Warp;
+    private applyRootGlobals;
+    private applyActionGlobals;
+}
+
+declare class WarpLogger {
+    private static isTestEnv;
+    static debug(...args: any[]): void;
+    static info(...args: any[]): void;
+    static warn(...args: any[]): void;
+    static error(...args: any[]): void;
+}
+
+declare class WarpTypeRegistry implements AdapterTypeRegistry {
+    private typeHandlers;
+    private typeAliases;
+    registerType(typeName: string, handler: WarpTypeHandler): void;
+    registerTypeAlias(typeName: string, alias: string): void;
+    hasType(typeName: string): boolean;
+    getHandler(typeName: string): WarpTypeHandler | undefined;
+    getAlias(typeName: string): string | undefined;
+    resolveType(typeName: string): string;
+    getRegisteredTypes(): string[];
 }
 
 type ValidationResult = {
@@ -585,12 +1016,13 @@ type ValidationResult = {
 type ValidationError = string;
 declare class WarpValidator {
     private config;
-    constructor(config: WarpInitConfig);
+    constructor(config: WarpClientConfig);
     validate(warp: Warp): Promise<ValidationResult>;
+    private validatePrimaryAction;
     private validateMaxOneValuePosition;
     private validateVariableNamesAndResultNamesUppercase;
     private validateAbiIsSetIfApplicable;
     private validateSchema;
 }
 
-export { type BaseWarpActionInputType, type Brand, BrandBuilder, type BrandColors, type BrandCta, type BrandMeta, type BrandUrls, CacheKey, CacheTtl, type CacheType, type InterpolationBag, type ProtocolName, type ResolvedInput, type Warp, WarpAbiBuilder, type WarpAbiContents, type WarpAction, WarpActionExecutor, type WarpActionInput, type WarpActionInputModifier, type WarpActionInputPosition, type WarpActionInputSource, type WarpActionInputType, type WarpActionType, WarpArgSerializer, WarpBuilder, WarpCache, type WarpCacheConfig, type WarpChain, type WarpChainEnv, type WarpChainInfo, type WarpCollectAction, WarpConfig, WarpConstants, type WarpContract, type WarpContractAction, type WarpContractActionTransfer, WarpContractLoader, type WarpContractVerification, type WarpExecution, type WarpExecutionMessages, type WarpExecutionNextInfo, type WarpExecutionResults, type WarpIdType, WarpIndex, type WarpInitConfig, WarpInterpolator, WarpLink, type WarpLinkAction, type WarpMessageName, type WarpMeta, type WarpNativeValue, WarpProtocolVersions, type WarpQueryAction, WarpRegistry, type WarpRegistryConfigInfo, type WarpRegistryInfo, type WarpResultName, type WarpResulutionPath, type WarpSearchHit, type WarpSearchResult, type WarpTransferAction, type WarpTrustStatus, WarpUtils, WarpValidator, type WarpVarPlaceholder, type WarpWarpAbi, address, biguint, boolean, codemeta, composite, esdt, getChainExplorerUrl, getLatestProtocolIdentifier, getMainChainInfo, getWarpActionByIndex, hex, list, nothing, option, optional, replacePlaceholders, shiftBigintBy, string, toPreviewText, toTypedChainInfo, token, u16, u32, u64, u8, variadic };
+export { type Adapter, type AdapterFactory, type AdapterTypeRegistry, type AdapterWarpAbiBuilder, type AdapterWarpBrandBuilder, type AdapterWarpBuilder, type AdapterWarpDataLoader, type AdapterWarpExecutor, type AdapterWarpExplorer, type AdapterWarpRegistry, type AdapterWarpResults, type AdapterWarpSerializer, type AdapterWarpWallet, type BaseWarpActionInputType, type BaseWarpBuilder, BrowserCryptoProvider, CacheTtl, type ClientIndexConfig, type ClientTransformConfig, type CodecFunc, type CombinedWarpBuilder, type CryptoProvider, type DetectionResult, type DetectionResultFromHtml, type ExecutionHandlers, type HttpAuthHeaders, type InterpolationBag, NodeCryptoProvider, type ProtocolName, type ResolvedInput, type SignableMessage, type TransformRunner, type Warp, type WarpAbi, type WarpAbiContents, type WarpAction, type WarpActionExecution, type WarpActionIndex, type WarpActionInput, type WarpActionInputModifier, type WarpActionInputPosition, type WarpActionInputSource, type WarpActionInputType, type WarpActionType, type WarpAdapterGenericRemoteTransaction, type WarpAdapterGenericTransaction, type WarpAdapterGenericType, type WarpAdapterGenericValue, type WarpBrand, WarpBrandBuilder, type WarpBrandColors, type WarpBrandCta, type WarpBrandUrls, WarpBuilder, WarpCache, type WarpCacheConfig, WarpCacheKey, type WarpChain, type WarpChainAccount, type WarpChainAction, type WarpChainActionStatus, type WarpChainAsset, type WarpChainAssetValue, type WarpChainEnv, type WarpChainInfo, WarpChainName, WarpClient, type WarpClientConfig, type WarpCollectAction, WarpConfig, WarpConstants, type WarpContract, type WarpContractAction, type WarpContractVerification, type WarpDataLoaderOptions, type WarpExecutable, type WarpExecutionMessages, type WarpExecutionNextInfo, type WarpExecutionResults, WarpExecutor, type WarpExplorerName, WarpFactory, type WarpI18nText, type WarpIdType, WarpIndex, WarpInputTypes, WarpInterpolator, type WarpLanguage, type WarpLinkAction, WarpLinkBuilder, WarpLinkDetecter, WarpLogger, type WarpMessageName, type WarpMeta, type WarpNativeValue, WarpProtocolVersions, type WarpProviderConfig, type WarpQueryAction, type WarpRegistryConfigInfo, type WarpRegistryInfo, type WarpResultName, type WarpResulutionPath, type WarpSearchHit, type WarpSearchResult, type WarpSecret, WarpSerializer, type WarpStructValue, type WarpText, type WarpTransferAction, type WarpTrustStatus, type WarpTypeHandler, WarpTypeRegistry, type WarpUserWallets, WarpValidator, type WarpVarPlaceholder, type WarpWalletDetails, address, applyResultsToMessages, asset, biguint, bool, buildNestedPayload, bytesToBase64, bytesToHex, createAuthHeaders, createAuthMessage, createCryptoProvider, createHttpAuthHeaders, createSignableMessage, createWarpI18nText, evaluateResultsCommon, extractCollectResults, extractIdentifierInfoFromUrl, extractWarpSecrets, findWarpAdapterByPrefix, findWarpAdapterForChain, getCryptoProvider, getLatestProtocolIdentifier, getNextInfo, getProviderConfig, getProviderUrl, getRandomBytes, getRandomHex, getWarpActionByIndex, getWarpInfoFromIdentifier, getWarpPrimaryAction, getWarpWalletAddress, getWarpWalletAddressFromConfig, getWarpWalletMnemonic, getWarpWalletMnemonicFromConfig, getWarpWalletPrivateKey, getWarpWalletPrivateKeyFromConfig, hasInputPrefix, hex, isWarpActionAutoExecute, isWarpI18nText, mergeNestedPayload, option, parseResultsOutIndex, parseSignedMessage, replacePlaceholders, resolveWarpText, safeWindow, setCryptoProvider, shiftBigintBy, splitInput, string, struct, testCryptoAvailability, toPreviewText, tuple, uint16, uint32, uint64, uint8, validateSignedMessage, vector };