@ghostspeak/sdk 2.0.5 → 2.0.6

package/dist/{GhostSpeakClient-hsGuGg__.d.ts → GhostSpeakClient-D_66Uzsf.d.ts}

@@ -3,6 +3,7 @@ import { TransactionSigner } from '@solana/kit';
 import { P as ProposalTypeArgs, E as ExecutionParamsArgs, V as VoteChoice, G as GovernanceProposal } from './ipfs-types-BOt9ZNg4.js';
 import { Address } from '@solana/addresses';
 import { M as MultisigConfigArgs } from './multisigConfig-BzEhy6jy.js';
+import { CrossmintClientOptions } from './credentials.js';
 
 interface CreateMultisigParams {
     multisigId: bigint;
@@ -53,160 +54,6 @@ declare class MultisigModule extends BaseModule {
     executeProposal(params: ExecuteProposalParams): Promise<string>;
 }
 
-/**
- * Crossmint Verifiable Credentials API Client
- *
- * Integrates with Crossmint's VC system to issue and verify credentials.
- * Ported from packages/web for SDK consumption.
- */
-declare const GHOSTSPEAK_CREDENTIAL_TYPES: {
-    readonly AGENT_IDENTITY: "GhostSpeakAgentIdentity";
-    readonly REPUTATION_SCORE: "GhostSpeakReputation";
-    readonly JOB_COMPLETION: "GhostSpeakJobCompletion";
-};
-interface ActionResponse {
-    id: string;
-    status: string;
-    data?: {
-        collection?: CredentialTemplate$1;
-    };
-}
-interface CredentialType$1 {
-    id: string;
-    typeSchema: {
-        $schema: string;
-        $id: string;
-        title: string;
-        description: string;
-        type: string;
-        properties: Record<string, unknown>;
-    };
-}
-interface CredentialTemplate$1 {
-    id: string;
-    metadata: {
-        name: string;
-        description: string;
-        imageUrl: string;
-    };
-    fungibility: string;
-    onChain: {
-        chain: string;
-        type: string;
-    };
-    actionId: string;
-}
-interface IssuedCredential {
-    id: string;
-    credentialId: string;
-    onChain: {
-        status: 'pending' | 'completed';
-        chain: string;
-        contractAddress: string;
-        tokenId?: string;
-    };
-    actionId: string;
-}
-interface VerificationResult {
-    isValid: boolean;
-    errors?: string[];
-}
-interface CrossmintClientOptions {
-    apiKey: string;
-    environment?: 'staging' | 'production';
-    chain?: 'base-sepolia' | 'polygon-amoy' | 'ethereum-sepolia' | 'base' | 'polygon' | 'ethereum';
-}
-/**
- * Crossmint Verifiable Credentials Client
- *
- * Handles the complete credential lifecycle:
- * 1. Create credential types (JSON schemas)
- * 2. Create credential templates (on-chain configuration)
- * 3. Issue credentials to recipients
- * 4. Retrieve credentials
- * 5. Verify credentials
- * 6. Revoke credentials
- *
- * NOTE: Crossmint VCs are only supported on EVM chains.
- */
-declare class CrossmintVCClient {
-    private apiKey;
-    private baseUrl;
-    private chain;
-    constructor(options: CrossmintClientOptions);
-    /**
-     * Create the GhostSpeak Agent Identity credential type
-     */
-    createAgentIdentityType(): Promise<CredentialType$1>;
-    /**
-     * Create the GhostSpeak Reputation credential type
-     */
-    createReputationType(): Promise<CredentialType$1>;
-    /**
-     * Create the GhostSpeak Job Completion credential type
-     */
-    createJobCompletionType(): Promise<CredentialType$1>;
-    /**
-     * Initialize all GhostSpeak credential types
-     */
-    initializeAllTypes(): Promise<{
-        agentIdentity: CredentialType$1;
-        reputation: CredentialType$1;
-        jobCompletion: CredentialType$1;
-    }>;
-    /**
-     * Create all GhostSpeak credential templates
-     */
-    createAllTemplates(types: {
-        agentIdentity: CredentialType$1;
-        reputation: CredentialType$1;
-        jobCompletion: CredentialType$1;
-    }): Promise<{
-        agentIdentityTemplate: CredentialTemplate$1;
-        reputationTemplate: CredentialTemplate$1;
-        jobCompletionTemplate: CredentialTemplate$1;
-    }>;
-    /**
-     * Issue an agent identity credential
-     */
-    issueAgentCredential(templateId: string, recipientEmail: string, subject: Record<string, unknown>, expiresAt?: string): Promise<IssuedCredential>;
-    /**
-     * Issue a reputation credential
-     */
-    issueReputationCredential(templateId: string, recipientEmail: string, subject: Record<string, unknown>, expiresAt?: string): Promise<IssuedCredential>;
-    /**
-     * Issue a job completion credential
-     */
-    issueJobCompletionCredential(templateId: string, recipientEmail: string, subject: Record<string, unknown>, expiresAt?: string): Promise<IssuedCredential>;
-    /**
-     * Create a credential type (JSON Schema)
-     */
-    createCredentialType(typeName: string, schema: Record<string, unknown>): Promise<CredentialType$1>;
-    /**
-     * Create a credential template
-     */
-    createTemplate(typeId: string, metadata: {
-        name: string;
-        description: string;
-        imageUrl: string;
-    }): Promise<CredentialTemplate$1>;
-    /**
-     * Poll an action until completion
-     */
-    waitForAction(actionId: string): Promise<ActionResponse>;
-    /**
-     * Issue a credential using a template
-     */
-    issueCredential(templateId: string, recipientEmail: string, subject: Record<string, unknown>, expiresAt?: string): Promise<IssuedCredential>;
-    getCredential(credentialId: string): Promise<unknown>;
-    verifyCredential(credential: unknown): Promise<VerificationResult>;
-    revokeCredential(credentialId: string): Promise<{
-        actionId: string;
-        status: string;
-    }>;
-    private getDefaultExpiry;
-}
-
 /**
  * GhostSpeak Credential Module
  *
@@ -857,4 +704,4 @@ declare function sol(amount: number): bigint;
  */
 declare function lamportsToSol(lamports: bigint): number;
 
-export { CredentialModule as C, GhostSpeakClient as G, type IssuedCredentialResult as I, MultisigModule as M, UnifiedCredentialService as U, type W3CVerifiableCredential as W, CredentialKind as a, CredentialStatus as b, type Credential as c, type CredentialTemplate as d, type UnifiedCredentialConfig as e, CrossmintVCClient as f, type CrossmintClientOptions as g, type CredentialType$1 as h, type IssuedCredential as i, GHOSTSPEAK_CREDENTIAL_TYPES as j, lamportsToSol as l, sol as s };
+export { CredentialModule as C, GhostSpeakClient as G, type IssuedCredentialResult as I, MultisigModule as M, UnifiedCredentialService as U, type W3CVerifiableCredential as W, CredentialKind as a, CredentialStatus as b, type Credential as c, type CredentialTemplate as d, type UnifiedCredentialConfig as e, lamportsToSol as l, sol as s };

package/dist/browser.js

@@ -4,11 +4,11 @@ export { AgentModule, ChannelModule, EscrowModule, GHOSTSPEAK_PROGRAM_ID, Govern
 import { REPUTATION_CONSTANTS } from './chunk-OWYHJG6H.js';
 export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, BadgeType, NATIVE_MINT_ADDRESS, REPUTATION_CONSTANTS, ReputationTier, TOKEN_2022_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS } from './chunk-OWYHJG6H.js';
 import { getInitializeStakingConfigInstructionAsync, getCreateStakingAccountInstructionAsync, getClaimStakingRewardsInstructionAsync } from './chunk-COGZFWOT.js';
+import './chunk-GMHIUK2R.js';
 export { deriveAgentPda, deriveAgentPdaOriginal, deriveChannelPda, deriveEscrowPda, deriveJobPostingPda, deriveMessagePda, deriveServiceListingPda, deriveUserRegistryPda } from './chunk-ASQXX4IT.js';
 import './chunk-RERCHKZP.js';
 import './chunk-RDDPOFR5.js';
 import './chunk-SRS2SKFS.js';
-import './chunk-GMHIUK2R.js';
 import './chunk-NSBPE2FW.js';
 import { getProgramDerivedAddress, getBytesEncoder, getAddressEncoder, getUtf8Encoder } from '@solana/kit';
 

package/dist/{chunk-FKRN4PW5.js → chunk-APCKGD23.js}

@@ -1,6 +1,7 @@
 import { BaseModule, AgentModule, EscrowModule, ChannelModule, MarketplaceModule, GovernanceModule, Token2022Module } from './chunk-TVVGXYCI.js';
 import { deriveMultisigPda } from './chunk-ZGP5552B.js';
 import { getCreateMultisigInstruction, getInitializeGovernanceProposalInstructionAsync, getCastVoteInstruction, getExecuteProposalInstruction, GHOSTSPEAK_MARKETPLACE_PROGRAM_ADDRESS } from './chunk-COGZFWOT.js';
+import { CrossmintVCClient } from './chunk-RIZZPLLB.js';
 import { sha256 } from '@noble/hashes/sha256';
 import bs58 from 'bs58';
 
@@ -74,346 +75,6 @@ var MultisigModule = class extends BaseModule {
     return this.execute("executeProposal", () => instruction, [params.executor]);
   }
 };
-
-// src/modules/credentials/CrossmintVCClient.ts
-var CROSSMINT_STAGING_URL = "https://staging.crossmint.com";
-var CROSSMINT_PROD_URL = "https://www.crossmint.com";
-var GHOSTSPEAK_CREDENTIAL_TYPES = {
-  AGENT_IDENTITY: "GhostSpeakAgentIdentity",
-  REPUTATION_SCORE: "GhostSpeakReputation",
-  JOB_COMPLETION: "GhostSpeakJobCompletion"
-};
-var CrossmintVCClient = class {
-  apiKey;
-  baseUrl;
-  chain;
-  constructor(options) {
-    this.apiKey = options.apiKey;
-    this.baseUrl = options.environment === "production" ? CROSSMINT_PROD_URL : CROSSMINT_STAGING_URL;
-    this.chain = options.chain || "base-sepolia";
-  }
-  // ===================================
-  // Types & Templates
-  // ===================================
-  /**
-   * Create the GhostSpeak Agent Identity credential type
-   */
-  async createAgentIdentityType() {
-    const typeName = GHOSTSPEAK_CREDENTIAL_TYPES.AGENT_IDENTITY;
-    const schema = {
-      $schema: "https://json-schema.org/draft/2020-12/schema",
-      title: "GhostSpeak Agent Identity",
-      description: "Verified AI agent identity on the GhostSpeak Protocol",
-      type: "object",
-      properties: {
-        credentialSubject: {
-          type: "object",
-          properties: {
-            agentId: { type: "string" },
-            owner: { type: "string" },
-            capabilities: { type: "array", items: { type: "string" } },
-            registeredAt: { type: "string" },
-            reputationScore: { type: "number" },
-            totalJobsCompleted: { type: "integer" },
-            verified: { type: "boolean" },
-            id: { type: "string" }
-            // Auto-added by Crossmint
-          },
-          required: ["agentId", "owner", "capabilities", "registeredAt", "verified"],
-          additionalProperties: false
-        }
-      }
-    };
-    return this.createCredentialType(typeName, schema);
-  }
-  /**
-   * Create the GhostSpeak Reputation credential type
-   */
-  async createReputationType() {
-    const typeName = GHOSTSPEAK_CREDENTIAL_TYPES.REPUTATION_SCORE;
-    const schema = {
-      $schema: "https://json-schema.org/draft/2020-12/schema",
-      title: "GhostSpeak Reputation",
-      description: "Verified reputation score for GhostSpeak users",
-      type: "object",
-      properties: {
-        credentialSubject: {
-          type: "object",
-          properties: {
-            userId: { type: "string" },
-            walletAddress: { type: "string" },
-            reputationScore: { type: "number" },
-            totalTransactions: { type: "integer" },
-            disputeRate: { type: "number" },
-            memberSince: { type: "string" },
-            id: { type: "string" }
-          },
-          required: ["userId", "walletAddress", "reputationScore", "memberSince"],
-          additionalProperties: false
-        }
-      }
-    };
-    return this.createCredentialType(typeName, schema);
-  }
-  /**
-   * Create the GhostSpeak Job Completion credential type
-   */
-  async createJobCompletionType() {
-    const typeName = GHOSTSPEAK_CREDENTIAL_TYPES.JOB_COMPLETION;
-    const schema = {
-      $schema: "https://json-schema.org/draft/2020-12/schema",
-      title: "GhostSpeak Job Completion",
-      description: "Certificate of successful job completion on GhostSpeak",
-      type: "object",
-      properties: {
-        credentialSubject: {
-          type: "object",
-          properties: {
-            jobId: { type: "string" },
-            agentId: { type: "string" },
-            clientAddress: { type: "string" },
-            completedAt: { type: "string" },
-            amountPaid: { type: "string" },
-            rating: { type: "integer" },
-            review: { type: "string" },
-            id: { type: "string" }
-          },
-          required: ["jobId", "agentId", "clientAddress", "completedAt", "amountPaid", "rating"],
-          additionalProperties: false
-        }
-      }
-    };
-    return this.createCredentialType(typeName, schema);
-  }
-  /**
-   * Initialize all GhostSpeak credential types
-   */
-  async initializeAllTypes() {
-    const [agentIdentity, reputation, jobCompletion] = await Promise.all([
-      this.createAgentIdentityType(),
-      this.createReputationType(),
-      this.createJobCompletionType()
-    ]);
-    return { agentIdentity, reputation, jobCompletion };
-  }
-  /**
-   * Create all GhostSpeak credential templates
-   */
-  async createAllTemplates(types) {
-    const [agentIdentityTemplate, reputationTemplate, jobCompletionTemplate] = await Promise.all([
-      this.createTemplate(types.agentIdentity.id, {
-        name: "GhostSpeak Agent Identity",
-        description: "Verified AI agent identity on the GhostSpeak Protocol",
-        imageUrl: "https://www.ghostspeak.io/assets/credential-agent.png"
-      }),
-      this.createTemplate(types.reputation.id, {
-        name: "GhostSpeak Reputation",
-        description: "Verified reputation score for GhostSpeak users",
-        imageUrl: "https://www.ghostspeak.io/assets/credential-reputation.png"
-      }),
-      this.createTemplate(types.jobCompletion.id, {
-        name: "GhostSpeak Job Completion Certificate",
-        description: "Certificate of successful job completion on GhostSpeak",
-        imageUrl: "https://www.ghostspeak.io/assets/credential-job.png"
-      })
-    ]);
-    return { agentIdentityTemplate, reputationTemplate, jobCompletionTemplate };
-  }
-  /**
-   * Issue an agent identity credential
-   */
-  async issueAgentCredential(templateId, recipientEmail, subject, expiresAt) {
-    return this.issueCredential(templateId, recipientEmail, subject, expiresAt);
-  }
-  /**
-   * Issue a reputation credential
-   */
-  async issueReputationCredential(templateId, recipientEmail, subject, expiresAt) {
-    return this.issueCredential(templateId, recipientEmail, subject, expiresAt);
-  }
-  /**
-   * Issue a job completion credential
-   */
-  async issueJobCompletionCredential(templateId, recipientEmail, subject, expiresAt) {
-    return this.issueCredential(templateId, recipientEmail, subject, expiresAt);
-  }
-  /**
-   * Create a credential type (JSON Schema)
-   */
-  async createCredentialType(typeName, schema) {
-    const response = await fetch(
-      `${this.baseUrl}/api/v1-alpha1/credentials/types/${typeName}`,
-      {
-        method: "PUT",
-        headers: {
-          "Content-Type": "application/json",
-          "X-API-KEY": this.apiKey
-        },
-        body: JSON.stringify(schema)
-      }
-    );
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ message: response.statusText }));
-      throw new Error(`Failed to create credential type: ${JSON.stringify(error)}`);
-    }
-    return response.json();
-  }
-  /**
-   * Create a credential template
-   */
-  async createTemplate(typeId, metadata) {
-    const response = await fetch(
-      `${this.baseUrl}/api/v1-alpha1/credentials/templates/`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-API-KEY": this.apiKey
-        },
-        body: JSON.stringify({
-          credentials: {
-            type: typeId,
-            encryption: "none",
-            storage: "crossmint"
-          },
-          metadata,
-          chain: this.chain
-        })
-      }
-    );
-    if (!response.ok) {
-      const text = await response.text();
-      try {
-        const error = JSON.parse(text);
-        throw new Error(`Failed to create template: ${JSON.stringify(error)}`);
-      } catch (e) {
-        throw new Error(`Failed to create template (${response.status}): ${text}`);
-      }
-    }
-    const action = await response.json();
-    const result = await this.waitForAction(action.id);
-    if (result.data && result.data.collection) {
-      return result.data.collection;
-    }
-    return result.data || result;
-  }
-  /**
-   * Poll an action until completion
-   */
-  async waitForAction(actionId) {
-    let retries = 0;
-    while (retries < 60) {
-      await new Promise((resolve) => setTimeout(resolve, 2e3));
-      const response = await fetch(
-        `${this.baseUrl}/api/2022-06-09/actions/${actionId}`,
-        {
-          headers: {
-            "X-API-KEY": this.apiKey
-          }
-        }
-      );
-      if (!response.ok) {
-        throw new Error(`Failed to poll action: ${response.statusText}`);
-      }
-      const action = await response.json();
-      if (action.status === "succeeded") {
-        return action;
-      }
-      if (action.status === "failed") {
-        throw new Error(`Action failed: ${JSON.stringify(action)}`);
-      }
-      retries++;
-    }
-    throw new Error("Action polling timed out");
-  }
-  // ===================================
-  // Issuance
-  // ===================================
-  /**
-   * Issue a credential using a template
-   */
-  async issueCredential(templateId, recipientEmail, subject, expiresAt) {
-    const response = await fetch(
-      `${this.baseUrl}/api/v1-alpha1/credentials/templates/${templateId}/vcs`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-API-KEY": this.apiKey
-        },
-        body: JSON.stringify({
-          recipient: `email:${recipientEmail}:${this.chain}`,
-          credential: {
-            subject,
-            expiresAt: expiresAt || this.getDefaultExpiry()
-          }
-        })
-      }
-    );
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ message: response.statusText }));
-      throw new Error(`Failed to issue credential: ${JSON.stringify(error)}`);
-    }
-    return response.json();
-  }
-  // ===================================
-  // Verification & Retrieval
-  // ===================================
-  async getCredential(credentialId) {
-    const response = await fetch(
-      `${this.baseUrl}/api/v1-alpha1/credentials/${credentialId}`,
-      {
-        headers: {
-          "X-API-KEY": this.apiKey
-        }
-      }
-    );
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ message: response.statusText }));
-      throw new Error(`Failed to get credential: ${JSON.stringify(error)}`);
-    }
-    return response.json();
-  }
-  async verifyCredential(credential) {
-    const response = await fetch(
-      `${this.baseUrl}/api/v1-alpha1/credentials/verification/verify`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "X-API-KEY": this.apiKey
-        },
-        body: JSON.stringify({ credential })
-      }
-    );
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ message: response.statusText }));
-      throw new Error(`Failed to verify credential: ${JSON.stringify(error)}`);
-    }
-    return response.json();
-  }
-  async revokeCredential(credentialId) {
-    const response = await fetch(
-      `${this.baseUrl}/api/v1-alpha1/credentials/${credentialId}`,
-      {
-        method: "DELETE",
-        headers: {
-          "X-API-KEY": this.apiKey
-        }
-      }
-    );
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ message: response.statusText }));
-      throw new Error(`Failed to revoke credential: ${JSON.stringify(error)}`);
-    }
-    return response.json();
-  }
-  getDefaultExpiry() {
-    const date = /* @__PURE__ */ new Date();
-    date.setFullYear(date.getFullYear() + 1);
-    return date.toISOString().split("T")[0];
-  }
-};
 var base58Encode = (data) => bs58.encode(data);
 var DEFAULT_PROGRAM_ID = "GHosT3wqDfNq9bKz8dNEQ1F5mLuN7bKdNYx3Z1111111";
 var CredentialKind = /* @__PURE__ */ ((CredentialKind2) => {
@@ -1662,6 +1323,6 @@ function lamportsToSol(lamports) {
 }
 var GhostSpeakClient_default = GhostSpeakClient;
 
-export { CredentialKind, CredentialModule, CredentialStatus, CrossmintVCClient, GHOSTSPEAK_CREDENTIAL_TYPES, GhostSpeakClient, GhostSpeakClient_default, MultisigModule, UnifiedCredentialService, lamportsToSol, sol };
-//# sourceMappingURL=chunk-FKRN4PW5.js.map
-//# sourceMappingURL=chunk-FKRN4PW5.js.map
+export { CredentialKind, CredentialModule, CredentialStatus, GhostSpeakClient, GhostSpeakClient_default, MultisigModule, UnifiedCredentialService, lamportsToSol, sol };
+//# sourceMappingURL=chunk-APCKGD23.js.map
+//# sourceMappingURL=chunk-APCKGD23.js.map