@svsprotocol/solana 0.1.0

package/dist/elizaos.d.ts

@@ -0,0 +1,43 @@
+import type {
+  SvsAdapterActionInput,
+  SvsAdapterActionResult,
+  SvsAdapterOptions,
+  SvsAdapterReadinessResult,
+  JsonObject
+} from "./common.js";
+import { SvsAdapterCoreError } from "./adapter-core.js";
+
+export const ELIZAOS_ADAPTER_VERSION: "svs.elizaos-adapter.v1";
+export const ELIZAOS_PLUGIN_NAME: "svs-solana-verification";
+export const ELIZAOS_ACTION_NAME: "SVS_VERIFY_AND_SUBMIT_SOLANA_ACTION";
+
+export class SvsElizaOsAdapterError extends SvsAdapterCoreError {}
+
+export interface SvsElizaOsAction {
+  name: typeof ELIZAOS_ACTION_NAME;
+  client: unknown;
+  similes: string[];
+  description: string;
+  examples: unknown[];
+  validate(): Promise<boolean>;
+  handler(runtime: unknown, message: unknown, state: unknown, options?: Partial<SvsAdapterActionInput>, callback?: (response: JsonObject) => unknown): Promise<{
+    success: boolean;
+    text: string;
+    data: SvsAdapterActionResult | JsonObject;
+  }>;
+}
+
+export interface SvsElizaOsPlugin {
+  name: typeof ELIZAOS_PLUGIN_NAME;
+  description: string;
+  actions: SvsElizaOsAction[];
+  providers: unknown[];
+  evaluators: unknown[];
+  services: unknown[];
+}
+
+export function createSvsElizaOsPlugin(options: SvsAdapterOptions): SvsElizaOsPlugin;
+export function createSvsElizaOsAction(options: SvsAdapterOptions): SvsElizaOsAction;
+export function requireSvsElizaOsProductionReady(options: SvsAdapterOptions): Promise<SvsAdapterReadinessResult>;
+export function verifyAndSubmitElizaOsSolanaAction(options: SvsAdapterOptions & SvsAdapterActionInput): Promise<SvsAdapterActionResult>;
+export function normalizeElizaOsActionInput(options?: { message?: unknown; state?: unknown; options?: JsonObject }): Partial<SvsAdapterActionInput>;

package/dist/elizaos.js

@@ -0,0 +1,227 @@
+import {
+  SvsAdapterCoreError,
+  createSvsAdapterClient,
+  requireSvsAdapterProductionReady,
+  verifyAndSubmitSvsAdapterSolanaAction
+} from "./adapter-core.js";
+
+export const ELIZAOS_ADAPTER_VERSION = "svs.elizaos-adapter.v1";
+export const ELIZAOS_PLUGIN_NAME = "svs-solana-verification";
+export const ELIZAOS_ACTION_NAME = "SVS_VERIFY_AND_SUBMIT_SOLANA_ACTION";
+
+export class SvsElizaOsAdapterError extends SvsAdapterCoreError {
+  constructor(message, details = {}) {
+    super(message, details);
+    this.name = "SvsElizaOsAdapterError";
+  }
+}
+
+export function createSvsElizaOsPlugin(options = {}) {
+  const action = createSvsElizaOsAction(options);
+
+  return {
+    name: ELIZAOS_PLUGIN_NAME,
+    description: "SVS Agent Verification actions for human-approved Solana automation.",
+    actions: [action],
+    providers: [],
+    evaluators: [],
+    services: []
+  };
+}
+
+export function createSvsElizaOsAction({
+  client = null,
+  baseUrl,
+  apiKey,
+  requestSigningSecret,
+  expectedIntegrationContractHash,
+  botId,
+  policyId = null,
+  rpcUrl = null,
+  certificationStaleAfterMs = undefined,
+  requireCurrentIntegrationContract = true,
+  waitForProof = false,
+  waitAttempts = 12,
+  waitIntervalMs = 5000,
+  fetchProof = true,
+  checkReceiptRegistryChain = true,
+  requireReadinessOnSubmit = true
+} = {}) {
+  if (!botId) {
+    throw new Error("botId is required.");
+  }
+
+  const svs = createSvsAdapterClient({
+    client,
+    baseUrl,
+    apiKey,
+    requestSigningSecret,
+    expectedIntegrationContractHash
+  });
+  const defaults = {
+    botId,
+    policyId,
+    rpcUrl,
+    certificationStaleAfterMs,
+    requireCurrentIntegrationContract,
+    waitForProof,
+    waitAttempts,
+    waitIntervalMs,
+    fetchProof,
+    checkReceiptRegistryChain,
+    requireReadinessOnSubmit
+  };
+
+  return {
+    name: ELIZAOS_ACTION_NAME,
+    client: svs,
+    similes: [
+      "VERIFY_SOLANA_ACTION",
+      "SUBMIT_SOLANA_ACTION_WITH_SVS",
+      "HUMAN_APPROVED_SOLANA_ACTION"
+    ],
+    description: "Use SVS to require bot readiness, production certification, human approval, policy checks, and portable proof before trusting a Solana action.",
+    examples: [
+      [
+        {
+          user: "{{user1}}",
+          content: {
+            text: "Submit this Solana transaction only if SVS can verify it."
+          }
+        },
+        {
+          user: "{{agent}}",
+          content: {
+            text: "I will submit it through SVS for human approval and proof-backed execution.",
+            action: ELIZAOS_ACTION_NAME
+          }
+        }
+      ]
+    ],
+    async validate() {
+      try {
+        await requireSvsElizaOsProductionReady({
+          client: svs,
+          ...defaults
+        });
+
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async handler(runtime, message, state, options = {}, callback) {
+      try {
+        const input = normalizeElizaOsActionInput({ message, state, options });
+        const result = await verifyAndSubmitElizaOsSolanaAction({
+          client: svs,
+          ...defaults,
+          ...omitUndefined(input)
+        });
+        const response = {
+          success: result.ok === true,
+          text: result.nextAction?.message ?? `SVS action ${result.status}.`,
+          data: result
+        };
+
+        if (typeof callback === "function") {
+          await callback({
+            text: response.text,
+            action: ELIZAOS_ACTION_NAME,
+            data: result
+          });
+        }
+
+        return response;
+      } catch (error) {
+        const response = {
+          success: false,
+          text: error.message,
+          data: {
+            version: "svs.elizaos-action-error.v1",
+            ok: false,
+            status: "failed",
+            error: error.message,
+            details: error.details ?? null
+          }
+        };
+
+        if (typeof callback === "function") {
+          await callback({
+            text: response.text,
+            action: ELIZAOS_ACTION_NAME,
+            data: response.data
+          });
+        }
+
+        return response;
+      }
+    }
+  };
+}
+
+export async function requireSvsElizaOsProductionReady({
+  ...options
+} = {}) {
+  return requireSvsAdapterProductionReady({
+    ...options,
+    readinessVersion: "svs.elizaos-readiness.v1",
+    readyMessage: "SVS ElizaOS action readiness and production certification passed.",
+    adapterLabel: "ElizaOS adapter",
+    ErrorClass: SvsElizaOsAdapterError
+  });
+}
+
+export async function verifyAndSubmitElizaOsSolanaAction({
+  ...options
+} = {}) {
+  return verifyAndSubmitSvsAdapterSolanaAction({
+    ...options,
+    adapterVersion: ELIZAOS_ADAPTER_VERSION,
+    agentFramework: "elizaos",
+    resultVersion: "svs.elizaos-action-result.v1",
+    readinessVersion: "svs.elizaos-readiness.v1",
+    readyMessage: "SVS ElizaOS action readiness and production certification passed.",
+    adapterLabel: "ElizaOS adapter",
+    ErrorClass: SvsElizaOsAdapterError
+  });
+}
+
+export function normalizeElizaOsActionInput({ message = null, state = null, options = {} } = {}) {
+  const content = message?.content ?? {};
+  const source = {
+    ...(options.source ?? {}),
+    elizaMessageId: message?.id ?? message?.uuid ?? null,
+    elizaRoomId: message?.roomId ?? message?.room_id ?? null,
+    elizaUserId: message?.userId ?? message?.user_id ?? null,
+    elizaStateId: state?.id ?? null
+  };
+
+  return {
+    requestId: options.requestId ?? content.requestId ?? content.idempotencyKey ?? null,
+    idempotencyKey: options.idempotencyKey ?? options.requestId ?? content.idempotencyKey ?? content.requestId ?? null,
+    intent: options.intent ?? content.intent ?? null,
+    serializedTransaction: options.serializedTransaction ??
+      options.transaction?.serializedTransaction ??
+      content.serializedTransaction ??
+      content.transaction?.serializedTransaction ??
+      null,
+    policyId: options.policyId ?? content.policyId ?? undefined,
+    rpcUrl: options.rpcUrl ?? content.rpcUrl ?? undefined,
+    simulation: options.simulation ?? content.simulation ?? null,
+    metadata: options.metadata ?? content.metadata ?? null,
+    waitForProof: options.waitForProof ?? content.waitForProof ?? undefined,
+    waitAttempts: options.waitAttempts ?? content.waitAttempts ?? undefined,
+    waitIntervalMs: options.waitIntervalMs ?? content.waitIntervalMs ?? undefined,
+    fetchProof: options.fetchProof ?? content.fetchProof ?? undefined,
+    checkReceiptRegistryChain: options.checkReceiptRegistryChain ?? content.checkReceiptRegistryChain ?? undefined,
+    requireReadinessOnSubmit: options.requireReadinessOnSubmit ?? content.requireReadinessOnSubmit ?? undefined,
+    source
+  };
+}
+
+function omitUndefined(value) {
+  return Object.fromEntries(
+    Object.entries(value ?? {}).filter(([, entryValue]) => entryValue !== undefined)
+  );
+}

package/dist/goat.d.ts

@@ -0,0 +1,47 @@
+import type {
+  SvsAdapterActionInput,
+  SvsAdapterActionResult,
+  SvsAdapterOptions,
+  SvsAdapterReadinessResult,
+  JsonObject
+} from "./common.js";
+import { SvsAdapterCoreError } from "./adapter-core.js";
+
+export const GOAT_ADAPTER_VERSION: "svs.goat-adapter.v1";
+export const GOAT_PLUGIN_NAME: "svs-solana-verification";
+export const GOAT_TOOL_NAME: "svs_verify_and_submit_solana_action";
+
+export class SvsGoatAdapterError extends SvsAdapterCoreError {}
+
+export interface SvsGoatTool {
+  name: typeof GOAT_TOOL_NAME;
+  description: string;
+  parameters: unknown;
+  version?: typeof GOAT_ADAPTER_VERSION;
+  execute(parameters: SvsAdapterActionInput): Promise<SvsAdapterActionResult>;
+  handler?: (parameters: SvsAdapterActionInput) => Promise<SvsAdapterActionResult>;
+}
+
+export interface SvsGoatPlugin {
+  version: typeof GOAT_ADAPTER_VERSION;
+  name: typeof GOAT_PLUGIN_NAME;
+  description: string;
+  botId: string;
+  policyId: string | null;
+  rpcUrl: string | null;
+  client: unknown;
+  tool: SvsGoatTool | unknown;
+  tools: unknown[];
+  supportsChain(chain?: unknown): boolean;
+  requireSvsProductionReady(options?: Partial<SvsAdapterOptions>): Promise<SvsAdapterReadinessResult>;
+  verifyAndSubmitSolanaAction(input: SvsAdapterActionInput, options?: Partial<SvsAdapterOptions>): Promise<SvsAdapterActionResult>;
+  getTools(): unknown[];
+}
+
+export function createSvsGoatPlugin(options: SvsAdapterOptions & { createTool?: Function | null; z?: unknown }): SvsGoatPlugin;
+export function createSvsGoatTool(options?: { client?: unknown; defaults?: Partial<SvsAdapterOptions>; createTool?: Function | null; z?: unknown }): SvsGoatTool | unknown;
+export function createGoatToolMetadata(options?: { z?: unknown }): JsonObject;
+export function createGoatToolParameters(options?: { z?: unknown }): unknown;
+export function requireSvsGoatProductionReady(options: SvsAdapterOptions): Promise<SvsAdapterReadinessResult>;
+export function verifyAndSubmitGoatSolanaAction(options: SvsAdapterOptions & SvsAdapterActionInput): Promise<SvsAdapterActionResult>;
+export function supportsSolanaChain(chain?: unknown): boolean;

package/dist/goat.js

@@ -0,0 +1,261 @@
+import {
+  SvsAdapterCoreError,
+  createSvsAdapterClient,
+  requireSvsAdapterProductionReady,
+  verifyAndSubmitSvsAdapterSolanaAction
+} from "./adapter-core.js";
+
+export const GOAT_ADAPTER_VERSION = "svs.goat-adapter.v1";
+export const GOAT_PLUGIN_NAME = "svs-solana-verification";
+export const GOAT_TOOL_NAME = "svs_verify_and_submit_solana_action";
+
+export class SvsGoatAdapterError extends SvsAdapterCoreError {
+  constructor(message, details = {}) {
+    super(message, details);
+    this.name = "SvsGoatAdapterError";
+  }
+}
+
+export function createSvsGoatPlugin({
+  client = null,
+  baseUrl,
+  apiKey,
+  requestSigningSecret,
+  expectedIntegrationContractHash,
+  botId,
+  policyId = null,
+  rpcUrl = null,
+  certificationStaleAfterMs = undefined,
+  requireCurrentIntegrationContract = true,
+  waitForProof = false,
+  waitAttempts = 12,
+  waitIntervalMs = 5000,
+  fetchProof = true,
+  checkReceiptRegistryChain = true,
+  requireReadinessOnSubmit = true,
+  createTool = null,
+  z = null
+} = {}) {
+  if (!botId) {
+    throw new Error("botId is required.");
+  }
+
+  const svs = createSvsAdapterClient({
+    client,
+    baseUrl,
+    apiKey,
+    requestSigningSecret,
+    expectedIntegrationContractHash
+  });
+  const defaults = {
+    botId,
+    policyId,
+    rpcUrl,
+    certificationStaleAfterMs,
+    requireCurrentIntegrationContract,
+    waitForProof,
+    waitAttempts,
+    waitIntervalMs,
+    fetchProof,
+    checkReceiptRegistryChain,
+    requireReadinessOnSubmit
+  };
+  const tool = createSvsGoatTool({
+    client: svs,
+    defaults,
+    createTool,
+    z
+  });
+
+  return {
+    version: GOAT_ADAPTER_VERSION,
+    name: GOAT_PLUGIN_NAME,
+    description: "SVS Agent Verification plugin for GOAT Solana agents.",
+    botId,
+    policyId,
+    rpcUrl,
+    client: svs,
+    tool,
+    tools: [tool],
+    supportsChain: supportsSolanaChain,
+    async requireSvsProductionReady(options = {}) {
+      return requireSvsGoatProductionReady({
+        client: svs,
+        ...defaults,
+        ...options
+      });
+    },
+    async verifyAndSubmitSolanaAction(input = {}, options = {}) {
+      return verifyAndSubmitGoatSolanaAction({
+        client: svs,
+        ...defaults,
+        ...input,
+        ...options
+      });
+    },
+    getTools() {
+      return [tool];
+    }
+  };
+}
+
+export function createSvsGoatTool({
+  client,
+  defaults = {},
+  createTool = null,
+  z = null
+} = {}) {
+  const metadata = createGoatToolMetadata({ z });
+  const execute = async (parameters = {}) => verifyAndSubmitGoatSolanaAction({
+    client,
+    ...defaults,
+    ...parameters
+  });
+
+  if (typeof createTool === "function") {
+    return createTool(metadata, execute);
+  }
+
+  return {
+    ...metadata,
+    version: GOAT_ADAPTER_VERSION,
+    execute,
+    handler: execute
+  };
+}
+
+export function createGoatToolMetadata({ z = null } = {}) {
+  return {
+    name: GOAT_TOOL_NAME,
+    description: "Require SVS production readiness, then queue a Solana action for human approval and proof-backed execution.",
+    parameters: createGoatToolParameters({ z })
+  };
+}
+
+export function createGoatToolParameters({ z = null } = {}) {
+  if (z?.object && z?.string && z?.boolean && z?.number && z?.unknown) {
+    return z.object({
+      requestId: z.string().optional(),
+      idempotencyKey: z.string().optional(),
+      intent: z.unknown(),
+      policyId: z.string().optional(),
+      serializedTransaction: z.string(),
+      rpcUrl: z.string().optional(),
+      simulation: z.unknown().optional(),
+      metadata: z.unknown().optional(),
+      waitForProof: z.boolean().optional(),
+      waitAttempts: z.number().optional(),
+      waitIntervalMs: z.number().optional(),
+      fetchProof: z.boolean().optional(),
+      checkReceiptRegistryChain: z.boolean().optional()
+    });
+  }
+
+  return {
+    type: "object",
+    required: ["intent", "serializedTransaction"],
+    properties: {
+      requestId: {
+        type: "string",
+        description: "Stable idempotency key for this GOAT agent action."
+      },
+      idempotencyKey: {
+        type: "string",
+        description: "Optional idempotency override. Defaults to requestId."
+      },
+      intent: {
+        type: "object",
+        description: "Human-readable Solana action intent shown to the SVS operator."
+      },
+      policyId: {
+        type: "string",
+        description: "SVS policy id to enforce for this action."
+      },
+      serializedTransaction: {
+        type: "string",
+        description: "Serialized Solana transaction prepared by the GOAT agent."
+      },
+      rpcUrl: {
+        type: "string",
+        description: "Solana RPC URL used to simulate or verify the action."
+      },
+      simulation: {
+        type: "object",
+        description: "Optional Solana simulation result produced before submitting."
+      },
+      metadata: {
+        type: "object",
+        description: "Optional non-secret metadata to include in the approval record."
+      },
+      waitForProof: {
+        type: "boolean",
+        description: "Wait for the human/operator path to produce a production proof."
+      },
+      waitAttempts: {
+        type: "number",
+        description: "Maximum proof polling attempts."
+      },
+      waitIntervalMs: {
+        type: "number",
+        description: "Delay between proof polling attempts."
+      },
+      fetchProof: {
+        type: "boolean",
+        description: "Fetch the proof package after proof status becomes ready."
+      },
+      checkReceiptRegistryChain: {
+        type: "boolean",
+        description: "Ask SVS to independently check the custom registry proof on-chain."
+      }
+    }
+  };
+}
+
+export async function requireSvsGoatProductionReady({
+  ...options
+} = {}) {
+  return requireSvsAdapterProductionReady({
+    ...options,
+    readinessVersion: "svs.goat-readiness.v1",
+    readyMessage: "SVS GOAT plugin readiness and production certification passed.",
+    adapterLabel: "GOAT adapter",
+    ErrorClass: SvsGoatAdapterError
+  });
+}
+
+export async function verifyAndSubmitGoatSolanaAction({
+  ...options
+} = {}) {
+  return verifyAndSubmitSvsAdapterSolanaAction({
+    ...options,
+    adapterVersion: GOAT_ADAPTER_VERSION,
+    agentFramework: "goat",
+    resultVersion: "svs.goat-action-result.v1",
+    readinessVersion: "svs.goat-readiness.v1",
+    readyMessage: "SVS GOAT plugin readiness and production certification passed.",
+    adapterLabel: "GOAT adapter",
+    ErrorClass: SvsGoatAdapterError
+  });
+}
+
+export function supportsSolanaChain(chain = null) {
+  if (chain === null || chain === undefined) {
+    return true;
+  }
+
+  if (typeof chain === "string") {
+    return chain.toLowerCase().includes("solana");
+  }
+
+  const candidates = [
+    chain.type,
+    chain.namespace,
+    chain.chain,
+    chain.id,
+    chain.name,
+    chain.network,
+    chain.chainType
+  ].filter(Boolean).map((value) => String(value).toLowerCase());
+
+  return candidates.some((value) => value.includes("solana"));
+}