Bitso MCP Server

Implementation Reference

• src/tools/bitso-tools.ts:154-220 (handler)

  Complete handler and registration for the 'get_withdrawal' MCP tool: registers the tool with input schema, validates params with Zod, calls client.getWithdrawal, formats response text, handles errors.

    server.tool(
      "get_withdrawal",
      {
        description: "Get details of a specific withdrawal by ID",
        inputSchema: {
          type: "object",
          properties: {
            wid: {
              type: "string",
              description: "The withdrawal ID to retrieve"
            }
          },
          required: ["wid"]
        }
      },
      async (params): Promise<ToolResult> => {
        try {
          const validatedParams = GetWithdrawalSchema.parse(params);
          logToFile('INFO', 'Get withdrawal tool called', { wid: validatedParams.wid });
          
          const withdrawal = await client.getWithdrawal(validatedParams.wid);
          
          return {
            content: [
              {
                type: "text",
                text: `Withdrawal Details:
  ID: ${withdrawal.wid}
  Status: ${withdrawal.status}
  Currency: ${withdrawal.currency}
  Amount: ${withdrawal.amount}
  Method: ${withdrawal.method}
  Created: ${withdrawal.created_at}
  ${withdrawal.origin_id ? `Origin ID: ${withdrawal.origin_id}` : ''}
  ${withdrawal.asset ? `Asset: ${withdrawal.asset}` : ''}
  ${withdrawal.network ? `Network: ${withdrawal.network}` : ''}
  ${withdrawal.protocol ? `Protocol: ${withdrawal.protocol}` : ''}
  Details: ${JSON.stringify(withdrawal.details, null, 2)}`
              }
            ]
          };
        } catch (error) {
          logToFile('ERROR', 'Error in get_withdrawal 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 withdrawal: ${error instanceof Error ? error.message : String(error)}`
              }
            ]
          };
        }
      }
    );

• src/tools/bitso-tools.ts:19-21 (schema)

  Zod schema used for input validation in the get_withdrawal tool handler, requiring a non-empty 'wid' string.

  const GetWithdrawalSchema = z.object({
    wid: z.string().min(1, "Withdrawal ID is required"),
  });

• src/client.ts:140-170 (helper)

  BitsoApiClient helper method that fetches a specific withdrawal from the Bitso API by ID, includes caching logic, authentication, and error handling.

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

• src/index.ts:101-101 (registration)

  Top-level call to registerBitsoTools function, which includes registration of the 'get_withdrawal' tool on the MCP server.

  registerBitsoTools(server, client);