@medialane/sdk 0.1.0 → 0.2.1

package/README.md

@@ -1,48 +1,59 @@
-<img width="1260" height="640" alt="image" src="https://github.com/user-attachments/assets/a72bca86-bb82-42c4-8f61-9558484df5b9" />
+<img width="1260" height="640" alt="Medialane SDK" src="https://github.com/user-attachments/assets/a72bca86-bb82-42c4-8f61-9558484df5b9" />
 
-# Medialane SDK
+# @medialane/sdk
 
-The Medialane SDK provides a unified interface for interacting with the Medialane marketplace, offering both **on-chain operations** (create listings, make offers, fulfill orders) and **REST API access** (search tokens, manage orders, upload metadata).
+**Framework-agnostic TypeScript SDK for the Medialane IP marketplace on Starknet**
 
-Framework-agnostic TypeScript SDK for [Medialane.xyz](https://medialane.xyz) portal for tokenization and monetization services and [Medialane.io](https://medialane.io) NFT marketplace.
+The Medialane SDK provides a unified interface for interacting with the Medialane marketplace — both **on-chain operations** (create listings, make offers, fulfill orders, mint IP assets) and **REST API access** (search tokens, manage orders, upload metadata to IPFS). Built for [Medialane.io](https://medialane.io) and [Medialane.xyz](https://medialane.xyz).
+
+---
 
 ## Features
 
-✨ **On-Chain Operations**
+**On-Chain Operations**
 - Create listings (ERC-721 for sale)
 - Make offers (bid with ERC-20)
 - Fulfill orders (purchase NFTs)
 - Cancel active orders
-- Atomic multi-item checkout
+- Atomic multi-item cart checkout
 - Built-in approval checking
 - SNIP-12 typed data signing
-
-🌐 **REST API**
-- Query orders, tokens, and collections
-- Search across the marketplace
-- Stream activities and transactions
-- Manage API keys and webhooks (authenticated)
-- Upload metadata to IPFS
-
-🔧 **Developer-Friendly**
+- Mint IP NFTs into any collection
+- Deploy new ERC-721 collections
+
+**REST API Client**
+- Query orders, tokens, collections, and activities
+- Full-text search across the marketplace
+- Intent-based transaction orchestration
+- Upload metadata and files to IPFS (Pinata)
+- Tenant portal: API keys, webhooks, usage
+
+**IP Metadata Types**
+- `IpAttribute` — typed OpenSea ERC-721 attribute
+- `IpNftMetadata` — full IPFS metadata shape with licensing fields
+- `ApiTokenMetadata` — indexed token metadata with all licensing attributes
+- Berne Convention-compatible licensing data model
+
+**Developer-Friendly**
 - Framework-agnostic TypeScript
-- Dual ESM/CJS builds
-- Zod schema validation
+- Dual ESM + CJS builds
+- Zod schema config validation
 - Full type safety
-- Zero runtime dependencies (except Zod)
 - Peer dependency: `starknet >= 6.0.0`
 
+---
+
 ## Installation
 
 ```bash
 npm install @medialane/sdk starknet
 # or
-yarn add @medialane/sdk starknet
-# or
 bun add @medialane/sdk starknet
+# or
+yarn add @medialane/sdk starknet
 ```
 
-The SDK requires `starknet >= 6.0.0` as a peer dependency for on-chain operations.
+---
 
 ## Quick Start
 
@@ -53,63 +64,43 @@ import { MedialaneClient } from "@medialane/sdk";
 
 const client = new MedialaneClient({
   network: "mainnet",                              // "mainnet" | "sepolia"
-  rpcUrl: "https://starknet-mainnet.public.blastapi.io", // optional; auto-configured if omitted
-  backendUrl: "https://api.medialane.xyz",        // optional; required for .api methods
-  apiKey: "ml_live_...",                          // optional; enables authenticated API routes
+  rpcUrl: "https://starknet-mainnet.public.blastapi.io", // optional; defaults to BlastAPI
+  backendUrl: "https://api.medialane.xyz",        // required for .api methods
+  apiKey: "ml_live_...",                          // from Medialane Portal
 });
 ```
 
-### Query the Marketplace (REST API)
-
-```typescript
-// Get active listings
-const orders = await client.api.getOrders({
-  status: "active",
-  sort: "newest",
-  page: 1,
-  limit: 20,
-});
+---
 
-// Search for a specific token
-const search = await client.api.search("vintage-nft", 10);
+## Marketplace Operations (On-Chain)
 
-// Get activities
-const activities = await client.api.getActivities({ 
-  type: "sale", 
-  page: 1 
-});
-```
+All methods require a `starknet.js` `AccountInterface`. Nonce management, SNIP-12 signing, and `waitForTransaction` are handled automatically.
 
-### Create a Listing (On-Chain)
+### Create a Listing
 
 ```typescript
 import { Account } from "starknet";
 
-const account: Account = /* your starknet.js Account */;
-
 const result = await client.marketplace.createListing(account, {
-  nftContract: "0x05e73b7be06d82beeb390a0e0d655f2c9e7cf519658e04f05d9c690ccc41da03",
+  nftContract: "0x05e73b7...",
   tokenId: 42n,
-  currency: "USDC", // one of: "USDC", "USDT", "ETH", "STRK"
+  currency: "USDC",
   price: "1000000", // 1 USDC (6 decimals)
-  endTime: Math.floor(Date.now() / 1000) + 86400 * 30, // 30 days from now
+  endTime: Math.floor(Date.now() / 1000) + 86400 * 30, // 30 days
 });
-
-console.log("Listing created:", result.txHash);
+console.log("Listed:", result.txHash);
 ```
 
 ### Make an Offer
 
 ```typescript
 const result = await client.marketplace.makeOffer(account, {
-  nftContract: "0x05e73b7be06d82beeb390a0e0d655f2c9e7cf519658e04f05d9c690ccc41da03",
+  nftContract: "0x05e73b7...",
   tokenId: 42n,
   currency: "USDC",
   price: "500000", // 0.5 USDC
-  endTime: Math.floor(Date.now() / 1000) + 86400 * 7, // 7 days
+  endTime: Math.floor(Date.now() / 1000) + 86400 * 7,
 });
-
-console.log("Offer created:", result.txHash);
 ```
 
 ### Fulfill an Order
@@ -117,227 +108,271 @@ console.log("Offer created:", result.txHash);
 ```typescript
 const result = await client.marketplace.fulfillOrder(account, {
   orderHash: "0x...",
-  fulfiller: "0x...", // your address
+  fulfiller: account.address,
 });
-
-console.log("Order fulfilled:", result.txHash);
 ```
 
-### Checkout Multiple Items
+### Cart Checkout (Multiple Items)
 
 ```typescript
 const result = await client.marketplace.checkoutCart(account, [
-  {
-    orderHash: "0x...",
-    fulfiller: "0x...",
-  },
-  {
-    orderHash: "0x...",
-    fulfiller: "0x...",
-  },
+  { orderHash: "0x...", fulfiller: account.address },
+  { orderHash: "0x...", fulfiller: account.address },
 ]);
-
-console.log("Cart checked out:", result.txHash);
 ```
 
-## Configuration
-
-The `MedialaneClient` constructor accepts a `MedialaneConfig` object with the following options:
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `network` | `"mainnet" \| "sepolia"` | `"mainnet"` | Starknet network |
-| `rpcUrl` | `string` | BlastAPI endpoint | JSON-RPC URL for the network |
-| `backendUrl` | `string` | *(required for `.api` calls)* | Medialane backend API base URL |
-| `apiKey` | `string` | - | API key for authenticated routes (obtained from Medialane Portal) |
-| `marketplaceContract` | `string` | Network-specific default | Marketplace contract address |
+### Cancel an Order
 
-**Note:** If `backendUrl` is not provided, calling any `.api.*` method will throw an error with instructions to configure it.
+```typescript
+const result = await client.marketplace.cancelOrder(account, {
+  orderHash: "0x...",
+  offerer: account.address,
+});
+```
 
-## API Reference
+### Mint an IP Asset
 
-### Marketplace Module
+```typescript
+const result = await client.marketplace.mint(account, {
+  collectionId: "1",          // collection ID on the registry
+  recipient: account.address,
+  tokenUri: "ipfs://...",     // IPFS URI of the metadata JSON
+});
+```
 
-All methods require a `starknet.js` `AccountInterface`. They handle nonce management, SNIP-12 signing, and transaction waiting automatically.
+### Deploy a Collection
 
-#### Write Operations
+```typescript
+const result = await client.marketplace.createCollection(account, {
+  name: "My Creative Works",
+  symbol: "MCW",
+  baseUri: "",
+});
+```
 
-| Method | Description |
-|--------|-------------|
-| `createListing(account, params)` | List an ERC-721 for sale. Auto-checks approval; includes approve call if needed. |
-| `makeOffer(account, params)` | Bid on an ERC-721 with ERC-20. Includes token approval + order registration. |
-| `fulfillOrder(account, params)` | Purchase a listed NFT. Fetches nonce and signs fulfillment typed data. |
-| `cancelOrder(account, params)` | Cancel an active order. Fetches nonce and signs cancellation typed data. |
-| `checkoutCart(account, items)` | Atomic multicall for multiple purchases. One approve per unique token, sequential nonces. |
+---
 
-#### View Operations
+## REST API
 
-| Method | Description |
-|--------|-------------|
-| `getOrderDetails(orderHash)` | Fetch order details from the contract. |
-| `getNonce(address)` | Get the current nonce for an address. |
+### Query Orders
 
-### REST API Client
+```typescript
+const orders = await client.api.getOrders({
+  status: "ACTIVE",
+  sort: "price_asc",
+  currency: "0x033068...", // USDC address
+  page: 1,
+  limit: 20,
+});
 
-The `client.api` object provides access to all backend endpoints. All methods throw `MedialaneApiError` on non-2xx responses.
+const order = await client.api.getOrder("0x...");
+const tokenOrders = await client.api.getActiveOrdersForToken(contract, tokenId);
+const userOrders = await client.api.getOrdersByUser(address);
+```
 
-#### Orders
+### Query Tokens
 
 ```typescript
-client.api.getOrders(query?)              // List all orders with optional filters
-client.api.getOrder(orderHash)            // Get a specific order
-client.api.getActiveOrdersForToken(...)   // Get active orders for a token
-client.api.getOrdersByUser(address, ...)  // Get orders by user
+const token = await client.api.getToken(contract, tokenId);
+const tokens = await client.api.getTokensByOwner(address);
+const history = await client.api.getTokenHistory(contract, tokenId);
 ```
 
-#### Tokens
+### Query Collections
 
 ```typescript
-client.api.getToken(contract, tokenId, wait?)   // Get token metadata
-client.api.getTokensByOwner(address, ...)       // Get tokens owned by address
-client.api.getTokenHistory(contract, tokenId)   // Get token transaction history
+const collections = await client.api.getCollections();
+const collection = await client.api.getCollection(contract);
+const tokens = await client.api.getCollectionTokens(contract);
 ```
 
-#### Collections
+### Search
 
 ```typescript
-client.api.getCollections(page?, limit?)       // List all collections
-client.api.getCollection(contract)             // Get collection details
-client.api.getCollectionTokens(contract, ...)  // Get tokens in collection
+const results = await client.api.search("landscape painting", 10);
+// results.data.tokens — matching tokens
+// results.data.collections — matching collections
 ```
 
-#### Activities
+### Activities
 
 ```typescript
-client.api.getActivities(query?)               // Get marketplace activities
-client.api.getActivitiesByAddress(address)    // Get activities by user
+const feed = await client.api.getActivities({ type: "sale", page: 1 });
+const userFeed = await client.api.getActivitiesByAddress(address);
 ```
 
-#### Search
+### Upload Metadata to IPFS
 
 ```typescript
-client.api.search(query, limit?)               // Search tokens and collections
+// Upload a file
+const fileResult = await client.api.uploadFile(imageFile);
+// fileResult.data.url → "ipfs://..."
+
+// Upload metadata JSON
+const metaResult = await client.api.uploadMetadata({
+  name: "My Work",
+  description: "...",
+  image: "ipfs://...",
+  external_url: "https://medialane.io",
+  attributes: [
+    { trait_type: "License", value: "CC BY-NC" },
+    { trait_type: "Commercial Use", value: "No" },
+    // ...
+  ],
+});
+// metaResult.data.url → "ipfs://..."
 ```
 
-#### Intents (Advanced)
+### Intents (Advanced)
+
+The intent system handles the SNIP-12 signing flow for marketplace operations:
 
 ```typescript
-client.api.createListingIntent(params)         // Create listing intent
-client.api.createOfferIntent(params)           // Create offer intent
-client.api.createFulfillIntent(params)         // Create fulfill intent
-client.api.createCancelIntent(params)          // Create cancel intent
-client.api.submitIntentSignature(id, sig)     // Submit signature for intent
-```
+// 1. Create intent (gets typedData to sign)
+const intent = await client.api.createListingIntent({
+  offerer: address,
+  nftContract: "0x...",
+  tokenId: "42",
+  currency: "0x033068...",
+  price: "1000000",
+  endTime: Math.floor(Date.now() / 1000) + 86400 * 30,
+});
 
-#### Metadata (IPFS)
+// 2. Sign typedData
+const signature = await account.signMessage(intent.data.typedData);
 
-```typescript
-client.api.uploadMetadata(metadata)            // Upload JSON to IPFS
-client.api.uploadFile(file)                    // Upload file to IPFS
-client.api.resolveMetadata(uri)                // Resolve ipfs://, data:, https://
-client.api.getMetadataSignedUrl()              // Get presigned Pinata URL
+// 3. Submit signature
+await client.api.submitIntentSignature(intent.data.id, toSignatureArray(signature));
 ```
 
-#### Portal (Self-Service)
+Mint and collection intents are pre-signed — no signature step needed:
 
 ```typescript
-client.api.getMe()                             // Get current user info
-client.api.getApiKeys()                        // List API keys
-client.api.createApiKey(label?)                // Create new API key
-client.api.deleteApiKey(id)                    // Revoke API key
-client.api.getUsage()                          // Get 30-day request usage
+const mintIntent = await client.api.createMintIntent({
+  owner: ownerAddress,
+  collectionId: "1",
+  recipient: recipientAddress,
+  tokenUri: "ipfs://...",
+});
+// mintIntent.data.calls → ready to execute
 ```
 
-## Error Handling
+---
 
-The SDK throws two main error types:
+## IP Metadata Types
 
 ```typescript
-import { MedialaneError, MedialaneApiError } from "@medialane/sdk";
-
-// On-chain errors
-try {
-  await client.marketplace.createListing(account, params);
-} catch (error) {
-  if (error instanceof MedialaneError) {
-    console.error("On-chain error:", error.message);
-  }
-}
-
-// REST API errors
-try {
-  await client.api.getOrders();
-} catch (error) {
-  if (error instanceof MedialaneApiError) {
-    console.error(`API error ${error.status}:`, error.message);
-  }
-}
+import type { IpAttribute, IpNftMetadata, ApiTokenMetadata } from "@medialane/sdk";
+
+// Single OpenSea ERC-721 attribute
+const attr: IpAttribute = { trait_type: "License", value: "CC BY-NC-SA" };
+
+// Full IPFS metadata shape for a Medialane IP NFT
+const metadata: IpNftMetadata = {
+  name: "My Track",
+  description: "Original music",
+  image: "ipfs://...",
+  external_url: "https://medialane.io",
+  attributes: [
+    { trait_type: "IP Type",        value: "Music" },
+    { trait_type: "License",        value: "CC BY-NC-SA" },
+    { trait_type: "Commercial Use", value: "No" },
+    { trait_type: "Derivatives",    value: "Share-Alike" },
+    { trait_type: "Attribution",    value: "Required" },
+    { trait_type: "Territory",      value: "Worldwide" },
+    { trait_type: "AI Policy",      value: "Not Allowed" },
+    { trait_type: "Royalty",        value: "10%" },
+    { trait_type: "Standard",       value: "Berne Convention" },
+    { trait_type: "Registration",   value: "2026-03-06" },
+  ],
+};
+
+// Token from the API — includes indexed licensing fields for fast access
+const token = await client.api.getToken(contract, tokenId);
+token.data.metadata.licenseType;   // "CC BY-NC-SA"
+token.data.metadata.commercialUse; // "No"
+token.data.metadata.derivatives;   // "Share-Alike"
+token.data.metadata.attributes;    // IpAttribute[] | null
 ```
 
-## Supported Tokens
-
-The following tokens are supported for on-chain operations:
+---
 
-| Symbol | Address | Decimals |
-|--------|---------|----------|
-| USDC | `0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8` | 6 |
-| USDT | `0x068f5c6a61780768455de69077e07e89787839bf8166decfbf92b645209c0fb8` | 6 |
-| ETH | `0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7` | 18 |
-| STRK | `0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d` | 18 |
+## Supported Tokens
 
-Use the token symbol (e.g., `"USDC"`) in SDK methods, or access token details via:
+| Symbol | Type | Address | Decimals |
+|---|---|---|---|
+| USDC | Circle-native (canonical) | `0x033068f6539f8e6e6b131e6b2b814e6c34a5224bc66947c47dab9dfee93b35fb` | 6 |
+| USDC.e | Bridged (Starkgate) | `0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8` | 6 |
+| USDT | Tether | `0x068f5c6a61780768455de69077e07e89787839bf8166decfbf92b645209c0fb8` | 6 |
+| ETH | Ether | `0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7` | 18 |
+| STRK | Starknet native | `0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d` | 18 |
 
 ```typescript
-import { getTokenBySymbol, getTokenByAddress } from "@medialane/sdk";
+import { getTokenBySymbol, getTokenByAddress, SUPPORTED_TOKENS } from "@medialane/sdk";
 
 const usdc = getTokenBySymbol("USDC");
-const token = getTokenByAddress("0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8");
-
-console.log(usdc.decimals, token.address);
+const token = getTokenByAddress("0x033068...");
 ```
 
-## Utilities
+---
 
-Helper functions for common tasks:
+## Utilities
 
 ```typescript
 import {
-  normalizeAddress,      // Normalize address to 0x-prefixed lowercase
-  shortenAddress,        // Shorten to 0x1234...5678 format
-  parseAmount,           // Convert human-readable amount to smallest unit (BigInt)
-  formatAmount,          // Convert smallest unit (BigInt) to human-readable string
-  stringifyBigInts,      // Recursively convert BigInts to strings for JSON serialization
+  normalizeAddress,   // Pad to 64-char 0x-prefixed lowercase hex
+  shortenAddress,     // → "0x1234...5678"
+  parseAmount,        // Human-readable → smallest unit BigInt ("1.5", 6) → 1500000n
+  formatAmount,       // Smallest unit → human-readable ("1500000", 6) → "1.5"
+  stringifyBigInts,   // Recursively convert BigInt → string (for JSON)
+  u256ToBigInt,       // u256 { low, high } → BigInt
 } from "@medialane/sdk";
-
-// Address utilities
-const addr = normalizeAddress("0x123ABC");
-const short = shortenAddress("0x123abc456def789012345678901234567890");
-
-// Token amounts
-const amountWei = parseAmount("1.5", 6); // "1500000" (USDC)
-const readable = formatAmount("1500000", 6); // "1.5"
 ```
 
-## Advanced Usage
+---
 
-### Custom RPC Provider
+## Error Handling
 
 ```typescript
-import { RpcProvider } from "starknet";
+import { MedialaneError, MedialaneApiError } from "@medialane/sdk";
 
-const customProvider = new RpcProvider({
-  nodeUrl: "https://your-custom-rpc.com",
-});
+// On-chain errors (marketplace module)
+try {
+  await client.marketplace.createListing(account, params);
+} catch (err) {
+  if (err instanceof MedialaneError) {
+    console.error("On-chain error:", err.message, err.cause);
+  }
+}
 
-const client = new MedialaneClient({
-  network: "mainnet",
-  rpcUrl: "https://your-custom-rpc.com",
-});
+// REST API errors
+try {
+  await client.api.getOrders();
+} catch (err) {
+  if (err instanceof MedialaneApiError) {
+    console.error(`API ${err.status}:`, err.message);
+  }
+}
 ```
 
-### Signing Typed Data (for integrations)
+---
 
-For advanced integrations like ChipiPay, you can access the SNIP-12 typed data builders directly:
+## Configuration Reference
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `network` | `"mainnet" \| "sepolia"` | `"mainnet"` | Starknet network |
+| `rpcUrl` | `string` | BlastAPI public endpoint | JSON-RPC URL |
+| `backendUrl` | `string` | — | Medialane API base URL (required for `.api.*`) |
+| `apiKey` | `string` | — | API key from [Medialane Portal](https://medialane.xyz) |
+| `marketplaceContract` | `string` | Mainnet default | Marketplace contract override |
+| `collectionContract` | `string` | Mainnet default | Collection registry override |
+
+---
+
+## Advanced: SNIP-12 Typed Data Builders
+
+For integrations that handle signing externally (e.g. ChipiPay, Cartridge Controller):
 
 ```typescript
 import {
@@ -348,33 +383,49 @@ import {
 
 const typedData = buildOrderTypedData(orderParams, chainId);
 const signature = await account.signMessage(typedData);
-
-// Signature can then be submitted via API intents
-await client.api.submitIntentSignature(intentId, signature);
+await client.api.submitIntentSignature(intentId, signatureArray);
 ```
 
-## Development
+---
 
-Build and type-check the SDK:
+## Development
 
 ```bash
-bun run build      # Compile to dist/ (ESM + CJS)
+bun run build      # Compile to dist/ (ESM + CJS dual output)
 bun run dev        # Watch mode
-bun run typecheck  # Type check only (no emit)
+bun run typecheck  # tsc --noEmit
 ```
 
-The SDK uses:
-- **tsup** for dual ESM/CJS bundling
-- **TypeScript** for type safety
-- **Zod** for runtime config validation
+Built with:
+- **tsup** — dual ESM/CJS bundling
+- **TypeScript** — full type safety
+- **Zod** — runtime config validation
+- Peer dep: `starknet >= 6.0.0`
 
-## License
+---
 
-[MIT](LICENSE)
+## Changelog
+
+### v0.2.0
+- `IpAttribute` and `IpNftMetadata` interfaces for IP metadata
+- `ApiTokenMetadata.attributes` typed as `IpAttribute[] | null` (was `unknown`)
+- `ApiTokenMetadata` extended with `derivatives`, `attribution`, `territory`, `aiPolicy`, `royalty`, `registration`, `standard`
+- Added `USDC.e` (bridged USDC via Starkgate) to `SUPPORTED_TOKENS`
+
+### v0.1.0
+- Initial release — orders, tokens, collections, activities, intents, metadata, portal
 
-## Support
+---
 
-- **Services App**: [medialane.xyz](https://medialane.xyz)
-- **Documentation**: [medialane.xyz/docs](https://medialane.xyz/docs)
-- **Issues**: [GitHub Issues](https://github.com/medialane-io/sdk/issues)
-- **Medialane Github**: [GitHub Issues](https://github.com/medialane-io)
+## Links
+
+- **Marketplace**: [medialane.io](https://medialane.io)
+- **Developer Portal**: [medialane.xyz](https://medialane.xyz)
+- **npm**: [npmjs.com/package/@medialane/sdk](https://www.npmjs.com/package/@medialane/sdk)
+- **GitHub**: [github.com/medialane-io](https://github.com/medialane-io)
+
+---
+
+## License
+
+[MIT](LICENSE)

package/dist/index.cjs

@@ -10,11 +10,17 @@ var MARKETPLACE_CONTRACT_MAINNET = "0x059deafbbafbf7051c315cf75a94b03c5547892bc0
 var COLLECTION_CONTRACT_MAINNET = "0x05e73b7be06d82beeb390a0e0d655f2c9e7cf519658e04f05d9c690ccc41da03";
 var SUPPORTED_TOKENS = [
   {
-    // Circle-native USDC on Starknet (canonical)
+    // Circle-native USDC on Starknet (canonical — preferred)
     symbol: "USDC",
     address: "0x033068f6539f8e6e6b131e6b2b814e6c34a5224bc66947c47dab9dfee93b35fb",
     decimals: 6
   },
+  {
+    // Bridged USDC.e (Ethereum USDC bridged via Starkgate)
+    symbol: "USDC.e",
+    address: "0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8",
+    decimals: 6
+  },
   {
     symbol: "USDT",
     address: "0x068f5c6a61780768455de69077e07e89787839bf8166decfbf92b645209c0fb8",