@vleap/warps 3.0.0-alpha.8 → 3.0.0-alpha.81

package/dist/index.d.ts

@@ -1,75 +1,33 @@
-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 WarpChainAccount = {
+    address: string;
+    balance: bigint;
 };
-declare const CacheKey: {
-    Warp: (id: string) => string;
-    WarpAbi: (id: string) => string;
-    LastWarpExecutionInputs: (id: string, action: number) => string;
-    RegistryInfo: (id: string) => string;
-    Brand: (hash: string) => string;
-    ChainInfo: (chain: WarpChain) => string;
-    ChainInfos: () => string;
+type WarpChainAssetValue = {
+    identifier: string;
+    nonce: bigint;
+    amount: bigint;
+};
+type WarpChainAsset = {
+    identifier: string;
+    nonce?: bigint;
+    name: string;
+    amount: bigint;
+    decimals?: number;
+    logoUrl?: 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 WarpChainEnv = 'mainnet' | 'testnet' | 'devnet';
-type ProtocolName = 'warp' | 'brand' | 'abi';
 
 type WarpChain = string;
-type WarpInitConfig = {
-    env: WarpChainEnv;
-    clientUrl?: string;
-    currentUrl?: string;
-    vars?: Record<string, string | number>;
-    user?: {
-        wallet?: string;
-    };
-    schema?: {
-        warp?: string;
-        brand?: string;
-    };
-    cache?: {
-        ttl?: number;
-        type?: CacheType;
-    };
-    registry?: {
-        contract?: string;
-    };
-    index?: {
-        url?: string;
-        apiKey?: string;
-        searchParamName?: string;
-    };
-};
-type WarpCacheConfig = {
-    ttl?: number;
-};
+type WarpExplorerName = string;
 type WarpChainInfo = {
-    name: WarpChain;
+    name: string;
     displayName: string;
     chainId: string;
     blockTime: number;
     addressHrp: string;
-    apiUrl: string;
-    explorerUrl: string;
+    defaultApiUrl: string;
+    nativeToken: string;
 };
 type WarpIdType = 'hash' | 'alias';
 type WarpVarPlaceholder = string;
@@ -91,11 +49,13 @@ type Warp = {
     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;
@@ -105,7 +65,7 @@ type WarpTransferAction = {
     address?: string;
     data?: string;
     value?: string;
-    transfers?: WarpContractActionTransfer[];
+    transfers?: string[];
     inputs?: WarpActionInput[];
     next?: string;
 };
@@ -114,29 +74,24 @@ type WarpContractAction = {
     chain?: WarpChain;
     label: string;
     description?: string | null;
-    address: string;
-    func: string | null;
-    args: string[];
+    address?: string;
+    func?: string | null;
+    args?: string[];
     value?: string;
     gasLimit: number;
-    transfers?: WarpContractActionTransfer[];
+    transfers?: string[];
     abi?: string;
     inputs?: WarpActionInput[];
     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[];
+    address?: string;
+    func?: string;
+    args?: string[];
     abi?: string;
     inputs?: WarpActionInput[];
     next?: string;
@@ -163,9 +118,10 @@ type WarpLinkAction = {
     inputs?: WarpActionInput[];
 };
 type WarpActionInputSource = 'field' | 'query' | 'user:wallet';
-type BaseWarpActionInputType = 'string' | 'uint8' | 'uint16' | 'uint32' | 'uint64' | 'biguint' | 'bool' | 'address' | 'token' | 'codemeta' | 'hex' | 'esdt' | 'nft';
+type BaseWarpActionInputType = 'string' | 'uint8' | 'uint16' | 'uint32' | 'uint64' | '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';
+type WarpNativeValue = string | number | bigint | boolean | WarpChainAssetValue | null | WarpNativeValue[];
+type WarpActionInputPosition = 'receiver' | 'value' | 'transfer' | `arg:${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10}` | 'data' | 'chain';
 type WarpActionInputModifier = 'scale';
 type WarpActionInput = {
     name: string;
@@ -184,6 +140,7 @@ type WarpActionInput = {
         [key: string]: string;
     };
     modifier?: string;
+    default?: string | number | boolean;
 };
 type ResolvedInput = {
     input: WarpActionInput;
@@ -198,8 +155,19 @@ type WarpContractVerification = {
     codeHash: string;
     abi: object;
 };
+type WarpExecutable = {
+    chain: WarpChainInfo;
+    warp: Warp;
+    action: number;
+    destination: string;
+    args: string[];
+    value: bigint;
+    transfers: string[];
+    data: string | null;
+    resolvedInputs: ResolvedInput[];
+};
 
-type WarpWarpAbi = {
+type WarpAbi = {
     protocol: string;
     content: WarpAbiContents;
     meta?: WarpMeta;
@@ -213,35 +181,44 @@ type WarpAbiContents = {
     events?: any[];
 };
 
-type Brand = {
+type WarpBrand = {
     protocol: string;
     name: string;
     description: string;
     logo: string;
-    urls?: BrandUrls;
-    colors?: BrandColors;
-    cta?: BrandCta;
-    meta?: BrandMeta;
+    urls?: WarpBrandUrls;
+    colors?: WarpBrandColors;
+    cta?: WarpBrandCta;
+    meta?: WarpBrandMeta;
 };
-type BrandUrls = {
+type WarpBrandUrls = {
     web?: string;
 };
-type BrandColors = {
+type WarpBrandColors = {
     primary?: string;
     secondary?: string;
 };
-type BrandCta = {
+type WarpBrandCta = {
     title: string;
     description: string;
     label: string;
     url: string;
 };
-type BrandMeta = {
+type WarpBrandMeta = {
     hash: string;
     creator: string;
     createdAt: string;
 };
 
+type ClientCacheConfig = {
+    ttl?: number;
+    type?: WarpCacheType;
+};
+type WarpCacheType = 'memory' | 'localStorage';
+
+type WarpChainEnv = 'mainnet' | 'testnet' | 'devnet';
+type ProtocolName = 'warp' | 'brand' | 'abi';
+
 type WarpTrustStatus = 'unverified' | 'verified' | 'blacklisted';
 type WarpRegistryInfo = {
     hash: string;
@@ -276,6 +253,11 @@ type WarpExecutionNextInfo = {
 type WarpExecutionResults = Record<WarpResultName, any | null>;
 type WarpExecutionMessages = Record<WarpMessageName, string | null>;
 
+type ClientIndexConfig = {
+    url?: string;
+    apiKey?: string;
+    searchParamName?: string;
+};
 type WarpSearchResult = {
     hits: WarpSearchHit[];
 };
@@ -291,71 +273,160 @@ type WarpSearchHit = {
     featured: boolean;
 };
 
-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;
+interface TransformRunner {
+    run(code: string, context: any): Promise<any>;
 }
-
-declare const WarpProtocolVersions: {
-    Warp: string;
-    Brand: string;
-    Abi: string;
+type ClientTransformConfig = {
+    runner?: TransformRunner | null;
 };
-declare const WarpConfig: {
-    LatestWarpSchemaUrl: string;
-    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";
+
+type WarpUserWallets = Record<WarpChain, string | null>;
+type WarpProviderConfig = Record<WarpChainEnv, string>;
+type WarpClientConfig = {
+    env: WarpChainEnv;
+    clientUrl?: string;
+    currentUrl?: string;
+    vars?: Record<string, string | number>;
+    user?: {
+        wallets?: WarpUserWallets;
     };
-    Registry: {
-        Contract: (env: WarpChainEnv) => "erd1qqqqqqqqqqqqqpgqje2f99vr6r7sk54thg03c9suzcvwr4nfl3tsfkdl36" | "####" | "erd1qqqqqqqqqqqqqpgq3mrpj3u6q7tejv6d7eqhnyd27n9v5c5tl3ts08mffe";
+    preferences?: {
+        explorers?: Record<WarpChain, WarpExplorerName>;
     };
-    AvailableActionInputSources: WarpActionInputSource[];
-    AvailableActionInputTypes: WarpActionInputType[];
-    AvailableActionInputPositions: WarpActionInputPosition[];
+    providers?: Record<WarpChain, WarpProviderConfig>;
+    schema?: {
+        warp?: string;
+        brand?: string;
+    };
+    cache?: ClientCacheConfig;
+    transform?: ClientTransformConfig;
+    index?: ClientIndexConfig;
 };
-
-type InterpolationBag = {
-    config: WarpInitConfig;
-    chain: WarpChainInfo;
+type WarpCacheConfig = {
+    ttl?: number;
 };
-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;
+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;
+    registerTypes?: (typeRegistry: WarpTypeRegistry) => void;
+};
+type WarpAdapterGenericTransaction = any;
+type WarpAdapterGenericRemoteTransaction = any;
+type WarpAdapterGenericValue = any;
+type WarpAdapterGenericType = any;
+interface WarpTypeHandler {
+    stringToNative(value: string): any;
+    nativeToString(value: any): string;
+}
+interface WarpTypeRegistry {
+    registerType(typeName: string, handler: WarpTypeHandler): void;
+    hasType(typeName: string): boolean;
+    getHandler(typeName: string): WarpTypeHandler | undefined;
+    getRegisteredTypes(): string[];
+}
+interface BaseWarpBuilder {
+    createFromRaw(encoded: string): 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): WarpAdapterGenericTransaction;
+    createFromTransaction(tx: WarpAdapterGenericTransaction, validate?: boolean): Promise<Warp>;
+    createFromTransactionHash(hash: string, cache?: WarpCacheConfig): Promise<Warp | null>;
+}
+type CombinedWarpBuilder = AdapterWarpBuilder & BaseWarpBuilder;
+interface AdapterWarpAbiBuilder {
+    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>;
+    preprocessInput(chain: WarpChainInfo, input: string, type: WarpActionInputType, value: string): Promise<string>;
+    signMessage(message: string, privateKey: string): Promise<string>;
+}
+interface AdapterWarpResults {
+    getTransactionExecutionResults(warp: Warp, tx: WarpAdapterGenericRemoteTransaction): Promise<WarpExecution>;
+}
+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): 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 AdapterWarpDataLoader {
+    getAccount(address: string): Promise<WarpChainAccount>;
+    getAccountAssets(address: string): Promise<WarpChainAsset[]>;
 }
 
+declare enum WarpChainName {
+    Multiversx = "multiversx",
+    Vibechain = "vibechain",
+    Sui = "sui",
+    Ethereum = "ethereum",
+    Base = "base",
+    Arbitrum = "arbitrum"
+}
 declare const WarpConstants: {
     HttpProtocolPrefix: string;
     IdentifierParamName: string;
-    IdentifierParamSeparator: string;
+    IdentifierParamSeparator: string[];
+    IdentifierParamSeparatorDefault: string;
+    IdentifierChainDefault: string;
     IdentifierType: {
-        Alias: string;
-        Hash: string;
+        Alias: WarpIdType;
+        Hash: WarpIdType;
     };
     Source: {
         UserWallet: string;
@@ -363,13 +434,13 @@ declare const WarpConstants: {
     Globals: {
         UserWallet: {
             Placeholder: string;
-            Accessor: (bag: InterpolationBag) => string | undefined;
+            Accessor: (bag: InterpolationBag) => string | null | undefined;
         };
         ChainApiUrl: {
             Placeholder: string;
             Accessor: (bag: InterpolationBag) => string;
         };
-        ChainExplorerUrl: {
+        ChainAddressHrp: {
             Placeholder: string;
             Accessor: (bag: InterpolationBag) => string;
         };
@@ -383,103 +454,203 @@ declare const WarpConstants: {
     Transform: {
         Prefix: string;
     };
-    Egld: {
-        Identifier: string;
-        EsdtIdentifier: string;
-        DisplayName: string;
-        Decimals: number;
-    };
+};
+declare const WarpInputTypes: {
+    Option: string;
+    Optional: string;
+    List: string;
+    Variadic: string;
+    Composite: string;
+    String: string;
+    U8: string;
+    U16: string;
+    U32: string;
+    U64: string;
+    Biguint: string;
+    Boolean: string;
+    Address: string;
+    Asset: string;
+    Hex: string;
+};
+
+type InterpolationBag = {
+    config: WarpClientConfig;
+    chain: WarpChainName;
+    chainInfo: WarpChainInfo;
+};
+
+declare const WarpProtocolVersions: {
+    Warp: string;
+    Brand: string;
+    Abi: string;
+};
+declare const WarpConfig: {
+    LatestWarpSchemaUrl: string;
+    LatestBrandSchemaUrl: string;
+    DefaultClientUrl: (env: WarpChainEnv) => "https://usewarp.to" | "https://testnet.usewarp.to" | "https://devnet.usewarp.to";
+    DefaultChainPrefix: string;
+    SuperClientUrls: string[];
+    AvailableActionInputSources: WarpActionInputSource[];
+    AvailableActionInputTypes: WarpActionInputType[];
+    AvailableActionInputPositions: WarpActionInputPosition[];
 };
 
-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 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 findWarpExecutableAction: (warp: Warp) => {
+    action: WarpAction;
+    actionIndex: WarpActionIndex;
+};
+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 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;
+
+declare const getNextInfo: (config: WarpClientConfig, adapters: Adapter[], warp: Warp, actionIndex: number, results: WarpExecutionResults) => WarpExecutionNextInfo | null;
+
+declare const getProviderUrl: (config: WarpClientConfig, chain: WarpChain, env: WarpChainEnv, defaultProvider: string) => string;
+declare const getProviderConfig: (config: WarpClientConfig, chain: WarpChain) => WarpProviderConfig | undefined;
+
+declare const extractCollectResults: (warp: Warp, response: any, actionIndex: number, inputs: ResolvedInput[], transformRunner?: TransformRunner | null) => Promise<{
+    values: any[];
+    results: WarpExecutionResults;
+}>;
+declare const evaluateResultsCommon: (warp: Warp, baseResults: WarpExecutionResults, actionIndex: number, inputs: ResolvedInput[], 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;
 
-type TxComponents = {
-    destination: Address;
-    args: string[];
-    value: bigint;
-    transfers: TokenTransfer$1[];
-    data: Buffer | null;
-    resolvedInputs: ResolvedInput[];
+type KnownToken = {
+    id: string;
+    name: string;
+    decimals: number;
 };
-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[], meta?: 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 KnownTokens: KnownToken[];
+declare const findKnownTokenById: (id: string) => KnownToken | null;
 
-type WarpNativeValue = string | number | bigint | boolean | null | TokenTransfer | WarpNativeValue[];
-declare class WarpArgSerializer {
-    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;
-}
+declare const string: (value: string) => string;
+declare const u8: (value: number) => string;
+declare const u16: (value: number) => string;
+declare const u32: (value: number) => string;
+declare const u64: (value: bigint | number) => string;
+declare const biguint: (value: bigint | string | number) => string;
+declare const boolean: (value: boolean) => string;
+declare const address: (value: string) => string;
+declare const asset: (value: WarpChainAsset) => string;
+declare const hex: (value: string) => string;
 
-declare class WarpBuilder {
+declare class WarpBrandBuilder {
     private config;
-    private cache;
+    private pendingBrand;
+    constructor(config: WarpClientConfig);
+    createFromRaw(encoded: string, validateSchema?: boolean): Promise<WarpBrand>;
+    setName(name: string): WarpBrandBuilder;
+    setDescription(description: string): WarpBrandBuilder;
+    setLogo(logo: string): WarpBrandBuilder;
+    setUrls(urls: WarpBrandUrls): WarpBrandBuilder;
+    setColors(colors: WarpBrandColors): WarpBrandBuilder;
+    setCta(cta: WarpBrandCta): WarpBrandBuilder;
+    build(): Promise<WarpBrand>;
+    private ensure;
+    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>;
     setName(name: string): WarpBuilder;
     setTitle(title: string): WarpBuilder;
     setDescription(description: string): WarpBuilder;
@@ -492,25 +663,95 @@ declare class WarpBuilder {
     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;
+};
+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: WarpExecution) => void;
+    onError?: (params: {
+        message: string;
+    }) => void;
+    onSignRequest?: (params: {
+        message: string;
+        chain: WarpChainInfo;
+    }) => Promise<string>;
+};
+declare class WarpExecutor {
+    private config;
+    private adapters;
+    private handlers?;
+    private factory;
+    private serializer;
+    constructor(config: WarpClientConfig, adapters: Adapter[], handlers?: ExecutionHandlers | undefined);
+    execute(warp: Warp, inputs: string[]): Promise<{
+        tx: WarpAdapterGenericTransaction | null;
+        chain: WarpChainInfo | null;
+    }>;
+    evaluateResults(warp: Warp, chain: WarpChain, tx: WarpAdapterGenericRemoteTransaction): Promise<void>;
+    private executeCollect;
+}
+
+declare class WarpFactory {
+    private config;
+    private adapters;
+    private url;
+    private serializer;
+    private cache;
+    constructor(config: WarpClientConfig, adapters: Adapter[]);
+    createExecutable(warp: Warp, actionIndex: number, inputs: string[]): Promise<WarpExecutable>;
+    getChainInfoForAction(action: WarpAction, inputs?: string[]): Promise<WarpChainInfo>;
+    getResolvedInputs(chain: WarpChain, action: WarpAction, inputArgs: string[]): Promise<ResolvedInput[]>;
+    getModifiedInputs(inputs: ResolvedInput[]): ResolvedInput[];
+    preprocessInput(chain: WarpChain, input: string): Promise<string>;
+    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 +760,79 @@ 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 {
+declare class WarpClient {
     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;
+    private adapters;
+    constructor(config: WarpClientConfig, adapters: Adapter[]);
+    getConfig(): WarpClientConfig;
+    setConfig(config: WarpClientConfig): WarpClient;
+    getAdapters(): Adapter[];
+    addAdapter(adapter: Adapter): WarpClient;
+    createExecutor(handlers?: ExecutionHandlers): WarpExecutor;
+    detectWarp(urlOrId: string, cache?: WarpCacheConfig): Promise<DetectionResult>;
+    executeWarp(identifier: string, inputs: string[], handlers?: ExecutionHandlers, options?: {
+        cache?: WarpCacheConfig;
+    }): Promise<{
+        tx: WarpAdapterGenericTransaction | null;
+        chain: WarpChainInfo | null;
+        evaluateResults: (remoteTx: 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, privateKey: string): Promise<string>;
+    getExplorer(chain: WarpChain): AdapterWarpExplorer;
+    getResults(chain: WarpChain): AdapterWarpResults;
+    getRegistry(chain: WarpChain): Promise<AdapterWarpRegistry>;
+    getDataLoader(chain: WarpChain): AdapterWarpDataLoader;
+    get factory(): WarpFactory;
+    get index(): WarpIndex;
+    get linkBuilder(): WarpLinkBuilder;
+    createBuilder(chain: WarpChain): CombinedWarpBuilder;
+    createAbiBuilder(chain: WarpChain): AdapterWarpAbiBuilder;
+    createBrandBuilder(chain: WarpChain): AdapterWarpBrandBuilder;
+}
+
+declare class WarpInterpolator {
+    private config;
+    private adapter;
+    constructor(config: WarpClientConfig, adapter: Adapter);
+    apply(config: WarpClientConfig, warp: Warp): Promise<Warp>;
+    applyGlobals(config: WarpClientConfig, warp: Warp): Promise<Warp>;
+    applyVars(config: WarpClientConfig, warp: Warp): Warp;
+    private applyRootGlobals;
+    private applyActionGlobals;
+}
+
+declare class WarpLogger {
+    private static isTestEnv;
+    static info(...args: any[]): void;
+    static warn(...args: any[]): void;
+    static error(...args: any[]): void;
+}
+
+declare class WarpSerializer {
+    private typeRegistry;
+    setTypeRegistry(typeRegistry: WarpTypeRegistry): void;
+    nativeToString(type: WarpActionInputType, value: WarpNativeValue): string;
+    stringToNative(value: string): [WarpActionInputType, WarpNativeValue];
+}
+
+declare class WarpTypeRegistryImpl implements WarpTypeRegistry {
+    private typeHandlers;
+    registerType(typeName: string, handler: WarpTypeHandler): void;
+    hasType(typeName: string): boolean;
+    getHandler(typeName: string): WarpTypeHandler | undefined;
+    getRegisteredTypes(): string[];
 }
 
 type ValidationResult = {
@@ -585,7 +842,7 @@ type ValidationResult = {
 type ValidationError = string;
 declare class WarpValidator {
     private config;
-    constructor(config: WarpInitConfig);
+    constructor(config: WarpClientConfig);
     validate(warp: Warp): Promise<ValidationResult>;
     private validateMaxOneValuePosition;
     private validateVariableNamesAndResultNamesUppercase;
@@ -593,4 +850,4 @@ declare class WarpValidator {
     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 AdapterWarpAbiBuilder, type AdapterWarpBrandBuilder, type AdapterWarpBuilder, type AdapterWarpDataLoader, type AdapterWarpExecutor, type AdapterWarpExplorer, type AdapterWarpRegistry, type AdapterWarpResults, type AdapterWarpSerializer, type BaseWarpActionInputType, type BaseWarpBuilder, BrowserCryptoProvider, CacheTtl, type ClientIndexConfig, type ClientTransformConfig, type CombinedWarpBuilder, type CryptoProvider, type DetectionResult, type DetectionResultFromHtml, type ExecutionHandlers, type HttpAuthHeaders, type InterpolationBag, type KnownToken, KnownTokens, NodeCryptoProvider, type ProtocolName, type ResolvedInput, type SignableMessage, type TransformRunner, type Warp, type WarpAbi, type WarpAbiContents, type WarpAction, 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 WarpBrandMeta, type WarpBrandUrls, WarpBuilder, WarpCache, type WarpCacheConfig, WarpCacheKey, type WarpChain, type WarpChainAccount, type WarpChainAsset, type WarpChainAssetValue, type WarpChainEnv, type WarpChainInfo, WarpChainName, WarpClient, type WarpClientConfig, type WarpCollectAction, WarpConfig, WarpConstants, type WarpContract, type WarpContractAction, type WarpContractVerification, type WarpExecutable, type WarpExecution, type WarpExecutionMessages, type WarpExecutionNextInfo, type WarpExecutionResults, WarpExecutor, type WarpExplorerName, WarpFactory, type WarpIdType, WarpIndex, WarpInputTypes, WarpInterpolator, 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, WarpSerializer, type WarpTransferAction, type WarpTrustStatus, type WarpTypeHandler, type WarpTypeRegistry, WarpTypeRegistryImpl, type WarpUserWallets, WarpValidator, type WarpVarPlaceholder, address, applyResultsToMessages, asset, biguint, boolean, bytesToBase64, bytesToHex, createAuthHeaders, createAuthMessage, createCryptoProvider, createHttpAuthHeaders, createSignableMessage, evaluateResultsCommon, extractCollectResults, extractIdentifierInfoFromUrl, findKnownTokenById, findWarpAdapterByPrefix, findWarpAdapterForChain, findWarpExecutableAction, getCryptoProvider, getLatestProtocolIdentifier, getNextInfo, getProviderConfig, getProviderUrl, getRandomBytes, getRandomHex, getWarpActionByIndex, getWarpInfoFromIdentifier, hex, parseResultsOutIndex, parseSignedMessage, replacePlaceholders, setCryptoProvider, shiftBigintBy, string, testCryptoAvailability, toPreviewText, u16, u32, u64, u8, validateSignedMessage };