mantle-agent-kit-sdk 1.0.4 → 1.1.2

package/dist/index.d.ts

@@ -3,6 +3,377 @@ import { Hex, Address, WalletClient, Transport, Chain, PublicActions } from 'vie
 import { PrivateKeyAccount, Address as Address$1 } from 'viem/accounts';
 import { Erc7811Actions } from 'viem/experimental';
 
+declare const PYTH_CONTRACT: {
+    readonly mainnet: "0xA2aa501b19aff244D90cc15a4Cf739D2725B5729";
+    readonly testnet: "0x98046Bd286715D3B0BC227Dd7a956b83D8978603";
+};
+declare const HERMES_ENDPOINT: {
+    readonly mainnet: "https://hermes.pyth.network";
+    readonly testnet: "https://hermes.pyth.network";
+};
+declare const PYTH_PRICE_FEED_IDS: {
+    readonly "BTC/USD": "e62df6c8b4a85fe1a67db44dc12de5db330f7ac66b72dc658afedf0f4a415b43";
+    readonly "ETH/USD": "ff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace";
+    readonly "SOL/USD": "ef0d8b6fda2ceba41da15d4095d1da392a0d2f8ed0c6c7bc0f4cfac8c280b56d";
+    readonly "BNB/USD": "2f95862b045670cd22bee3114c39763a4a08beeb663b145d283c31d7d1101c4f";
+    readonly "XRP/USD": "ec5d399846a9209f3fe5881d70aae9268c94339ff9817e8d18ff19fa05eea1c8";
+    readonly "ADA/USD": "2a01deaec9e51a579277b34b122399984d0bbf57e2458a7e42fecd2829867a0d";
+    readonly "DOGE/USD": "dcef50dd0a4cd2dcc17e45df1676dcb336a11a61c69df7a0299b0150c672d25c";
+    readonly "DOT/USD": "ca3eed9b267293f6595901c734c7525ce8ef49adafe8284571c8e17d6c926346";
+    readonly "AVAX/USD": "93da3352f9f1d105fdfe4971cfa80e9dd777bfc5d0f683ebb6e1294b92137bb7";
+    readonly "MATIC/USD": "5de33440f6b7d0d7d70f0a7b2a6c0e0b8e5d2f7c8a9b0c1d2e3f4a5b6c7d8e9f";
+    readonly "LINK/USD": "8ac0c70fff57e9aefdf5edf44b51d62c2d433653cbb2cf5cc06bb115af04d221";
+    readonly "ATOM/USD": "b00b60f88b03a6a625a8d1c048c3f66653edf217439cb6a1cbab0c1c5e8c52bd";
+    readonly "LTC/USD": "6e3f3fa8253588df9326580180233eb791e03b443a3ba7a1d892e73874e19a54";
+    readonly "UNI/USD": "78d185a741d07edb3412b09008b7c5cfb9bbbd7d568bf00ba737b456ba171501";
+    readonly "NEAR/USD": "c415de8d2eba7db216527dff4b60e8f3a5311c740dadb233e13e12547e226750";
+    readonly "TRX/USD": "67aed5a24fdad045475e7195c98a98aea119c763f272d4523f5bac93a4f33c2b";
+    readonly "ARB/USD": "3fa4252848f9f0a1480be62745a4629d9eb1322aebab8a791e344b3b9c1adcf5";
+    readonly "OP/USD": "385f64d993f7b77d8182ed5003d97c60aa3361f3cecfe711544d2d59165e9bdf";
+    readonly "MNT/USD": "4e3037c822d852d79af3ac80e35eb420ee3b870dca49f9344a38ef4773fb0585";
+    readonly "IMX/USD": "941320a8989414a6d2c757c8c6c52b3e7e0b7e4e4c5bb8a3c8e7a0f3e0f0f0f0";
+    readonly "STRK/USD": "6a182399ff70ccf3e06024898942028204125a819e519a335ffa4579e66cd870";
+    readonly "AAVE/USD": "2b9ab1e972a281585084148ba1389800799bd4be63b957507db1349314e47445";
+    readonly "CRV/USD": "a19d04ac696c7a6616d291c7e5d1377cc8be437c327b75adb5dc1bad745fcae8";
+    readonly "MKR/USD": "9375299e31c0deb9c6bc378e6329aab44cb48ec655552a70d4b9050346a30378";
+    readonly "SNX/USD": "39d020f60982ed892abbcd4a06a276a9f9b7bfbce003204c110b6e488f502da3";
+    readonly "COMP/USD": "4a8e42861cabc5ecb50996f92e7cfa2bce3fd0a2423b0c44c9b423fb2bd25478";
+    readonly "LDO/USD": "c63e2a7f37a04e5e614c07238bedb25dcc38927e77a90a4b21a7a2e1d7f0d2e3";
+    readonly "1INCH/USD": "63f341689d98a12ef60a5cff1d7f85c70a9e17bf1575f0e7c0b2512d48b1c8b3";
+    readonly "SUSHI/USD": "26e4f737fde0263a9eea10ae63ac36dcedab2aaf629f1e31a28a28dd0e0d2b0c";
+    readonly "YFI/USD": "425f4b198ab2504936886c1e93511bb6720fbcf2045a4f3c0723bb213846022f";
+    readonly "BAL/USD": "07ad7b4a7662d19a6bc675f6b467172d2f3947fa653ca97555a9b20236406628";
+    readonly "CAKE/USD": "2356af9529a1064d1d2a2e3e4ab6d6e6f6e6f6e6f6e6f6e6f6e6f6e6f6e6f6e6";
+    readonly "GMX/USD": "b962539d0fcb272a494d65ea56f94851c2bcf8823935da05bd628916e2e9edbf";
+    readonly "PENDLE/USD": "9a4df90b25497f66b1afb012467e316e801ca3d839456db028892fe8c70c8016";
+    readonly "JOE/USD": "1e8a156c8a23c1e56f2d9d7f0e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e";
+    readonly "USDC/USD": "eaa020c61cc479712813461ce153894a96a6c00b21ed0cfc2798d1f9a9e9c94a";
+    readonly "USDT/USD": "2b89b9dc8fdf9f34709a5b106b472f0f39bb6ca9ce04b0fd7f2e971688e2e53b";
+    readonly "DAI/USD": "b0948a5e5313200c632b51bb5ca32f6de0d36e9950a942d19751e833f70dabfd";
+    readonly "FRAX/USD": "c3d5d8d6d0c0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0";
+    readonly "BUSD/USD": "5bc91f13e412c07599167bae86f07543f076a638962b8d6017ec19dab4a82814";
+    readonly "TUSD/USD": "433faaa801ecda2c0bbfa8f4e2d85fd4c310e2c1e5f8f8e6e5f5f5f5f5f5f5f5";
+    readonly "LUSD/USD": "d892ae586f4e0fbeee4d64f29ed6e89b1b3e2e2e2e2e2e2e2e2e2e2e2e2e2e2e";
+    readonly "WETH/USD": "ff61491a931112ddf1bd8147cd1b641375f79f5825126d665480874634fd0ace";
+    readonly "WBTC/USD": "c9d8b075a5c69303365ae23633d4e085199bf5c520a3b90fed1322a0342ffc33";
+    readonly "stETH/USD": "846ae1bdb6300b817cee5fdee2a6da192775030db5615b94a465f53bd40850b5";
+    readonly "cbETH/USD": "15ecddd26d49e1a8f1de9376ebebc03916ede873447c1255d2d5891b92ce5717";
+    readonly "rETH/USD": "a0255134973f4fdf2f8f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f";
+    readonly "mETH/USD": "4c9c6f9f0cde13fced52dc1927c8c06a91b1a65ab77b9e1ec1c614963ce90dd4";
+    readonly "wstETH/USD": "6df640f3b8963d8f8358f791f352b8364513f6ab1cca5ed3f1f7b5448980e784";
+    readonly "SHIB/USD": "f0d57deca57b3da2fe63a493f4c25925fdfd8edf834b20f93e1f84dbd1504d4a";
+    readonly "PEPE/USD": "d69731a2e74ac1ce884fc3890f7ee324b6deb66147055249568869ed700882e4";
+    readonly "FLOKI/USD": "6b1381ce7e874dc5410b197ac8348162c0dd6c0d4c9cd6322c28a6f7f4d1a2d2";
+    readonly "BONK/USD": "72b021217ca3fe68922a19aaf990109cb9d84e9ad004b4d2025ad6f529314419";
+    readonly "WIF/USD": "4ca4beeca86f0d164160323817a4e42b10010a724c2217c6ee41b54cd4cc61fc";
+    readonly "AXS/USD": "b0d8f5e3f3a7c0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0";
+    readonly "SAND/USD": "f4040ec3e5b71c241a7e1a9a1e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e";
+    readonly "MANA/USD": "2b15e4bded7f5e5d5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a";
+    readonly "GALA/USD": "e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3e3";
+    readonly "APE/USD": "15add95022ae13563a11992e727c91bdb6b55bc183d9d747436c80a483d8c864";
+    readonly "ENJ/USD": "5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a5a";
+    readonly "FIL/USD": "150ac9b959aee0051e4091f0ef5216d941f590e1c5e7f91cf7635b5c11628c0e";
+    readonly "GRT/USD": "4d1f8dae0d96236fb98e8f47571a70f41c8b8f2f6d6c0e0e0e0e0e0e0e0e0e0e";
+    readonly "RNDR/USD": "ab7347771135fc733f8f38db462ba085ed3309955f42554a14fa13e855ac0e2f";
+    readonly "INJ/USD": "7a5bc1d2b56ad029048cd63964b3ad2776eadf812edc1a43a31406cb54bff592";
+    readonly "AR/USD": "8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c8c";
+    readonly "THETA/USD": "4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a";
+    readonly "PYTH/USD": "0bbf28e9a841a1cc788f6a361b17ca072d0ea3098a1e5df1c3922d06719579ff";
+    readonly "FET/USD": "b49ee9d8ccf9b6e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0";
+    readonly "OCEAN/USD": "2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d";
+    readonly "TAO/USD": "410f41de235f2dbdf41f1a808c1e15f6a9e7d6a7b8c9d0e1f2a3b4c5d6e7f8a9";
+    readonly "FTT/USD": "6c75e52531ec5fd3ef253f6062956a8508a2f03fa0a209fb7dbc0d0f3d6f6f6f";
+    readonly "CRO/USD": "b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7b7";
+    readonly "OKB/USD": "23d7315113f5b1d3ba7a83604c44b94d79f4fd69af77f804fc7f920a6dc65744";
+    readonly "EUR/USD": "a995d00bb36a63cef7fd2c287dc105fc8f3d93779f062f09551b0af3e81ec30b";
+    readonly "GBP/USD": "84c2dde9633d93d1bcad84e7dc41c9d56578b7ec52fabedc1f335d673df0a7c1";
+    readonly "JPY/USD": "ef2c98c804ba503c6a707e38be4dfbb16683775f195b091252bf24693042fd52";
+    readonly "AUD/USD": "67a6f93030f4217f2e8f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f";
+    readonly "CAD/USD": "9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a9a";
+    readonly "XAU/USD": "765d2ba906dbc32ca17cc11f5310a89e9ee1f6420508c63861f2f8ba4ee34bb2";
+    readonly "XAG/USD": "f2fb02c32b055c805e7238d628e5e9dadef274376114eb1f012337cabe93871e";
+    readonly "WTI/USD": "c9c8e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9e9";
+    readonly "BRENT/USD": "d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8d8";
+    readonly "AAPL/USD": "49f6b65cb1de6b10eaf75e7c03ca029c306d0357e91b5311b175084a5ad55688";
+    readonly "NVDA/USD": "b1073854ed24cbc755dc527418f52b7d271f6cc967bbf8d8129112b18860a593";
+    readonly "TSLA/USD": "16dad506d7db8da01c87581c87ca897a012a153557d4d578c3b9c9e1bc0632f1";
+    readonly "GOOGL/USD": "b7e3904c08ddd9c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0";
+    readonly "AMZN/USD": "c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6c6";
+    readonly "MSFT/USD": "d0ca23c1cc005e004ccf1db5bf76aeb6a49218f43dac3d4b275e92de12ea4b77";
+    readonly "META/USD": "a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4a4";
+    readonly "COIN/USD": "9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b9b";
+    readonly "SPY/USD": "19e09bb805456ada3979a7d1cbb4b6d63babc3a0f8e8a9b3c4d5e6f7a8b9c0d1";
+    readonly "QQQ/USD": "2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e";
+};
+declare const PYTH_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly name: "id";
+        readonly type: "bytes32";
+    }];
+    readonly name: "getPrice";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly name: "price";
+            readonly type: "int64";
+        }, {
+            readonly name: "conf";
+            readonly type: "uint64";
+        }, {
+            readonly name: "expo";
+            readonly type: "int32";
+        }, {
+            readonly name: "publishTime";
+            readonly type: "uint256";
+        }];
+        readonly name: "";
+        readonly type: "tuple";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "id";
+        readonly type: "bytes32";
+    }];
+    readonly name: "getPriceNoOlderThan";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly name: "price";
+            readonly type: "int64";
+        }, {
+            readonly name: "conf";
+            readonly type: "uint64";
+        }, {
+            readonly name: "expo";
+            readonly type: "int32";
+        }, {
+            readonly name: "publishTime";
+            readonly type: "uint256";
+        }];
+        readonly name: "";
+        readonly type: "tuple";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "id";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "age";
+        readonly type: "uint256";
+    }];
+    readonly name: "getPriceNoOlderThan";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly name: "price";
+            readonly type: "int64";
+        }, {
+            readonly name: "conf";
+            readonly type: "uint64";
+        }, {
+            readonly name: "expo";
+            readonly type: "int32";
+        }, {
+            readonly name: "publishTime";
+            readonly type: "uint256";
+        }];
+        readonly name: "";
+        readonly type: "tuple";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "id";
+        readonly type: "bytes32";
+    }];
+    readonly name: "getPriceUnsafe";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly name: "price";
+            readonly type: "int64";
+        }, {
+            readonly name: "conf";
+            readonly type: "uint64";
+        }, {
+            readonly name: "expo";
+            readonly type: "int32";
+        }, {
+            readonly name: "publishTime";
+            readonly type: "uint256";
+        }];
+        readonly name: "";
+        readonly type: "tuple";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "id";
+        readonly type: "bytes32";
+    }];
+    readonly name: "getEmaPrice";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly name: "price";
+            readonly type: "int64";
+        }, {
+            readonly name: "conf";
+            readonly type: "uint64";
+        }, {
+            readonly name: "expo";
+            readonly type: "int32";
+        }, {
+            readonly name: "publishTime";
+            readonly type: "uint256";
+        }];
+        readonly name: "";
+        readonly type: "tuple";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "updateData";
+        readonly type: "bytes[]";
+    }];
+    readonly name: "updatePriceFeeds";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "updateData";
+        readonly type: "bytes[]";
+    }];
+    readonly name: "getUpdateFee";
+    readonly outputs: readonly [{
+        readonly name: "feeAmount";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "id";
+        readonly type: "bytes32";
+    }];
+    readonly name: "priceFeedExists";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "updateData";
+        readonly type: "bytes[]";
+    }, {
+        readonly name: "priceIds";
+        readonly type: "bytes32[]";
+    }, {
+        readonly name: "minPublishTime";
+        readonly type: "uint64";
+    }, {
+        readonly name: "maxPublishTime";
+        readonly type: "uint64";
+    }];
+    readonly name: "parsePriceFeedUpdates";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly name: "id";
+            readonly type: "bytes32";
+        }, {
+            readonly components: readonly [{
+                readonly name: "price";
+                readonly type: "int64";
+            }, {
+                readonly name: "conf";
+                readonly type: "uint64";
+            }, {
+                readonly name: "expo";
+                readonly type: "int32";
+            }, {
+                readonly name: "publishTime";
+                readonly type: "uint256";
+            }];
+            readonly name: "price";
+            readonly type: "tuple";
+        }, {
+            readonly components: readonly [{
+                readonly name: "price";
+                readonly type: "int64";
+            }, {
+                readonly name: "conf";
+                readonly type: "uint64";
+            }, {
+                readonly name: "expo";
+                readonly type: "int32";
+            }, {
+                readonly name: "publishTime";
+                readonly type: "uint256";
+            }];
+            readonly name: "emaPrice";
+            readonly type: "tuple";
+        }];
+        readonly name: "";
+        readonly type: "tuple[]";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}];
+interface PythPriceData {
+    price: bigint;
+    conf: bigint;
+    expo: number;
+    publishTime: bigint;
+}
+interface PythPriceResponse {
+    priceFeedId: string;
+    pair: string;
+    price: string;
+    confidence: string;
+    exponent: number;
+    publishTime: number;
+    formattedPrice: string;
+}
+interface PythTokenPriceResponse {
+    tokenAddress: string;
+    tokenSymbol: string;
+    pair: string;
+    priceFeedId: string;
+    priceUsd: string;
+    confidence: string;
+    exponent: number;
+    publishTime: number;
+    lastUpdated: string;
+}
+declare const TOKEN_ADDRESS_TO_PRICE_FEED: Record<string, {
+    pair: string;
+    feedId: string;
+}>;
+declare function isTokenAddress(input: string): boolean;
+declare function resolvePriceFeedInput(input: string): {
+    pair: string;
+    feedId: string;
+} | null;
+
+declare const index$c_HERMES_ENDPOINT: typeof HERMES_ENDPOINT;
+declare const index$c_PYTH_ABI: typeof PYTH_ABI;
+declare const index$c_PYTH_CONTRACT: typeof PYTH_CONTRACT;
+declare const index$c_PYTH_PRICE_FEED_IDS: typeof PYTH_PRICE_FEED_IDS;
+type index$c_PythPriceData = PythPriceData;
+type index$c_PythPriceResponse = PythPriceResponse;
+type index$c_PythTokenPriceResponse = PythTokenPriceResponse;
+declare const index$c_TOKEN_ADDRESS_TO_PRICE_FEED: typeof TOKEN_ADDRESS_TO_PRICE_FEED;
+declare const index$c_isTokenAddress: typeof isTokenAddress;
+declare const index$c_resolvePriceFeedInput: typeof resolvePriceFeedInput;
+declare namespace index$c {
+  export { index$c_HERMES_ENDPOINT as HERMES_ENDPOINT, index$c_PYTH_ABI as PYTH_ABI, index$c_PYTH_CONTRACT as PYTH_CONTRACT, index$c_PYTH_PRICE_FEED_IDS as PYTH_PRICE_FEED_IDS, type index$c_PythPriceData as PythPriceData, type index$c_PythPriceResponse as PythPriceResponse, type index$c_PythTokenPriceResponse as PythTokenPriceResponse, index$c_TOKEN_ADDRESS_TO_PRICE_FEED as TOKEN_ADDRESS_TO_PRICE_FEED, index$c_isTokenAddress as isTokenAddress, index$c_resolvePriceFeedInput as resolvePriceFeedInput };
+}
+
 interface OpenPositionResult$1 {
     positionId: bigint;
     txHash: Hex;
@@ -201,12 +572,12 @@ declare const FEE_TIERS$1: {
 };
 declare const DEFAULT_POOL_FEE: 3000;
 
-declare const index$9_DEFAULT_POOL_FEE: typeof DEFAULT_POOL_FEE;
-declare const index$9_FACTORY_ADDRESS: typeof FACTORY_ADDRESS;
-declare const index$9_QUOTER_V2_ADDRESS: typeof QUOTER_V2_ADDRESS;
-declare const index$9_SWAP_ROUTER_ADDRESS: typeof SWAP_ROUTER_ADDRESS;
-declare namespace index$9 {
-  export { index$9_DEFAULT_POOL_FEE as DEFAULT_POOL_FEE, index$9_FACTORY_ADDRESS as FACTORY_ADDRESS, FEE_TIERS$1 as FEE_TIERS, NATIVE_TOKEN_ADDRESS$3 as NATIVE_TOKEN_ADDRESS, index$9_QUOTER_V2_ADDRESS as QUOTER_V2_ADDRESS, index$9_SWAP_ROUTER_ADDRESS as SWAP_ROUTER_ADDRESS, WMNT_ADDRESS$1 as WMNT_ADDRESS };
+declare const index$b_DEFAULT_POOL_FEE: typeof DEFAULT_POOL_FEE;
+declare const index$b_FACTORY_ADDRESS: typeof FACTORY_ADDRESS;
+declare const index$b_QUOTER_V2_ADDRESS: typeof QUOTER_V2_ADDRESS;
+declare const index$b_SWAP_ROUTER_ADDRESS: typeof SWAP_ROUTER_ADDRESS;
+declare namespace index$b {
+  export { index$b_DEFAULT_POOL_FEE as DEFAULT_POOL_FEE, index$b_FACTORY_ADDRESS as FACTORY_ADDRESS, FEE_TIERS$1 as FEE_TIERS, NATIVE_TOKEN_ADDRESS$3 as NATIVE_TOKEN_ADDRESS, index$b_QUOTER_V2_ADDRESS as QUOTER_V2_ADDRESS, index$b_SWAP_ROUTER_ADDRESS as SWAP_ROUTER_ADDRESS, WMNT_ADDRESS$1 as WMNT_ADDRESS };
 }
 
 interface UniswapQuoteResult {
@@ -453,13 +824,13 @@ declare const METH_ABI: readonly [{
     readonly type: "function";
 }];
 
-declare const index$8_METH_ABI: typeof METH_ABI;
-declare const index$8_METH_TOKEN: typeof METH_TOKEN;
-declare const index$8_NATIVE_MNT_ADDRESS: typeof NATIVE_MNT_ADDRESS;
-declare const index$8_WETH_TOKEN: typeof WETH_TOKEN;
-declare const index$8_WMNT_TOKEN: typeof WMNT_TOKEN;
-declare namespace index$8 {
-  export { index$8_METH_ABI as METH_ABI, index$8_METH_TOKEN as METH_TOKEN, index$8_NATIVE_MNT_ADDRESS as NATIVE_MNT_ADDRESS, index$8_WETH_TOKEN as WETH_TOKEN, index$8_WMNT_TOKEN as WMNT_TOKEN };
+declare const index$a_METH_ABI: typeof METH_ABI;
+declare const index$a_METH_TOKEN: typeof METH_TOKEN;
+declare const index$a_NATIVE_MNT_ADDRESS: typeof NATIVE_MNT_ADDRESS;
+declare const index$a_WETH_TOKEN: typeof WETH_TOKEN;
+declare const index$a_WMNT_TOKEN: typeof WMNT_TOKEN;
+declare namespace index$a {
+  export { index$a_METH_ABI as METH_ABI, index$a_METH_TOKEN as METH_TOKEN, index$a_NATIVE_MNT_ADDRESS as NATIVE_MNT_ADDRESS, index$a_WETH_TOKEN as WETH_TOKEN, index$a_WMNT_TOKEN as WMNT_TOKEN };
 }
 
 interface MethPosition {
@@ -563,45 +934,653 @@ interface PikePerpsMarketData {
 declare function pikeperpsGetMarketData(agent: MNTAgentKit, tokenAddress: Address, limit?: number): Promise<PikePerpsMarketData>;
 
 /**
- * Platform Configuration & Validation
- *
- * Validates APP_ID with Mantle platform API
+ * Get price data from Pyth Network for a specific price feed
+ * @param agent - MNTAgentKit instance
+ * @param input - Token address, price feed ID (hex string), or pair name like "ETH/USD"
+ * @returns Price data with formatted price
  */
-/** Project configuration from platform */
-interface ProjectConfig {
-    appId: string;
+declare function pythGetPrice(agent: MNTAgentKit, input: string): Promise<PythPriceResponse>;
+/**
+ * Get EMA (Exponential Moving Average) price from Pyth
+ * @param agent - MNTAgentKit instance
+ * @param input - Token address, price feed ID, or pair name
+ * @returns EMA price data
+ */
+declare function pythGetEmaPrice(agent: MNTAgentKit, input: string): Promise<PythPriceResponse>;
+/**
+ * Get price for a token by its contract address
+ * @param agent - MNTAgentKit instance
+ * @param tokenAddress - Token contract address on Mantle (e.g., "0x09Bc4E0D10C81b3a3766c49F0f98a8aaa7adA8D2" for USDC)
+ * @returns Token price details including address, symbol, and USD price
+ * @example
+ * const price = await pythGetTokenPrice(agent, "0x09Bc4E0D10C81b3a3766c49F0f98a8aaa7adA8D2");
+ * // Returns: { tokenAddress: "0x09Bc...", tokenSymbol: "USDC", priceUsd: "1.00", ... }
+ */
+declare function pythGetTokenPrice(agent: MNTAgentKit, tokenAddress: string): Promise<PythTokenPriceResponse>;
+
+/**
+ * Get multiple prices from Pyth in a single call
+ * @param agent - MNTAgentKit instance
+ * @param inputs - Array of token addresses, pair names, or price feed IDs
+ * @returns Array of price responses
+ */
+declare function pythGetMultiplePrices(agent: MNTAgentKit, inputs: string[]): Promise<PythPriceResponse[]>;
+/**
+ * Get all supported Pyth price feed IDs
+ * @returns Object mapping pair names to price feed IDs
+ */
+declare function pythGetSupportedPriceFeeds(): Record<string, string>;
+/**
+ * Get all supported token addresses that can be used for price lookups
+ * @returns Object mapping token addresses to their pair names
+ */
+declare function pythGetSupportedTokenAddresses(): Record<string, string>;
+/**
+ * Check if a price feed exists on Pyth
+ * @param agent - MNTAgentKit instance
+ * @param input - Token address, price feed ID, or pair name
+ * @returns Boolean indicating if feed exists
+ */
+declare function pythPriceFeedExists(agent: MNTAgentKit, input: string): Promise<boolean>;
+
+declare const ERC20_ABI: readonly [{
+    readonly inputs: readonly [];
+    readonly name: "name";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "symbol";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "decimals";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "totalSupply";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly name: "balanceOf";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "transfer";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+type TokenType = "standard" | "rwa";
+interface TokenConfig {
     name: string;
-    payTo: string;
-    network: string;
-    status: string;
+    symbol: string;
+    supply: string;
+    decimals?: number;
+    tokenType?: TokenType;
+    assetType?: string;
+    assetId?: string;
+}
+interface TokenDeploymentResult {
+    tokenAddress: string;
+    txHash: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    totalSupply: string;
+    mintedTo: string;
+    tokenType: TokenType;
+    assetType?: string;
+    assetId?: string;
+}
+interface TokenInfo {
+    address: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    totalSupply: string;
+    balance?: string;
+}
+
+declare const index$9_ERC20_ABI: typeof ERC20_ABI;
+type index$9_TokenConfig = TokenConfig;
+type index$9_TokenDeploymentResult = TokenDeploymentResult;
+type index$9_TokenInfo = TokenInfo;
+type index$9_TokenType = TokenType;
+declare namespace index$9 {
+  export { index$9_ERC20_ABI as ERC20_ABI, type index$9_TokenConfig as TokenConfig, type index$9_TokenDeploymentResult as TokenDeploymentResult, type index$9_TokenInfo as TokenInfo, type index$9_TokenType as TokenType };
 }
+
 /**
- * Initialize platform validation
- *
- * Reads APP_ID from environment and validates with platform API.
- * Uses singleton pattern - multiple calls return same promise.
- *
- * @returns Project configuration from platform
- * @throws Error if APP_ID is not set or validation fails
+ * Deploy a new token (ERC20 or RWA) - mints supply to caller's address
+ * @param agent - MNTAgentKit instance
+ * @param name - Token name
+ * @param symbol - Token symbol
+ * @param supply - Total supply (human readable, e.g., "1000000")
+ * @param tokenType - "standard" or "rwa"
+ * @param assetType - For RWA: type of underlying asset
+ * @param assetId - For RWA: external asset identifier
  */
-declare function initializePlatform(): Promise<ProjectConfig>;
+declare function deployToken(agent: MNTAgentKit, name: string, symbol: string, supply: string, tokenType?: TokenType, assetType?: string, assetId?: string): Promise<TokenDeploymentResult>;
 /**
- * Get cached project configuration
- *
- * @throws Error if platform not initialized
+ * Deploy a standard ERC20 token
  */
-declare function getProjectConfig(): ProjectConfig;
+declare function deployStandardToken(agent: MNTAgentKit, name: string, symbol: string, supply: string): Promise<TokenDeploymentResult>;
+/**
+ * Deploy an RWA (Real World Asset) token
+ * @param agent - MNTAgentKit instance
+ * @param name - Token name (e.g., "Manhattan Property Token")
+ * @param symbol - Token symbol (e.g., "MPT")
+ * @param supply - Total supply representing fractional ownership
+ * @param assetType - Asset category (e.g., "Real Estate", "Commodities", "Securities", "Art")
+ * @param assetId - External reference ID for the underlying asset
+ */
+declare function deployRWAToken(agent: MNTAgentKit, name: string, symbol: string, supply: string, assetType: string, assetId?: string): Promise<TokenDeploymentResult>;
 
-declare class MNTAgentKit {
-    account: PrivateKeyAccount;
-    client: WalletClient<Transport, Chain, PrivateKeyAccount> & PublicActions & Erc7811Actions;
-    chain: "testnet" | "mainnet";
-    demo: boolean;
-    projectConfig?: ProjectConfig;
-    constructor(privateKey: Address$1, chain: "mainnet" | "testnet" | "testnet-demo");
-    /**
-     * Initialize the agent with platform validation
-     *
+/**
+ * Get token information
+ */
+declare function getTokenInfo(agent: MNTAgentKit, tokenAddress: Address, holder?: Address): Promise<TokenInfo>;
+/**
+ * Get token balance
+ */
+declare function getTokenBalance(agent: MNTAgentKit, tokenAddress: Address, holder?: Address): Promise<string>;
+
+/**
+ * Transfer tokens
+ */
+declare function transferToken(agent: MNTAgentKit, tokenAddress: Address, to: Address, amount: string): Promise<Hex>;
+
+declare const ERC721_ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly name: "name";
+        readonly type: "string";
+    }, {
+        readonly name: "symbol";
+        readonly type: "string";
+    }, {
+        readonly name: "baseURI";
+        readonly type: "string";
+    }, {
+        readonly name: "maxSupply";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "name";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "symbol";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "totalSupply";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly name: "tokenURI";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly name: "ownerOf";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }];
+    readonly name: "balanceOf";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly name: "getApproved";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "operator";
+        readonly type: "address";
+    }];
+    readonly name: "isApprovedForAll";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "to";
+        readonly type: "address";
+    }];
+    readonly name: "mint";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "quantity";
+        readonly type: "uint256";
+    }];
+    readonly name: "batchMint";
+    readonly outputs: readonly [{
+        readonly name: "startTokenId";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly name: "approve";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "operator";
+        readonly type: "address";
+    }, {
+        readonly name: "approved";
+        readonly type: "bool";
+    }];
+    readonly name: "setApprovalForAll";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly name: "transferFrom";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly name: "safeTransferFrom";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly name: "safeTransferFrom";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly name: "Transfer";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "approved";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "tokenId";
+        readonly type: "uint256";
+    }];
+    readonly name: "Approval";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly name: "operator";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly name: "approved";
+        readonly type: "bool";
+    }];
+    readonly name: "ApprovalForAll";
+    readonly type: "event";
+}];
+interface NFTCollectionConfig {
+    name: string;
+    symbol: string;
+    baseURI: string;
+    maxSupply?: number;
+    description?: string;
+}
+interface NFTCollectionDeploymentResult {
+    collectionAddress: string;
+    txHash: string;
+    name: string;
+    symbol: string;
+    baseURI: string;
+    maxSupply: number;
+    deployer: string;
+}
+interface NFTMintResult {
+    txHash: string;
+    tokenId: string;
+    collectionAddress: string;
+    to: string;
+}
+interface NFTCollectionInfo {
+    address: string;
+    name: string;
+    symbol: string;
+    totalSupply: string;
+    balanceOf?: string;
+}
+interface NFTTokenInfo {
+    collectionAddress: string;
+    tokenId: string;
+    owner: string;
+    tokenURI: string;
+}
+
+declare const index$8_ERC721_ABI: typeof ERC721_ABI;
+type index$8_NFTCollectionConfig = NFTCollectionConfig;
+type index$8_NFTCollectionDeploymentResult = NFTCollectionDeploymentResult;
+type index$8_NFTCollectionInfo = NFTCollectionInfo;
+type index$8_NFTMintResult = NFTMintResult;
+type index$8_NFTTokenInfo = NFTTokenInfo;
+declare namespace index$8 {
+  export { index$8_ERC721_ABI as ERC721_ABI, type index$8_NFTCollectionConfig as NFTCollectionConfig, type index$8_NFTCollectionDeploymentResult as NFTCollectionDeploymentResult, type index$8_NFTCollectionInfo as NFTCollectionInfo, type index$8_NFTMintResult as NFTMintResult, type index$8_NFTTokenInfo as NFTTokenInfo };
+}
+
+/**
+ * Deploy a new ERC721 NFT collection on Mantle Network
+ * @param agent - MNTAgentKit instance
+ * @param config - NFT collection configuration
+ * @returns Collection deployment result with contract address
+ */
+declare function deployNFTCollection(agent: MNTAgentKit, config: NFTCollectionConfig): Promise<NFTCollectionDeploymentResult>;
+/**
+ * Deploy an NFT collection with preset configurations
+ * @param agent - MNTAgentKit instance
+ * @param preset - Preset type: "pfp" (10000), "art" (1000), "membership" (100)
+ * @param name - Collection name
+ * @param symbol - Collection symbol
+ * @param baseURI - Base URI for metadata
+ * @returns Collection deployment result
+ */
+declare function deployNFTCollectionWithPreset(agent: MNTAgentKit, preset: "pfp" | "art" | "membership" | "unlimited", name: string, symbol: string, baseURI: string): Promise<NFTCollectionDeploymentResult>;
+
+/**
+ * Mint a single NFT from a collection
+ * @param agent - MNTAgentKit instance
+ * @param collectionAddress - NFT collection contract address
+ * @param to - Recipient address (defaults to agent address)
+ * @returns Mint result with token ID
+ */
+declare function mintNFT(agent: MNTAgentKit, collectionAddress: Address, to?: Address): Promise<NFTMintResult>;
+/**
+ * Batch mint multiple NFTs from a collection
+ * @param agent - MNTAgentKit instance
+ * @param collectionAddress - NFT collection contract address
+ * @param to - Recipient address
+ * @param quantity - Number of NFTs to mint
+ * @returns Mint result with starting token ID
+ */
+declare function batchMintNFT(agent: MNTAgentKit, collectionAddress: Address, to: Address, quantity: number): Promise<{
+    txHash: Hex;
+    startTokenId: string;
+    quantity: number;
+}>;
+
+/**
+ * Get information about an NFT collection
+ * @param agent - MNTAgentKit instance
+ * @param collectionAddress - NFT collection contract address
+ * @param holderAddress - Optional address to get balance for
+ * @returns Collection information
+ */
+declare function getNFTCollectionInfo(agent: MNTAgentKit, collectionAddress: Address, holderAddress?: Address): Promise<NFTCollectionInfo>;
+/**
+ * Get information about a specific NFT token
+ * @param agent - MNTAgentKit instance
+ * @param collectionAddress - NFT collection contract address
+ * @param tokenId - Token ID
+ * @returns Token information
+ */
+declare function getNFTTokenInfo(agent: MNTAgentKit, collectionAddress: Address, tokenId: string): Promise<NFTTokenInfo>;
+/**
+ * Get NFT balance for an address
+ * @param agent - MNTAgentKit instance
+ * @param collectionAddress - NFT collection contract address
+ * @param holderAddress - Address to check balance for (defaults to agent address)
+ * @returns Balance as string
+ */
+declare function getNFTBalance(agent: MNTAgentKit, collectionAddress: Address, holderAddress?: Address): Promise<string>;
+/**
+ * Check if an address owns a specific NFT
+ * @param agent - MNTAgentKit instance
+ * @param collectionAddress - NFT collection contract address
+ * @param tokenId - Token ID to check
+ * @param ownerAddress - Address to verify ownership
+ * @returns Boolean indicating ownership
+ */
+declare function isNFTOwner(agent: MNTAgentKit, collectionAddress: Address, tokenId: string, ownerAddress?: Address): Promise<boolean>;
+
+/**
+ * Transfer an NFT to another address
+ * @param agent - MNTAgentKit instance
+ * @param collectionAddress - NFT collection contract address
+ * @param to - Recipient address
+ * @param tokenId - Token ID to transfer
+ * @returns Transaction hash
+ */
+declare function transferNFT(agent: MNTAgentKit, collectionAddress: Address, to: Address, tokenId: string): Promise<Hex>;
+/**
+ * Safe transfer an NFT (checks if recipient can receive)
+ * @param agent - MNTAgentKit instance
+ * @param collectionAddress - NFT collection contract address
+ * @param to - Recipient address
+ * @param tokenId - Token ID to transfer
+ * @returns Transaction hash
+ */
+declare function safeTransferNFT(agent: MNTAgentKit, collectionAddress: Address, to: Address, tokenId: string): Promise<Hex>;
+/**
+ * Approve an address to transfer a specific NFT
+ * @param agent - MNTAgentKit instance
+ * @param collectionAddress - NFT collection contract address
+ * @param approved - Address to approve
+ * @param tokenId - Token ID to approve
+ * @returns Transaction hash
+ */
+declare function approveNFT(agent: MNTAgentKit, collectionAddress: Address, approved: Address, tokenId: string): Promise<Hex>;
+/**
+ * Set approval for all NFTs in a collection
+ * @param agent - MNTAgentKit instance
+ * @param collectionAddress - NFT collection contract address
+ * @param operator - Operator address
+ * @param approved - Whether to approve or revoke
+ * @returns Transaction hash
+ */
+declare function setApprovalForAllNFT(agent: MNTAgentKit, collectionAddress: Address, operator: Address, approved: boolean): Promise<Hex>;
+
+/**
+ * Platform Configuration & Validation
+ *
+ * Validates APP_ID with Mantle platform API
+ */
+/** Project configuration from platform */
+interface ProjectConfig {
+    appId: string;
+    name: string;
+    payTo: string;
+    network: string;
+    status: string;
+}
+/**
+ * Initialize platform validation
+ *
+ * Reads APP_ID from environment and validates with platform API.
+ * Uses singleton pattern - multiple calls return same promise.
+ *
+ * @returns Project configuration from platform
+ * @throws Error if APP_ID is not set or validation fails
+ */
+declare function initializePlatform(): Promise<ProjectConfig>;
+/**
+ * Get cached project configuration
+ *
+ * @throws Error if platform not initialized
+ */
+declare function getProjectConfig(): ProjectConfig;
+
+declare class MNTAgentKit {
+    account: PrivateKeyAccount;
+    client: WalletClient<Transport, Chain, PrivateKeyAccount> & PublicActions & Erc7811Actions;
+    chain: "testnet" | "mainnet";
+    demo: boolean;
+    projectConfig?: ProjectConfig;
+    constructor(privateKey: Address$1, chain: "mainnet" | "testnet" | "testnet-demo");
+    /**
+     * Initialize the agent with platform validation
+     *
      * Validates APP_ID with the platform API.
      * Must be called after creating the agent instance.
      *
@@ -730,6 +1709,208 @@ declare class MNTAgentKit {
      * @returns Market data with price and recent trades
      */
     pikeperpsGetMarketData(tokenAddress: Address$1, limit?: number): Promise<PikePerpsMarketData>;
+    /**
+     * Get real-time price from Pyth Network
+     * Accepts token address, pair name, or price feed ID
+     * @param input - Token address (e.g., "0x09Bc4E0D10C81b3a3766c49F0f98a8aaa7adA8D2" for USDC),
+     *                pair name (e.g., "ETH/USD"), or price feed ID (hex string)
+     * @returns Price data with formatted price
+     * @example
+     * // Using pair name
+     * await agent.pythGetPrice("ETH/USD");
+     * // Using token address (USDC on Mantle)
+     * await agent.pythGetPrice("0x09Bc4E0D10C81b3a3766c49F0f98a8aaa7adA8D2");
+     */
+    pythGetPrice(input: string): Promise<PythPriceResponse>;
+    /**
+     * Get EMA (Exponential Moving Average) price from Pyth
+     * Accepts token address, pair name, or price feed ID
+     * @param input - Token address, pair name, or price feed ID
+     * @returns EMA price data
+     */
+    pythGetEmaPrice(input: string): Promise<PythPriceResponse>;
+    /**
+     * Get price for a token by its contract address
+     * Pass any supported token address and get the USD price with full details
+     * @param tokenAddress - Token contract address on Mantle
+     * @returns Token price details including symbol, USD price, and timestamp
+     * @example
+     * const price = await agent.pythGetTokenPrice("0x09Bc4E0D10C81b3a3766c49F0f98a8aaa7adA8D2");
+     * // Returns: {
+     * //   tokenAddress: "0x09Bc4E0D10C81b3a3766c49F0f98a8aaa7adA8D2",
+     * //   tokenSymbol: "USDC",
+     * //   pair: "USDC/USD",
+     * //   priceUsd: "1.00",
+     * //   lastUpdated: "2024-01-08T12:00:00.000Z"
+     * // }
+     */
+    pythGetTokenPrice(tokenAddress: string): Promise<PythTokenPriceResponse>;
+    /**
+     * Get multiple prices from Pyth in a single call
+     * Accepts token addresses, pair names, or price feed IDs
+     * @param inputs - Array of token addresses, pair names, or price feed IDs
+     * @returns Array of price responses
+     * @example
+     * await agent.pythGetMultiplePrices([
+     *   "ETH/USD",                                           // pair name
+     *   "0x09Bc4E0D10C81b3a3766c49F0f98a8aaa7adA8D2",       // USDC address
+     *   "0xcDA86A272531e8640cD7F1a92c01839911B90bb0",       // mETH address
+     * ]);
+     */
+    pythGetMultiplePrices(inputs: string[]): Promise<PythPriceResponse[]>;
+    /**
+     * Get all supported Pyth price feed IDs
+     * @returns Object mapping pair names to price feed IDs
+     */
+    pythGetSupportedPriceFeeds(): Record<string, string>;
+    /**
+     * Get all supported token addresses for Pyth price lookups on Mantle
+     * @returns Object mapping token addresses to their pair names
+     * @example
+     * const addresses = agent.pythGetSupportedTokenAddresses();
+     * // Returns: { "0x09Bc4E0D10C81b3a3766c49F0f98a8aaa7adA8D2": "USDC/USD", ... }
+     */
+    pythGetSupportedTokenAddresses(): Record<string, string>;
+    /**
+     * Check if a price feed exists on Pyth
+     * Accepts token address, pair name, or price feed ID
+     * @param input - Token address, pair name, or price feed ID
+     * @returns Boolean indicating if feed exists
+     */
+    pythPriceFeedExists(input: string): Promise<boolean>;
+    /**
+     * Deploy a new token (ERC20 or RWA) - supply minted to your address
+     * @param name - Token name
+     * @param symbol - Token symbol
+     * @param supply - Total supply (human readable, e.g., "1000000")
+     * @param tokenType - "standard" or "rwa"
+     * @param assetType - For RWA: asset category
+     * @param assetId - For RWA: external asset ID
+     */
+    deployToken(name: string, symbol: string, supply: string, tokenType?: TokenType, assetType?: string, assetId?: string): Promise<TokenDeploymentResult>;
+    /**
+     * Deploy a standard ERC20 token
+     * @param name - Token name
+     * @param symbol - Token symbol
+     * @param supply - Total supply (e.g., "1000000" for 1M tokens)
+     */
+    deployStandardToken(name: string, symbol: string, supply: string): Promise<TokenDeploymentResult>;
+    /**
+     * Deploy an RWA (Real World Asset) token
+     * @param name - Token name (e.g., "Manhattan Property Token")
+     * @param symbol - Token symbol (e.g., "MPT")
+     * @param supply - Total supply for fractional ownership
+     * @param assetType - Asset category: "Real Estate", "Commodities", "Securities", "Art"
+     * @param assetId - External reference ID for the underlying asset
+     */
+    deployRWAToken(name: string, symbol: string, supply: string, assetType: string, assetId?: string): Promise<TokenDeploymentResult>;
+    /**
+     * Get token information
+     */
+    getTokenInfo(tokenAddress: Address$1, holder?: Address$1): Promise<TokenInfo>;
+    /**
+     * Get token balance
+     */
+    getTokenBalance(tokenAddress: Address$1, holder?: Address$1): Promise<string>;
+    /**
+     * Transfer tokens
+     */
+    transferToken(tokenAddress: Address$1, to: Address$1, amount: string): Promise<`0x${string}`>;
+    /**
+     * Deploy a new ERC721 NFT collection on Mantle Network
+     * @param config - Collection configuration (name, symbol, baseURI, maxSupply)
+     * @returns Collection deployment result with contract address
+     */
+    deployNFTCollection(config: NFTCollectionConfig): Promise<NFTCollectionDeploymentResult>;
+    /**
+     * Deploy an NFT collection with preset configurations
+     * @param preset - Preset type: "pfp" (10000), "art" (1000), "membership" (100), "unlimited"
+     * @param name - Collection name
+     * @param symbol - Collection symbol
+     * @param baseURI - Base URI for metadata
+     * @returns Collection deployment result
+     */
+    deployNFTCollectionWithPreset(preset: "pfp" | "art" | "membership" | "unlimited", name: string, symbol: string, baseURI: string): Promise<NFTCollectionDeploymentResult>;
+    /**
+     * Mint a single NFT from a collection
+     * @param collectionAddress - NFT collection contract address
+     * @param to - Recipient address (defaults to agent address)
+     * @returns Mint result with token ID
+     */
+    mintNFT(collectionAddress: Address$1, to?: Address$1): Promise<NFTMintResult>;
+    /**
+     * Batch mint multiple NFTs from a collection
+     * @param collectionAddress - NFT collection contract address
+     * @param to - Recipient address
+     * @param quantity - Number of NFTs to mint
+     * @returns Mint result with starting token ID
+     */
+    batchMintNFT(collectionAddress: Address$1, to: Address$1, quantity: number): Promise<{
+        txHash: viem.Hex;
+        startTokenId: string;
+        quantity: number;
+    }>;
+    /**
+     * Get information about an NFT collection
+     * @param collectionAddress - NFT collection contract address
+     * @param holderAddress - Optional address to get balance for
+     * @returns Collection information
+     */
+    getNFTCollectionInfo(collectionAddress: Address$1, holderAddress?: Address$1): Promise<NFTCollectionInfo>;
+    /**
+     * Get information about a specific NFT token
+     * @param collectionAddress - NFT collection contract address
+     * @param tokenId - Token ID
+     * @returns Token information
+     */
+    getNFTTokenInfo(collectionAddress: Address$1, tokenId: string): Promise<NFTTokenInfo>;
+    /**
+     * Get NFT balance for an address
+     * @param collectionAddress - NFT collection contract address
+     * @param holderAddress - Address to check (defaults to agent address)
+     * @returns Balance as string
+     */
+    getNFTBalance(collectionAddress: Address$1, holderAddress?: Address$1): Promise<string>;
+    /**
+     * Check if an address owns a specific NFT
+     * @param collectionAddress - NFT collection contract address
+     * @param tokenId - Token ID to check
+     * @param ownerAddress - Address to verify ownership
+     * @returns Boolean indicating ownership
+     */
+    isNFTOwner(collectionAddress: Address$1, tokenId: string, ownerAddress?: Address$1): Promise<boolean>;
+    /**
+     * Transfer an NFT to another address
+     * @param collectionAddress - NFT collection contract address
+     * @param to - Recipient address
+     * @param tokenId - Token ID to transfer
+     * @returns Transaction hash
+     */
+    transferNFT(collectionAddress: Address$1, to: Address$1, tokenId: string): Promise<`0x${string}`>;
+    /**
+     * Safe transfer an NFT (checks if recipient can receive)
+     * @param collectionAddress - NFT collection contract address
+     * @param to - Recipient address
+     * @param tokenId - Token ID to transfer
+     * @returns Transaction hash
+     */
+    safeTransferNFT(collectionAddress: Address$1, to: Address$1, tokenId: string): Promise<`0x${string}`>;
+    /**
+     * Approve an address to transfer a specific NFT
+     * @param collectionAddress - NFT collection contract address
+     * @param approved - Address to approve
+     * @param tokenId - Token ID to approve
+     * @returns Transaction hash
+     */
+    approveNFT(collectionAddress: Address$1, approved: Address$1, tokenId: string): Promise<`0x${string}`>;
+    /**
+     * Set approval for all NFTs in a collection
+     * @param collectionAddress - NFT collection contract address
+     * @param operator - Operator address
+     * @param approved - Whether to approve or revoke
+     * @returns Transaction hash
+     */
+    setApprovalForAllNFT(collectionAddress: Address$1, operator: Address$1, approved: boolean): Promise<`0x${string}`>;
 }
 
 declare const FACTORY: {
@@ -1599,4 +2780,4 @@ interface UserAccountData {
     healthFactor: bigint;
 }
 
-export { index$7 as AgniConstants, index$6 as LendleConstants, type LendlePosition, type LendlePositionsResult, METH_TOKEN, MNTAgentKit, index$5 as MerchantMoeConstants, index$8 as MethConstants, type MethPosition, index$4 as OKXConstants, index$3 as OneInchConstants, index$2 as OpenOceanConstants, index as PikePerpsConstants, type PikePerpsMarketData, type PikePerpsPosition, type PikePerpsTrade, type ProjectConfig, index$1 as SquidConstants, index$9 as UniswapConstants, type UserAccountData, agniSwap, approveToken, crossChainSwapViaSquid, executeSwap, get1inchQuote, getOpenOceanQuote, getProjectConfig, getSquidRoute, getUniswapQuote, initializePlatform, lendleBorrow, lendleGetPositions, lendleRepay, lendleSupply, lendleWithdraw, merchantMoeSwap, methGetPosition, pikeperpsClosePosition, pikeperpsGetMarketData, pikeperpsGetPositions, pikeperpsOpenLong, pikeperpsOpenShort, sendTransaction, swapFromMeth, swapOn1inch, swapOnOpenOcean, swapOnUniswap, swapToMeth };
+export { index$7 as AgniConstants, index$6 as LendleConstants, type LendlePosition, type LendlePositionsResult, METH_TOKEN, MNTAgentKit, index$5 as MerchantMoeConstants, index$a as MethConstants, type MethPosition, type NFTCollectionConfig, type NFTCollectionDeploymentResult, type NFTCollectionInfo, index$8 as NFTLaunchpadConstants, type NFTMintResult, type NFTTokenInfo, index$4 as OKXConstants, index$3 as OneInchConstants, index$2 as OpenOceanConstants, index as PikePerpsConstants, type PikePerpsMarketData, type PikePerpsPosition, type PikePerpsTrade, type ProjectConfig, index$c as PythConstants, type PythPriceData, type PythPriceResponse, index$1 as SquidConstants, type TokenConfig, type TokenDeploymentResult, type TokenInfo, index$9 as TokenLaunchpadConstants, type TokenType, index$b as UniswapConstants, type UserAccountData, agniSwap, approveNFT, approveToken, batchMintNFT, crossChainSwapViaSquid, deployNFTCollection, deployNFTCollectionWithPreset, deployRWAToken, deployStandardToken, deployToken, executeSwap, get1inchQuote, getNFTBalance, getNFTCollectionInfo, getNFTTokenInfo, getOpenOceanQuote, getProjectConfig, getSquidRoute, getTokenBalance, getTokenInfo, getUniswapQuote, initializePlatform, isNFTOwner, lendleBorrow, lendleGetPositions, lendleRepay, lendleSupply, lendleWithdraw, merchantMoeSwap, methGetPosition, mintNFT, pikeperpsClosePosition, pikeperpsGetMarketData, pikeperpsGetPositions, pikeperpsOpenLong, pikeperpsOpenShort, pythGetEmaPrice, pythGetMultiplePrices, pythGetPrice, pythGetSupportedPriceFeeds, pythGetSupportedTokenAddresses, pythGetTokenPrice, pythPriceFeedExists, safeTransferNFT, sendTransaction, setApprovalForAllNFT, swapFromMeth, swapOn1inch, swapOnOpenOcean, swapOnUniswap, swapToMeth, transferNFT, transferToken };