# Note: You need to encrypt the payload first using a script/tool
# See the Encryption Guide for JWE token creation

# 1. Create encrypted JWE token containing: {"webhookStatus": "DISABLED"}
ENCRYPTED_TOKEN="eyJhbGciOiJBMjU2S1ciL..."

# 2. Make API request
curl -X PUT https://webhooks.sbx.moduluslabs.io/v1/webhooks/a78efd32-de3b-4854-b599-11ae9f98f97e \
  -u sk_your_secret_key: \
  -H "Content-Type: application/json" \
  -d "{\"request\": {\"Token\": \"$ENCRYPTED_TOKEN\"}}"

# 1. Create encrypted JWE token containing: {"callbackUrl": "https://new-domain.com/webhooks/modulus"}
ENCRYPTED_TOKEN="eyJhbGciOiJBMjU2S1ciL..."

# 2. Make API request
curl -X PUT https://webhooks.sbx.moduluslabs.io/v1/webhooks/a78efd32-de3b-4854-b599-11ae9f98f97e \
  -u sk_your_secret_key: \
  -H "Content-Type: application/json" \
  -d "{\"request\": {\"Token\": \"$ENCRYPTED_TOKEN\"}}"

const axios = require('axios');
const jose = require('jose');

const SECRET_KEY = process.env.MODULUS_SECRET_KEY;
const ENCRYPTION_KEY = process.env.MODULUS_ENCRYPTION_KEY;

async function updateWebhook(webhookId, updates) {
  // 1. Encrypt payload into JWE token
  const key = Buffer.from(ENCRYPTION_KEY, 'base64');
  const jweToken = await new jose.CompactEncrypt(
    new TextEncoder().encode(JSON.stringify(updates))
  )
    .setProtectedHeader({ alg: 'A256KW', enc: 'A256CBC-HS512' })
    .encrypt(key);

  // 2. Make API request
  const response = await axios.put(
    `https://webhooks.sbx.moduluslabs.io/v1/webhooks/${webhookId}`,
    { request: { Token: jweToken } },
    {
      auth: { username: SECRET_KEY, password: '' },
      headers: { 'Content-Type': 'application/json' }
    }
  );

  const result = response.data;
  console.log('Webhook updated successfully');
  console.log('Webhook ID:', result.id);
  console.log('New URL:', result.callbackUrl);
  console.log('New Status:', result.webhookStatus);

  return result;
}

// Example: Disable webhook
updateWebhook('a78efd32-de3b-4854-b599-11ae9f98f97e', { webhookStatus: 'DISABLED' })
  .catch(error => {
    console.error('Error:', error.response?.data || error.message);
  });

// Example: Change URL
updateWebhook('a78efd32-de3b-4854-b599-11ae9f98f97e', {
  callbackUrl: 'https://new-domain.com/webhooks/modulus'
});

// Example: Update multiple fields
updateWebhook('a78efd32-de3b-4854-b599-11ae9f98f97e', {
  callbackUrl: 'https://api.example.com/webhooks/success',
  webhookAction: 'QRPH_SUCCESS',
  webhookStatus: 'ENABLED'
});

import os
import json
import requests
from jose import jwe

SECRET_KEY = os.getenv('MODULUS_SECRET_KEY')
ENCRYPTION_KEY = os.getenv('MODULUS_ENCRYPTION_KEY')

def update_webhook(webhook_id, updates):
    # 1. Encrypt payload into JWE token
    jwe_token = jwe.encrypt(
        json.dumps(updates),
        ENCRYPTION_KEY,
        algorithm='A256KW',
        encryption='A256CBC-HS512'
    )

    # 2. Make API request
    response = requests.put(
        f'https://webhooks.sbx.moduluslabs.io/v1/webhooks/{webhook_id}',
        json={'request': {'Token': jwe_token}},
        auth=(SECRET_KEY, ''),
        headers={'Content-Type': 'application/json'}
    )

    response.raise_for_status()

    result = response.json()
    print('Webhook updated successfully')
    print(f"Webhook ID: {result['id']}")
    print(f"New URL: {result['callbackUrl']}")
    print(f"New Status: {result['webhookStatus']}")

    return result

# Example: Disable webhook
update_webhook('a78efd32-de3b-4854-b599-11ae9f98f97e', {'webhookStatus': 'DISABLED'})

# Example: Change URL
update_webhook('a78efd32-de3b-4854-b599-11ae9f98f97e', {
    'callbackUrl': 'https://new-domain.com/webhooks/modulus'
})

# Example: Update multiple fields
update_webhook('a78efd32-de3b-4854-b599-11ae9f98f97e', {
    'callbackUrl': 'https://api.example.com/webhooks/success',
    'webhookAction': 'QRPH_SUCCESS',
    'webhookStatus': 'ENABLED'
})

<?php
require 'vendor/autoload.php';

use Jose\Component\Core\AlgorithmManager;
use Jose\Component\Core\JWK;
use Jose\Component\Encryption\Algorithm\KeyEncryption\A256KW;
use Jose\Component\Encryption\Algorithm\ContentEncryption\A256CBCHS512;
use Jose\Component\Encryption\JWEBuilder;
use Jose\Component\Encryption\Serializer\CompactSerializer;

$secretKey = getenv('MODULUS_SECRET_KEY');
$encryptionKey = getenv('MODULUS_ENCRYPTION_KEY');

function updateWebhook($webhookId, $updates) {
    global $secretKey, $encryptionKey;

    // 1. Encrypt payload (simplified - use proper JWE library)
    // See encryption documentation for full implementation
    $jweToken = encryptToJWE(json_encode($updates), $encryptionKey);

    // 2. Make API request
    $ch = curl_init("https://webhooks.sbx.moduluslabs.io/v1/webhooks/{$webhookId}");
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(['request' => ['Token' => $jweToken]]));
    curl_setopt($ch, CURLOPT_USERPWD, $secretKey . ':');
    curl_setopt($ch, CURLOPT_HTTPHEADER, ['Content-Type: application/json']);

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode === 200) {
        $result = json_decode($response, true);
        echo "Webhook updated successfully\n";
        echo "Webhook ID: {$result['id']}\n";
        echo "New URL: {$result['callbackUrl']}\n";
        echo "New Status: {$result['webhookStatus']}\n";
        return $result;
    } else {
        echo "Error: HTTP $httpCode\n";
        echo "Details: $response\n";
        return null;
    }
}

// Example: Disable webhook
updateWebhook('a78efd32-de3b-4854-b599-11ae9f98f97e', ['webhookStatus' => 'DISABLED']);

// Example: Change URL
updateWebhook('a78efd32-de3b-4854-b599-11ae9f98f97e', [
    'callbackUrl' => 'https://new-domain.com/webhooks/modulus'
]);

package main

import (
	"bytes"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"

	"github.com/lestrrat-go/jwx/v2/jwa"
	"github.com/lestrrat-go/jwx/v2/jwe"
)

type TokenWrapper struct {
	Token string `json:"Token"`
}

type TokenRequest struct {
	Request TokenWrapper `json:"request"`
}

type WebhookResponse struct {
	ID            string `json:"id"`
	WebhookAction string `json:"webhookAction"`
	WebhookStatus string `json:"webhookStatus"`
	CallbackUrl   string `json:"callbackUrl"`
}

func updateWebhook(webhookID string, updates map[string]interface{}) (*WebhookResponse, error) {
	secretKey := os.Getenv("MODULUS_SECRET_KEY")
	encryptionKey := os.Getenv("MODULUS_ENCRYPTION_KEY")

	// 1. Encrypt payload into JWE token
	payloadJSON, err := json.Marshal(updates)
	if err != nil {
		return nil, fmt.Errorf("failed to marshal payload: %w", err)
	}

	keyBytes, err := base64.RawURLEncoding.DecodeString(encryptionKey)
	if err != nil {
		return nil, fmt.Errorf("failed to decode encryption key: %w", err)
	}

	encrypted, err := jwe.Encrypt(payloadJSON,
		jwe.WithKey(jwa.A256KW, keyBytes),
		jwe.WithContentEncryption(jwa.A256CBC_HS512),
	)
	if err != nil {
		return nil, fmt.Errorf("failed to encrypt payload: %w", err)
	}
	jweToken := string(encrypted)

	// 2. Make API request with Basic Auth
	reqBody := TokenRequest{Request: TokenWrapper{Token: jweToken}}
	jsonData, _ := json.Marshal(reqBody)

	url := fmt.Sprintf("https://webhooks.sbx.moduluslabs.io/v1/webhooks/%s", webhookID)
	req, err := http.NewRequest("PUT", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return nil, fmt.Errorf("failed to create request: %w", err)
	}

	req.SetBasicAuth(secretKey, "")
	req.Header.Set("Content-Type", "application/json")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("request failed: %w", err)
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)

	if resp.StatusCode == 200 {
		var result WebhookResponse
		json.Unmarshal(body, &result)
		fmt.Println("Webhook updated successfully")
		fmt.Printf("Webhook ID: %s\n", result.ID)
		fmt.Printf("New URL: %s\n", result.CallbackUrl)
		fmt.Printf("New Status: %s\n", result.WebhookStatus)
		return &result, nil
	}

	return nil, fmt.Errorf("HTTP %d: %s", resp.StatusCode, string(body))
}

func main() {
	// Example: Disable webhook
	_, err := updateWebhook("a78efd32-de3b-4854-b599-11ae9f98f97e", map[string]interface{}{
		"webhookStatus": "DISABLED",
	})
	if err != nil {
		fmt.Printf("Failed to update webhook: %v\n", err)
	}
}

using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;
using Jose;

namespace ModulusWebhooks;

class Program
{
    static async Task Main(string[] args)
    {
        await UpdateWebhook("a78efd32-de3b-4854-b599-11ae9f98f97e", new
        {
            callbackUrl = "https://api.yourcompany.com/webhooks/modulus",
            webhookAction = "QRPH_SUCCESS",
            webhookStatus = "DISABLED"
        });
    }

    static byte[] Base64UrlDecode(string base64Url)
    {
        var base64 = base64Url
            .Replace('-', '+')
            .Replace('_', '/');

        switch (base64.Length % 4)
        {
            case 2: base64 += "=="; break;
            case 3: base64 += "="; break;
        }

        return Convert.FromBase64String(base64);
    }

    static async Task UpdateWebhook(string webhookId, object updates)
    {
        var secretKey = Environment.GetEnvironmentVariable("MODULUS_SECRET_KEY");
        var encryptionKey = Environment.GetEnvironmentVariable("MODULUS_ENCRYPTION_KEY");

        if (string.IsNullOrEmpty(secretKey) || string.IsNullOrEmpty(encryptionKey))
        {
            Console.WriteLine("Error: MODULUS_SECRET_KEY and MODULUS_ENCRYPTION_KEY must be set");
            return;
        }

        try
        {
            // 1. Encrypt payload into JWE token
            var key = Base64UrlDecode(encryptionKey);
            var payloadJson = JsonSerializer.Serialize(updates);
            var jweToken = JWT.Encode(
                payloadJson,
                key,
                JweAlgorithm.A256KW,
                JweEncryption.A256CBC_HS512
            );

            // 2. Make API request with Basic Auth
            using var client = new HttpClient();
            var authBytes = Encoding.ASCII.GetBytes($"{secretKey}:");
            client.DefaultRequestHeaders.Authorization =
                new AuthenticationHeaderValue("Basic", Convert.ToBase64String(authBytes));

            var requestBody = new { request = new { Token = jweToken } };
            var content = new StringContent(
                JsonSerializer.Serialize(requestBody),
                Encoding.UTF8,
                "application/json"
            );

            var response = await client.PutAsync(
                $"https://webhooks.sbx.moduluslabs.io/v1/webhooks/{webhookId}",
                content
            );

            var responseBody = await response.Content.ReadAsStringAsync();

            if (response.IsSuccessStatusCode)
            {
                var result = JsonSerializer.Deserialize<WebhookResponse>(
                    responseBody,
                    new JsonSerializerOptions { PropertyNameCaseInsensitive = true }
                );

                Console.WriteLine("Webhook updated successfully");
                Console.WriteLine($"Webhook ID: {result?.Id}");
                Console.WriteLine($"Webhook URL: {result?.CallbackUrl}");
                Console.WriteLine($"Action: {result?.WebhookAction}");
                Console.WriteLine($"Status: {result?.WebhookStatus}");
            }
            else
            {
                Console.WriteLine($"Error: HTTP {(int)response.StatusCode}");
                Console.WriteLine($"Details: {responseBody}");
            }
        }
        catch (Exception e)
        {
            Console.WriteLine($"Error: {e.Message}");
        }
    }
}

public class WebhookResponse
{
    public string? Id { get; set; }
    public string? CallbackUrl { get; set; }
    public string? WebhookAction { get; set; }
    public string? WebhookStatus { get; set; }
}

{
  "id": "a78efd32-de3b-4854-b599-11ae9f98f97e",
  "webhookAction": "QRPH_SUCCESS",
  "webhookStatus": "DISABLED",
  "callbackUrl": "https://api.yourcompany.com/webhooks/success",
}

{
  "code": "20000002",
  "error": "Invalid callbackUrl: must be a valid HTTPS URL",
  "referenceNumber": "097bf60a-bdab-40bf-b615-3c0eae693b86"
}

{
  "code": "10000013",
  "error": "Invalid API Key",
  "referenceNumber": "097bf60a-bdab-40bf-b615-3c0eae693b86"
}

{
  "code": "20000004",
  "error": "Webhook not found",
  "referenceNumber": "097bf60a-bdab-40bf-b615-3c0eae693b86"
}

{
  "code": "20000003",
  "error": "Webhook URL already exists",
  "referenceNumber": "097bf60a-bdab-40bf-b615-3c0eae693b86"
}

{
  "code": "10000001",
  "error": "An unexpected error occurred. Please try again later.",
  "referenceNumber": "097bf60a-bdab-40bf-b615-3c0eae693b86"
}