Signing with utility functions

import PrivySDK

// Define structs for the request body (must conform to Encodable)
struct PersonalSignParams: Encodable {
let message: String
let encoding: String
}

struct PersonalSignRpcRequest: Encodable {
let method: String
let params: PersonalSignParams
}

// Create the RPC request body
let rpcRequest = PersonalSignRpcRequest(
method: "personal_sign",
params: PersonalSignParams(message: "Hello from Privy!", encoding: "utf-8")
)

// Create the signature payload using WalletApiPayload
let signaturePayload = WalletApiPayload(
version: 1,
url: "https://api.privy.io/v1/wallets/<wallet-id>/rpc",
method: "POST",
headers: ["privy-app-id": "<app-id>"],
body: rpcRequest
)

import io.privy.wallet.walletApi.WalletApiPayload
import kotlinx.serialization.Serializable

// Define data classes for the request body (must be @Serializable)
@Serializable
data class PersonalSignParams(
    val message: String,
    val encoding: String
)

@Serializable
data class PersonalSignRpcRequest(
    val method: String,
    val params: PersonalSignParams
)

// Create the RPC request body
val rpcRequest = PersonalSignRpcRequest(
    method = "personal_sign",
    params = PersonalSignParams(message = "Hello from Privy!", encoding = "utf-8")
)

// Create the signature payload using WalletApiPayload
val signaturePayload = WalletApiPayload(
    version = 1,
    url = "https://api.privy.io/v1/wallets/<wallet-id>/rpc",
    method = "POST",
    headers = mapOf("privy-app-id" to "<app-id>"),
    body = rpcRequest
)

import 'package:privy_flutter/privy_flutter.dart';

// Create the RPC request body as a Map
final rpcRequestBody = {
  'method': 'personal_sign',
  'params': {
    'message': 'Hello from Privy!',
    'encoding': 'utf-8',
  },
};

// Create the signature payload
final signaturePayload = WalletApiPayload(
  version: 1,
  url: 'https://api.privy.io/v1/wallets/<wallet-id>/rpc',
  method: 'POST',
  headers: {'privy-app-id': '<app-id>'},
  body: rpcRequestBody,
);

using System.Collections.Generic;
using Privy.Wallets;

// Create the signature payload
var signaturePayload = new WalletApiPayload
{
    Version = 1,
    Url = "https://api.privy.io/v1/wallets/<wallet-id>/rpc",
    Method = "POST",
    Headers = new Dictionary<string, string> { { "privy-app-id", "<app-id>" } },
    Body = new
    {
        method = "personal_sign",
        @params = new { message = "Hello from Privy!", encoding = "utf-8" }
    }
};

import {useAuthorizationSignature} from '@privy-io/expo';

const {generateAuthorizationSignature} = useAuthorizationSignature();

// Sign the request using the current authenticated user's signing key.
// The `signaturePayload` here refers to the JSON payload constructed in step (1).
const authorizationSignature = await generateAuthorizationSignature(signaturePayload);

// Get the authenticated user
guard let user = try await privy.getUser() else {
    // User is not authenticated
    return
}

// Sign the request using the payload from step (1)
do {
    let authorizationSignature = try await user.generateAuthorizationSignature(payload: signaturePayload)
    // Use signature in API request headers as 'privy-authorization-signature'
} catch {
    // Handle error
}

val user = privy.getUser() ?: return

// Sign the request using the payload from step (1)
user.generateAuthorizationSignature(signaturePayload)
    .onSuccess { authorizationSignature ->
        // Use signature in API request headers as 'privy-authorization-signature'
    }
    .onFailure { error ->
        // Handle error
    }

final user = await privy.getUser();
if (user == null) return;

// Sign the request using the payload from step (1)
final result = await user.generateAuthorizationSignature(signaturePayload);

result.fold(
  onSuccess: (signature) {
    // Use signature in API request headers as 'privy-authorization-signature'
    print('Signature: $signature');
  },
  onFailure: (error) {
    // Handle error
    print('Error: $error');
  },
);

using Privy.Core;
using Privy.Auth.Models;

IPrivyUser user = await PrivyManager.Instance.GetUser();

// Sign the request using the payload from step (1)
string signature = await user.GenerateAuthorizationSignature(signaturePayload);
// Use signature in API request headers as 'privy-authorization-signature'