Create an attempt

const timestamp = Date.now()
const message = JSON.stringify({
  apiKey: AKEDLY_API_KEY,
  publicKey: WIDGET_PUBLIC_KEY,
  timestamp,
})
const signature = crypto
  .createHmac('sha256', WIDGET_SECRET)
  .update(message)
  .digest('hex')

const response = await axios.post(
  'https://api.akedly.io/api/v1/widget-sdk/create-attempt',
  {
    apiKey: AKEDLY_API_KEY,
    publicKey: WIDGET_PUBLIC_KEY,
    signature,
    timestamp,
    verificationAddress: {
      email: 'user@example.com',
    },
    digits: 6,
  },
)

import hmac
import hashlib
import json
import time
import requests
import os

AKEDLY_API_KEY = os.environ['AKEDLY_API_KEY']
WIDGET_PUBLIC_KEY = os.environ['WIDGET_PUBLIC_KEY']
WIDGET_SECRET = os.environ['WIDGET_SECRET']

def generate_signature(api_key, public_key, secret, timestamp, phone_number):
    message = json.dumps({
        'apiKey': api_key,
        'publicKey': public_key,
        'timestamp': timestamp,
        'phoneNumber': phone_number,
    }, separators=(',', ':'))

    signature = hmac.new(
        secret.encode('utf-8'),
        message.encode('utf-8'),
        hashlib.sha256
    ).hexdigest()

    return signature

def create_auth_attempt(phone_number, email=None, public_metadata=None, private_metadata=None):
    timestamp = int(time.time() * 1000)

    signature = generate_signature(
        AKEDLY_API_KEY,
        WIDGET_PUBLIC_KEY,
        WIDGET_SECRET,
        timestamp,
        phone_number
    )

    response = requests.post(
        'https://api.akedly.io/api/v1/widget-sdk/create-attempt',
        json={
            'apiKey': AKEDLY_API_KEY,
            'publicKey': WIDGET_PUBLIC_KEY,
            'signature': signature,
            'timestamp': timestamp,
            'verificationAddress': {
                'phoneNumber': phone_number,
                'email': email,
            },
            'digits': 6,
            'publicMetadata': public_metadata,
            'privateMetadata': private_metadata,
        }
    )

    response.raise_for_status()
    return response.json()['data']

# Usage in Flask route
@app.route('/api/auth/start', methods=['POST'])
def start_auth():
    try:
        data = request.json
        phone_number = data['phoneNumber']
        email = data.get('email')

        attempt = create_auth_attempt(
            phone_number,
            email,
            public_metadata={'userId': data.get('userId'), 'orderId': data.get('orderId')},
            private_metadata={'internalId': session.get('internalId')},
        )

        return jsonify({
            'success': True,
            'attemptId': attempt['attemptId'],
            'iframeUrl': attempt['iframeUrl'],
        })
    except requests.HTTPError as e:
        try:
            upstream = e.response.json()
        except ValueError:
            upstream = {}
        return jsonify({
            'success': False,
            'message': 'Could not start verification. Please try again.',
            'code': upstream.get('code'),
            'retryable': upstream.get('retryable'),
            'retryAfter': upstream.get('retryAfter'),
            'cooldownSeconds': upstream.get('cooldownSeconds'),
        }), e.response.status_code
    except Exception:
        return jsonify({
            'success': False,
            'message': 'Could not start verification. Please try again.',
        }), 500

<?php

function generateSignature($apiKey, $publicKey, $secret, $timestamp, $phoneNumber) {
    $message = json_encode([
        'apiKey' => $apiKey,
        'publicKey' => $publicKey,
        'timestamp' => $timestamp,
        'phoneNumber' => $phoneNumber,
    ], JSON_UNESCAPED_SLASHES);

    return hash_hmac('sha256', $message, $secret);
}

class AkedlyRequestException extends Exception {
    public $status;
    public $body;

    public function __construct($status, $body) {
        parent::__construct('API request failed');
        $this->status = $status;
        $this->body = $body;
    }
}

function createAuthAttempt($phoneNumber, $email = null, $publicMetadata = null, $privateMetadata = null) {
    $apiKey = getenv('AKEDLY_API_KEY');
    $publicKey = getenv('WIDGET_PUBLIC_KEY');
    $secret = getenv('WIDGET_SECRET');

    $timestamp = round(microtime(true) * 1000);

    $signature = generateSignature(
        $apiKey,
        $publicKey,
        $secret,
        $timestamp,
        $phoneNumber
    );

    $data = [
        'apiKey' => $apiKey,
        'publicKey' => $publicKey,
        'signature' => $signature,
        'timestamp' => $timestamp,
        'verificationAddress' => [
            'phoneNumber' => $phoneNumber,
            'email' => $email,
        ],
        'digits' => 6,
        'publicMetadata' => $publicMetadata,
        'privateMetadata' => $privateMetadata,
    ];

    $ch = curl_init('https://api.akedly.io/api/v1/widget-sdk/create-attempt');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
    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) {
        throw new AkedlyRequestException($httpCode, json_decode($response, true) ?? []);
    }

    return json_decode($response, true)['data'];
}

// Usage
try {
    $phoneNumber = $_POST['phoneNumber'];
    $email = $_POST['email'] ?? null;

    $attempt = createAuthAttempt(
        $phoneNumber,
        $email,
        ['userId' => $_POST['userId'] ?? null, 'orderId' => $_POST['orderId'] ?? null],
        ['internalId' => $_SESSION['internalId'] ?? null]
    );

    echo json_encode([
        'success' => true,
        'attemptId' => $attempt['attemptId'],
        'iframeUrl' => $attempt['iframeUrl'],
    ]);
} catch (AkedlyRequestException $e) {
    http_response_code($e->status >= 400 ? $e->status : 502);
    echo json_encode([
        'success' => false,
        'message' => 'Could not start verification. Please try again.',
        'code' => $e->body['code'] ?? null,
        'retryable' => $e->body['retryable'] ?? null,
        'retryAfter' => $e->body['retryAfter'] ?? null,
        'cooldownSeconds' => $e->body['cooldownSeconds'] ?? null,
    ]);
} catch (Exception $e) {
    http_response_code(500);
    echo json_encode([
        'success' => false,
        'message' => 'Could not start verification. Please try again.',
    ]);
}
?>