get_funding

Implementation Reference

• src/tools/bitso-tools.ts:498-544 (handler)

  Handler function that validates input parameters, fetches the specific funding using the Bitso client, formats the response as text, and handles errors including validation errors.

      async (params): Promise<ToolResult> => {
        try {
          const validatedParams = GetFundingSchema.parse(params);
          logToFile('INFO', 'Get funding tool called', { fid: validatedParams.fid });
          
          const funding = await client.getFunding(validatedParams.fid);
          
          return {
            content: [
              {
                type: "text",
                text: `Funding Details:
  ID: ${funding.fid}
  Status: ${funding.status}
  Currency: ${funding.currency}
  Amount: ${funding.amount}
  Method: ${funding.method}
  Created: ${funding.created_at}
  Details: ${JSON.stringify(funding.details, null, 2)}`
              }
            ]
          };
        } catch (error) {
          logToFile('ERROR', 'Error in get_funding tool', error);
          
          if (error instanceof z.ZodError) {
            const errorMessage = error.errors.map(err => `${err.path.join('.')}: ${err.message}`).join(', ');
            return {
              content: [
                {
                  type: "text",
                  text: `Validation error: ${errorMessage}`
                }
              ]
            };
          }
          
          return {
            content: [
              {
                type: "text",
                text: `Error retrieving funding: ${error instanceof Error ? error.message : String(error)}`
              }
            ]
          };
        }
      }

• src/tools/bitso-tools.ts:39-41 (schema)

  Zod schema used in the handler for input validation, requiring a 'fid' string.

  const GetFundingSchema = z.object({
    fid: z.string().min(1, "Funding ID is required"),
  });

• src/tools/bitso-tools.ts:483-497 (registration)

  MCP server tool registration for 'get_funding', providing tool name, description, input schema (mirroring Zod schema), and handler function.

  server.tool(
    "get_funding",
    {
      description: "Get details of a specific funding by ID",
      inputSchema: {
        type: "object",
        properties: {
          fid: {
            type: "string",
            description: "The funding ID to retrieve"
          }
        },
        required: ["fid"]
      }
    },

• src/client.ts:208-239 (helper)

  Supporting client method that performs the authenticated API call to Bitso's /fundings/{fid} endpoint, with caching, logging, and error handling.

  async getFunding(fid: string): Promise<Funding> {
    const cacheKey = this.getCacheKey(`/api/v3/fundings/${fid}`);
    const cached = this.getCachedData<Funding>(cacheKey);
    
    if (cached) {
      return cached;
    }
  
    try {
      const requestPath = `/api/v3/fundings/${fid}`;
      const authHeaders = this.createAuthHeaders('GET', requestPath);
      
      this.logToFile('INFO', 'Fetching funding from Bitso API...', { fid });
      
      const response: AxiosResponse<{ success: boolean; payload: Funding }> = await this.client.get(requestPath, {
        headers: authHeaders
      });
      
      if (!response.data.success) {
        throw new Error('API request failed');
      }
  
      const funding = response.data.payload;
      this.setCachedData(cacheKey, funding);
      
      this.logToFile('INFO', 'Funding fetched successfully', { fid });
      return funding;
    } catch (error) {
      this.logToFile('ERROR', 'Failed to fetch funding', { fid, error });
      throw error;
    }
  }