@vapi-network/core 0.2.0-dev.2

package/dist/keystore.d.ts

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import type { Hex } from "viem";
+declare const keystoreSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    address: z.ZodString;
+    crypto: z.ZodObject<{
+        cipher: z.ZodLiteral<"aes-256-gcm">;
+        ciphertext: z.ZodString;
+        iv: z.ZodString;
+        authTag: z.ZodString;
+        kdf: z.ZodLiteral<"scrypt">;
+        salt: z.ZodString;
+        kdfParams: z.ZodObject<{
+            n: z.ZodLiteral<number>;
+            r: z.ZodLiteral<8>;
+            p: z.ZodLiteral<1>;
+            dkLen: z.ZodLiteral<32>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type VapiKeystore = z.infer<typeof keystoreSchema>;
+/** @deprecated Use VapiKeystore. */
+export type AgentCashKeystore = VapiKeystore;
+export declare class KeystoreError extends Error {
+    constructor(message: string, options?: ErrorOptions);
+}
+export declare function encryptPrivateKey(privateKey: Hex, passphrase: string): Promise<AgentCashKeystore>;
+export declare function decryptPrivateKey(keystore: VapiKeystore, passphrase: string): Promise<Hex>;
+export declare function createKeystore(passphrase: string, path?: string): Promise<{
+    address: import("viem").Address;
+    nonceManager?: import("viem").NonceManager | undefined;
+    sign: (parameters: {
+        hash: import("viem").Hash;
+    }) => Promise<Hex>;
+    signAuthorization: (parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>;
+    signMessage: ({ message }: {
+        message: import("viem").SignableMessage;
+    }) => Promise<Hex>;
+    signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+        serializer?: serializer | undefined;
+    } | undefined) => Promise<Hex>;
+    signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<Hex>;
+    publicKey: Hex;
+    source: "privateKey";
+    type: "local";
+}>;
+export declare function unlockKeystore(passphrase: string, path?: string): Promise<{
+    address: import("viem").Address;
+    nonceManager?: import("viem").NonceManager | undefined;
+    sign: (parameters: {
+        hash: import("viem").Hash;
+    }) => Promise<Hex>;
+    signAuthorization: (parameters: import("viem").AuthorizationRequest) => Promise<import("viem/accounts").SignAuthorizationReturnType>;
+    signMessage: ({ message }: {
+        message: import("viem").SignableMessage;
+    }) => Promise<Hex>;
+    signTransaction: <serializer extends import("viem").SerializeTransactionFn<import("viem").TransactionSerializable> = import("viem").SerializeTransactionFn<import("viem").TransactionSerializable>, transaction extends Parameters<serializer>[0] = Parameters<serializer>[0]>(transaction: transaction, options?: {
+        serializer?: serializer | undefined;
+    } | undefined) => Promise<Hex>;
+    signTypedData: <const typedData extends import("viem").TypedData | Record<string, unknown>, primaryType extends keyof typedData | "EIP712Domain" = keyof typedData>(parameters: import("viem").TypedDataDefinition<typedData, primaryType>) => Promise<Hex>;
+    publicKey: Hex;
+    source: "privateKey";
+    type: "local";
+}>;
+export declare function getKeystorePassphrase(options?: {
+    confirm?: boolean;
+}): Promise<string>;
+export {};
+//# sourceMappingURL=keystore.d.ts.map

package/dist/keystore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keystore.d.ts","sourceRoot":"","sources":["../src/keystore.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAWhC,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;iBAiBlB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAC1D,oCAAoC;AACpC,MAAM,MAAM,iBAAiB,GAAG,YAAY,CAAC;AAE7C,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIpD;AAyBD,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,GAAG,EACf,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,iBAAiB,CAAC,CAiC5B;AAED,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAgChG;AAED,wBAAsB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,SAA0B;;;;;;;;;;oTAzFjF,CAAH;kBACc,CAAC;;;;;;GAkHjB;AAED,wBAAsB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,SAA0B;;;;;;;;;;oTArHjF,CAAH;kBACc,CAAC;;;;;;GAmIjB;AAED,wBAAsB,qBAAqB,CAAC,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAoB5F"}

package/dist/marketplace-contracts.d.ts

@@ -0,0 +1,521 @@
+import { z } from "zod";
+export declare const MARKETPLACE_DISCOVERY_PROTOCOL: "vapi.marketplace.discovery/1";
+export declare const MARKETPLACE_RANKING_VERSION: "marketplace-ranking-v1";
+export declare const MARKETPLACE_KINDS: readonly ["api", "service_offer", "open_request"];
+export declare const MARKETPLACE_EXECUTION_METHODS: readonly ["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE"];
+export declare const marketplaceExecutionMethodSchema: z.ZodEnum<{
+    HEAD: "HEAD";
+    GET: "GET";
+    POST: "POST";
+    PUT: "PUT";
+    PATCH: "PATCH";
+    DELETE: "DELETE";
+}>;
+export type MarketplaceExecutionMethod = z.infer<typeof marketplaceExecutionMethodSchema>;
+export declare const marketplaceKindSchema: z.ZodEnum<{
+    api: "api";
+    service_offer: "service_offer";
+    open_request: "open_request";
+}>;
+export type MarketplaceKind = z.infer<typeof marketplaceKindSchema>;
+/**
+ * The two orthogonal axes that describe an API listing, per
+ * `docs/adr/0008-two-axis-call-taxonomy.md`. `executionMode` answers "is vAPI in
+ * the request path"; `provenance` answers "where did this come from and what did
+ * we vouch for". Neither implies the other, and only `kind: "api"` carries them —
+ * Work kinds are first-party by construction and have no execution surface.
+ */
+export declare const EXECUTION_MODES: readonly ["direct", "gateway"];
+export declare const executionModeSchema: z.ZodEnum<{
+    direct: "direct";
+    gateway: "gateway";
+}>;
+export type ExecutionMode = z.infer<typeof executionModeSchema>;
+export declare const PROVENANCES: readonly ["indexed", "self_listed", "partner"];
+export declare const provenanceSchema: z.ZodEnum<{
+    partner: "partner";
+    indexed: "indexed";
+    self_listed: "self_listed";
+}>;
+export type Provenance = z.infer<typeof provenanceSchema>;
+/** Provenances vAPI itself holds a record for, as opposed to mirrored catalog rows. */
+export declare const FIRST_PARTY_PROVENANCES: readonly ["self_listed", "partner"];
+export declare const firstPartyProvenanceSchema: z.ZodEnum<{
+    partner: "partner";
+    self_listed: "self_listed";
+}>;
+export type FirstPartyProvenance = z.infer<typeof firstPartyProvenanceSchema>;
+export declare const marketplaceBadgeCodeSchema: z.ZodEnum<{
+    partner: "partner";
+    live_x402: "live_x402";
+    payout_wallet_confirmed: "payout_wallet_confirmed";
+    vapi_verified: "vapi_verified";
+    external_catalog: "external_catalog";
+    approved_vendor: "approved_vendor";
+}>;
+export type MarketplaceBadgeCode = z.infer<typeof marketplaceBadgeCodeSchema>;
+export declare const marketplaceBadgeSchema: z.ZodObject<{
+    code: z.ZodEnum<{
+        partner: "partner";
+        live_x402: "live_x402";
+        payout_wallet_confirmed: "payout_wallet_confirmed";
+        vapi_verified: "vapi_verified";
+        external_catalog: "external_catalog";
+        approved_vendor: "approved_vendor";
+    }>;
+    label: z.ZodString;
+}, z.core.$strict>;
+export type MarketplaceBadge = z.infer<typeof marketplaceBadgeSchema>;
+export declare const marketplacePublicFactSchema: z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodString;
+}, z.core.$strict>;
+export type MarketplacePublicFact = z.infer<typeof marketplacePublicFactSchema>;
+export declare const apiMarketplaceHitSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"api">;
+    provenance: z.ZodEnum<{
+        partner: "partner";
+        self_listed: "self_listed";
+    }>;
+    execution: z.ZodObject<{
+        mode: z.ZodEnum<{
+            direct: "direct";
+            gateway: "gateway";
+        }>;
+    }, z.core.$strict>;
+    action: z.ZodObject<{
+        type: z.ZodLiteral<"invoke_api">;
+        href: z.ZodUnion<readonly [z.ZodString, z.ZodURL]>;
+    }, z.core.$strict>;
+    ref: z.ZodString;
+    card: z.ZodObject<{
+        title: z.ZodString;
+        summary: z.ZodString;
+        byline: z.ZodOptional<z.ZodString>;
+        bylineHref: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodURL]>>;
+        badges: z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                partner: "partner";
+                live_x402: "live_x402";
+                payout_wallet_confirmed: "payout_wallet_confirmed";
+                vapi_verified: "vapi_verified";
+                external_catalog: "external_catalog";
+                approved_vendor: "approved_vendor";
+            }>;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+        facts: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"api">;
+    provenance: z.ZodLiteral<"indexed">;
+    execution: z.ZodObject<{
+        mode: z.ZodLiteral<"direct">;
+        url: z.ZodURL;
+        method: z.ZodNullable<z.ZodEnum<{
+            HEAD: "HEAD";
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+        }>>;
+        network: z.ZodString;
+    }, z.core.$strict>;
+    action: z.ZodObject<{
+        type: z.ZodLiteral<"invoke_api">;
+        href: z.ZodUnion<readonly [z.ZodString, z.ZodURL]>;
+    }, z.core.$strict>;
+    ref: z.ZodString;
+    card: z.ZodObject<{
+        title: z.ZodString;
+        summary: z.ZodString;
+        byline: z.ZodOptional<z.ZodString>;
+        bylineHref: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodURL]>>;
+        badges: z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                partner: "partner";
+                live_x402: "live_x402";
+                payout_wallet_confirmed: "payout_wallet_confirmed";
+                vapi_verified: "vapi_verified";
+                external_catalog: "external_catalog";
+                approved_vendor: "approved_vendor";
+            }>;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+        facts: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "provenance">;
+export type ApiMarketplaceHit = z.infer<typeof apiMarketplaceHitSchema>;
+export declare const serviceOfferMarketplaceHitSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"service_offer">;
+    action: z.ZodObject<{
+        type: z.ZodLiteral<"start_engagement">;
+        href: z.ZodUnion<readonly [z.ZodString, z.ZodURL]>;
+    }, z.core.$strict>;
+    ref: z.ZodString;
+    card: z.ZodObject<{
+        title: z.ZodString;
+        summary: z.ZodString;
+        byline: z.ZodOptional<z.ZodString>;
+        bylineHref: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodURL]>>;
+        badges: z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                partner: "partner";
+                live_x402: "live_x402";
+                payout_wallet_confirmed: "payout_wallet_confirmed";
+                vapi_verified: "vapi_verified";
+                external_catalog: "external_catalog";
+                approved_vendor: "approved_vendor";
+            }>;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+        facts: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type ServiceOfferMarketplaceHit = z.infer<typeof serviceOfferMarketplaceHitSchema>;
+export declare const openRequestMarketplaceHitSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"open_request">;
+    action: z.ZodObject<{
+        type: z.ZodLiteral<"propose_to_request">;
+        href: z.ZodUnion<readonly [z.ZodString, z.ZodURL]>;
+    }, z.core.$strict>;
+    ref: z.ZodString;
+    card: z.ZodObject<{
+        title: z.ZodString;
+        summary: z.ZodString;
+        byline: z.ZodOptional<z.ZodString>;
+        bylineHref: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodURL]>>;
+        badges: z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                partner: "partner";
+                live_x402: "live_x402";
+                payout_wallet_confirmed: "payout_wallet_confirmed";
+                vapi_verified: "vapi_verified";
+                external_catalog: "external_catalog";
+                approved_vendor: "approved_vendor";
+            }>;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+        facts: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type OpenRequestMarketplaceHit = z.infer<typeof openRequestMarketplaceHitSchema>;
+export declare const marketplaceHitSchema: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"api">;
+    provenance: z.ZodEnum<{
+        partner: "partner";
+        self_listed: "self_listed";
+    }>;
+    execution: z.ZodObject<{
+        mode: z.ZodEnum<{
+            direct: "direct";
+            gateway: "gateway";
+        }>;
+    }, z.core.$strict>;
+    action: z.ZodObject<{
+        type: z.ZodLiteral<"invoke_api">;
+        href: z.ZodUnion<readonly [z.ZodString, z.ZodURL]>;
+    }, z.core.$strict>;
+    ref: z.ZodString;
+    card: z.ZodObject<{
+        title: z.ZodString;
+        summary: z.ZodString;
+        byline: z.ZodOptional<z.ZodString>;
+        bylineHref: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodURL]>>;
+        badges: z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                partner: "partner";
+                live_x402: "live_x402";
+                payout_wallet_confirmed: "payout_wallet_confirmed";
+                vapi_verified: "vapi_verified";
+                external_catalog: "external_catalog";
+                approved_vendor: "approved_vendor";
+            }>;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+        facts: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"api">;
+    provenance: z.ZodLiteral<"indexed">;
+    execution: z.ZodObject<{
+        mode: z.ZodLiteral<"direct">;
+        url: z.ZodURL;
+        method: z.ZodNullable<z.ZodEnum<{
+            HEAD: "HEAD";
+            GET: "GET";
+            POST: "POST";
+            PUT: "PUT";
+            PATCH: "PATCH";
+            DELETE: "DELETE";
+        }>>;
+        network: z.ZodString;
+    }, z.core.$strict>;
+    action: z.ZodObject<{
+        type: z.ZodLiteral<"invoke_api">;
+        href: z.ZodUnion<readonly [z.ZodString, z.ZodURL]>;
+    }, z.core.$strict>;
+    ref: z.ZodString;
+    card: z.ZodObject<{
+        title: z.ZodString;
+        summary: z.ZodString;
+        byline: z.ZodOptional<z.ZodString>;
+        bylineHref: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodURL]>>;
+        badges: z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                partner: "partner";
+                live_x402: "live_x402";
+                payout_wallet_confirmed: "payout_wallet_confirmed";
+                vapi_verified: "vapi_verified";
+                external_catalog: "external_catalog";
+                approved_vendor: "approved_vendor";
+            }>;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+        facts: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "provenance">, z.ZodObject<{
+    kind: z.ZodLiteral<"service_offer">;
+    action: z.ZodObject<{
+        type: z.ZodLiteral<"start_engagement">;
+        href: z.ZodUnion<readonly [z.ZodString, z.ZodURL]>;
+    }, z.core.$strict>;
+    ref: z.ZodString;
+    card: z.ZodObject<{
+        title: z.ZodString;
+        summary: z.ZodString;
+        byline: z.ZodOptional<z.ZodString>;
+        bylineHref: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodURL]>>;
+        badges: z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                partner: "partner";
+                live_x402: "live_x402";
+                payout_wallet_confirmed: "payout_wallet_confirmed";
+                vapi_verified: "vapi_verified";
+                external_catalog: "external_catalog";
+                approved_vendor: "approved_vendor";
+            }>;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+        facts: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"open_request">;
+    action: z.ZodObject<{
+        type: z.ZodLiteral<"propose_to_request">;
+        href: z.ZodUnion<readonly [z.ZodString, z.ZodURL]>;
+    }, z.core.$strict>;
+    ref: z.ZodString;
+    card: z.ZodObject<{
+        title: z.ZodString;
+        summary: z.ZodString;
+        byline: z.ZodOptional<z.ZodString>;
+        bylineHref: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodURL]>>;
+        badges: z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                partner: "partner";
+                live_x402: "live_x402";
+                payout_wallet_confirmed: "payout_wallet_confirmed";
+                vapi_verified: "vapi_verified";
+                external_catalog: "external_catalog";
+                approved_vendor: "approved_vendor";
+            }>;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+        facts: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+export type MarketplaceHit = z.infer<typeof marketplaceHitSchema>;
+export declare const marketplaceDiscoveryInputSchema: z.ZodObject<{
+    q: z.ZodOptional<z.ZodString>;
+    kinds: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        api: "api";
+        service_offer: "service_offer";
+        open_request: "open_request";
+    }>>>;
+    network: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    includeUnverified: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type MarketplaceDiscoveryInput = z.infer<typeof marketplaceDiscoveryInputSchema>;
+/**
+ * True when a hit was mirrored from an external catalog rather than held by
+ * vAPI. The one predicate both ranking and presentation need, defined once here
+ * so neither has to re-derive it from the union shape.
+ */
+export declare function isMirroredHit(hit: MarketplaceHit): boolean;
+export declare const marketplaceDiscoveryPageSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"vapi.marketplace.discovery/1">;
+    items: z.ZodArray<z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"api">;
+        provenance: z.ZodEnum<{
+            partner: "partner";
+            self_listed: "self_listed";
+        }>;
+        execution: z.ZodObject<{
+            mode: z.ZodEnum<{
+                direct: "direct";
+                gateway: "gateway";
+            }>;
+        }, z.core.$strict>;
+        action: z.ZodObject<{
+            type: z.ZodLiteral<"invoke_api">;
+            href: z.ZodUnion<readonly [z.ZodString, z.ZodURL]>;
+        }, z.core.$strict>;
+        ref: z.ZodString;
+        card: z.ZodObject<{
+            title: z.ZodString;
+            summary: z.ZodString;
+            byline: z.ZodOptional<z.ZodString>;
+            bylineHref: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodURL]>>;
+            badges: z.ZodArray<z.ZodObject<{
+                code: z.ZodEnum<{
+                    partner: "partner";
+                    live_x402: "live_x402";
+                    payout_wallet_confirmed: "payout_wallet_confirmed";
+                    vapi_verified: "vapi_verified";
+                    external_catalog: "external_catalog";
+                    approved_vendor: "approved_vendor";
+                }>;
+                label: z.ZodString;
+            }, z.core.$strict>>;
+            facts: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"api">;
+        provenance: z.ZodLiteral<"indexed">;
+        execution: z.ZodObject<{
+            mode: z.ZodLiteral<"direct">;
+            url: z.ZodURL;
+            method: z.ZodNullable<z.ZodEnum<{
+                HEAD: "HEAD";
+                GET: "GET";
+                POST: "POST";
+                PUT: "PUT";
+                PATCH: "PATCH";
+                DELETE: "DELETE";
+            }>>;
+            network: z.ZodString;
+        }, z.core.$strict>;
+        action: z.ZodObject<{
+            type: z.ZodLiteral<"invoke_api">;
+            href: z.ZodUnion<readonly [z.ZodString, z.ZodURL]>;
+        }, z.core.$strict>;
+        ref: z.ZodString;
+        card: z.ZodObject<{
+            title: z.ZodString;
+            summary: z.ZodString;
+            byline: z.ZodOptional<z.ZodString>;
+            bylineHref: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodURL]>>;
+            badges: z.ZodArray<z.ZodObject<{
+                code: z.ZodEnum<{
+                    partner: "partner";
+                    live_x402: "live_x402";
+                    payout_wallet_confirmed: "payout_wallet_confirmed";
+                    vapi_verified: "vapi_verified";
+                    external_catalog: "external_catalog";
+                    approved_vendor: "approved_vendor";
+                }>;
+                label: z.ZodString;
+            }, z.core.$strict>>;
+            facts: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "provenance">, z.ZodObject<{
+        kind: z.ZodLiteral<"service_offer">;
+        action: z.ZodObject<{
+            type: z.ZodLiteral<"start_engagement">;
+            href: z.ZodUnion<readonly [z.ZodString, z.ZodURL]>;
+        }, z.core.$strict>;
+        ref: z.ZodString;
+        card: z.ZodObject<{
+            title: z.ZodString;
+            summary: z.ZodString;
+            byline: z.ZodOptional<z.ZodString>;
+            bylineHref: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodURL]>>;
+            badges: z.ZodArray<z.ZodObject<{
+                code: z.ZodEnum<{
+                    partner: "partner";
+                    live_x402: "live_x402";
+                    payout_wallet_confirmed: "payout_wallet_confirmed";
+                    vapi_verified: "vapi_verified";
+                    external_catalog: "external_catalog";
+                    approved_vendor: "approved_vendor";
+                }>;
+                label: z.ZodString;
+            }, z.core.$strict>>;
+            facts: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"open_request">;
+        action: z.ZodObject<{
+            type: z.ZodLiteral<"propose_to_request">;
+            href: z.ZodUnion<readonly [z.ZodString, z.ZodURL]>;
+        }, z.core.$strict>;
+        ref: z.ZodString;
+        card: z.ZodObject<{
+            title: z.ZodString;
+            summary: z.ZodString;
+            byline: z.ZodOptional<z.ZodString>;
+            bylineHref: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodURL]>>;
+            badges: z.ZodArray<z.ZodObject<{
+                code: z.ZodEnum<{
+                    partner: "partner";
+                    live_x402: "live_x402";
+                    payout_wallet_confirmed: "payout_wallet_confirmed";
+                    vapi_verified: "vapi_verified";
+                    external_catalog: "external_catalog";
+                    approved_vendor: "approved_vendor";
+                }>;
+                label: z.ZodString;
+            }, z.core.$strict>>;
+            facts: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>]>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+    unavailableKinds: z.ZodArray<z.ZodEnum<{
+        api: "api";
+        service_offer: "service_offer";
+        open_request: "open_request";
+    }>>;
+    rankingVersion: z.ZodLiteral<"marketplace-ranking-v1">;
+}, z.core.$strict>;
+export type MarketplaceDiscoveryPage = z.infer<typeof marketplaceDiscoveryPageSchema>;
+//# sourceMappingURL=marketplace-contracts.d.ts.map

package/dist/marketplace-contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"marketplace-contracts.d.ts","sourceRoot":"","sources":["../src/marketplace-contracts.ts"],"names":[],"mappings":"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"}

package/dist/net-guard.d.ts

@@ -0,0 +1,13 @@
+import { type LookupFunction } from "node:net";
+export type LookupFn = (hostname: string) => Promise<string[]>;
+export declare function assertPublicUrl(url: URL, options: {
+    allowPrivateNetwork: boolean;
+    lookup?: LookupFn;
+    timeoutMs?: number;
+}): Promise<void>;
+export declare function createPublicFetch(options: {
+    allowPrivateNetwork: boolean;
+    lookup?: LookupFn;
+}): typeof fetch;
+export declare function pinnedLookup(lookup: LookupFn): LookupFunction;
+//# sourceMappingURL=net-guard.d.ts.map

package/dist/net-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"net-guard.d.ts","sourceRoot":"","sources":["../src/net-guard.ts"],"names":[],"mappings":"AAGA,OAAO,EAAQ,KAAK,cAAc,EAAE,MAAM,UAAU,CAAC;AAGrD,MAAM,MAAM,QAAQ,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;AAO/D,wBAAsB,eAAe,CACnC,GAAG,EAAE,GAAG,EACR,OAAO,EAAE;IAAE,mBAAmB,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,QAAQ,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/E,OAAO,CAAC,IAAI,CAAC,CA0Cf;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE;IACzC,mBAAmB,EAAE,OAAO,CAAC;IAC7B,MAAM,CAAC,EAAE,QAAQ,CAAC;CACnB,GAAG,OAAO,KAAK,CAmDf;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,QAAQ,GAAG,cAAc,CAoB7D"}

package/dist/networks.d.ts

@@ -0,0 +1,49 @@
+import { ARC_TESTNET_CAIP2, BASE_MAINNET_CAIP2 } from "./x402-networks.js";
+import { type Address, type Chain, type HttpTransport, type PublicClient } from "viem";
+import { type LookupFn } from "./net-guard.js";
+export { ARC_TESTNET_CAIP2, BASE_MAINNET_CAIP2 };
+export declare const USDC_DECIMALS = 6;
+export declare const DEFAULT_ARC_GAS_HEADROOM_ATOMIC = 50000n;
+export type NetworkDefinition = {
+    chainId: number;
+    name: string;
+    usdc: Address;
+    gasToken: "ETH" | "USDC";
+    rpcEnv: string;
+    publicRpcUrl?: string;
+};
+export type ConfiguredNetwork = {
+    rpcUrl: string;
+    usdc: Address;
+};
+export type NetworkTransportOptions = {
+    allowPrivateNetwork?: boolean;
+    fetch?: typeof fetch;
+    lookup?: LookupFn;
+};
+export declare const NETWORKS: {
+    readonly "eip155:8453": {
+        readonly chainId: 8453;
+        readonly name: "Base mainnet";
+        readonly usdc: `0x${string}`;
+        readonly gasToken: "ETH";
+        readonly rpcEnv: "BASE_RPC_URL";
+        readonly publicRpcUrl: "https://mainnet.base.org";
+    };
+    readonly "eip155:5042002": {
+        readonly chainId: 5042002;
+        readonly name: "Arc testnet";
+        readonly usdc: `0x${string}`;
+        readonly gasToken: "USDC";
+        readonly rpcEnv: "ARC_TESTNET_RPC_URL";
+    };
+};
+export declare function parseEip155ChainId(network: string): number;
+export declare function getNetworkDefinition(network: string): NetworkDefinition;
+export declare function requireRpcUrl(network: string, configured: ConfiguredNetwork): string;
+export declare function createChain(network: string, rpcUrl: string): Chain;
+export declare function createNetworkPublicClient(network: string, configured: ConfiguredNetwork, options?: NetworkTransportOptions): PublicClient;
+/** Create a JSON-RPC transport whose default fetch validates and pins destinations. */
+export declare function createNetworkHttpTransport(rpcUrl: string, options?: NetworkTransportOptions): HttpTransport;
+export declare function formatUsdc(amountAtomic: bigint): string;
+//# sourceMappingURL=networks.d.ts.map

package/dist/networks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"networks.d.ts","sourceRoot":"","sources":["../src/networks.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAEnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAML,KAAK,OAAO,EACZ,KAAK,KAAK,EACV,KAAK,aAAa,EAClB,KAAK,YAAY,EAClB,MAAM,MAAM,CAAC;AAEd,OAAO,EAAqB,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAElE,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,CAAC;AACjD,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,+BAA+B,SAAU,CAAC;AAEvD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,KAAK,GAAG,MAAM,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IACpC,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,MAAM,CAAC,EAAE,QAAQ,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;CAgBiC,CAAC;AAEvD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAU1D;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,iBAAiB,CAavE;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,iBAAiB,GAAG,MAAM,CAapF;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,CAalE;AAED,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,iBAAiB,EAC7B,OAAO,GAAE,uBAA4B,GACpC,YAAY,CAMd;AAED,uFAAuF;AACvF,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,uBAA4B,GACpC,aAAa,CAQf;AAED,wBAAgB,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAEvD"}