Server SDKs by language

shasum -a 256 -c SHA256SUMS --ignore-missing

dotnet nuget add source ./packages --name kotp-local
dotnet add package KOtp.Sdk --version 0.1.0

using System.Text.Json.Nodes;
using KOtp;

using var client = new KotpClient(Environment.GetEnvironmentVariable("KOTP_SECRET_KEY")!);

try {
    var issued = await client.IssueAsync(new JsonObject {
        ["phoneNumber"] = "01012345678",
        ["purpose"] = "login",
        ["idempotencyKey"] = idempotencyKey, // e.g. Guid.NewGuid().ToString(), stored for retries
    });
    var issueId = issued!["issueId"]!.GetValue<string>();

    // Later, with the code the user entered:
    var result = await client.VerifyAsync(new JsonObject { ["issueId"] = issueId, ["code"] = "123456" });
    var verified = result!["verified"]!.GetValue<bool>();
} catch (KotpApiException e) {
    var code = e.Envelope?["code"]?.GetValue<string>();
    Console.Error.WriteLine($"{e.Status} {code} {e.RequestId}");
} catch (KotpTransportException) {
    // Outcome unknown: retry IssueAsync with the same idempotencyKey.
}

mvn install:install-file -Dfile=kotp-sdk-0.1.0.jar -DpomFile=kotp-sdk-0.1.0.pom \
  -Dsources=kotp-sdk-0.1.0-sources.jar -Djavadoc=kotp-sdk-0.1.0-javadoc.jar

<dependency>
  <groupId>dev.kotp</groupId>
  <artifactId>kotp-sdk</artifactId>
  <version>0.1.0</version>
</dependency>

import com.google.gson.JsonObject;
import dev.kotp.sdk.KotpClient;

try (KotpClient client = new KotpClient(System.getenv("KOTP_SECRET_KEY"))) {
    JsonObject issue = new JsonObject();
    issue.addProperty("phoneNumber", "01012345678");
    issue.addProperty("purpose", "login");
    issue.addProperty("idempotencyKey", idempotencyKey); // e.g. UUID.randomUUID().toString()
    String issueId = client.issue(issue).getAsJsonObject().get("issueId").getAsString();

    // Later, with the code the user entered:
    JsonObject verify = new JsonObject();
    verify.addProperty("issueId", issueId);
    verify.addProperty("code", "123456");
    boolean verified = client.verify(verify).getAsJsonObject().get("verified").getAsBoolean();
} catch (KotpClient.KotpApiException e) {
    System.err.println(e.status + " " + e.envelope.get("code") + " " + e.requestId);
} catch (KotpClient.KotpTransportException e) {
    // Outcome unknown: retry issue with the same idempotencyKey.
}

import com.google.gson.JsonObject
import dev.kotp.sdk.KotpClient

KotpClient(System.getenv("KOTP_SECRET_KEY")).use { client ->
    try {
        val issued = client.issue(JsonObject().apply {
            addProperty("phoneNumber", "01012345678")
            addProperty("purpose", "login")
            addProperty("idempotencyKey", idempotencyKey)
        })
        val issueId = issued.asJsonObject.get("issueId").asString

        val result = client.verify(JsonObject().apply {
            addProperty("issueId", issueId)
            addProperty("code", "123456")
        })
        val verified = result.asJsonObject.get("verified").asBoolean
    } catch (e: KotpClient.KotpApiException) {
        println("${e.status} ${e.envelope.get("code")} ${e.requestId}")
    } catch (e: KotpClient.KotpTransportException) {
        // Outcome unknown: retry issue with the same idempotencyKey.
    }
}

composer config repositories.kotp artifact ./packages
composer require k-otp/sdk:0.1.0

use KOtp\KotpApiError;
use KOtp\KotpClient;
use KOtp\KotpTransportError;

$client = new KotpClient(getenv('KOTP_SECRET_KEY'));

try {
    $issued = $client->issue([
        'phoneNumber' => '01012345678',
        'purpose' => 'login',
        'idempotencyKey' => $idempotencyKey, // e.g. bin2hex(random_bytes(16)), stored for retries
    ]);

    // Later, with the code the user entered:
    $result = $client->verify(['issueId' => $issued->issueId, 'code' => '123456']);
    $verified = $result->verified;
} catch (KotpApiError $e) {
    error_log("{$e->status} {$e->envelope->code} {$e->requestId}");
} catch (KotpTransportError $e) {
    // Outcome unknown: retry issue with the same idempotencyKey.
}

go get github.com/k-otp/sdk/sdks/go@v0.1.0

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"os"

	kotp "github.com/k-otp/sdk/sdks/go"
)

func sendAndVerify(ctx context.Context, idempotencyKey string) (bool, error) {
	client, err := kotp.New(kotp.Options{APIKey: os.Getenv("KOTP_SECRET_KEY")})
	if err != nil {
		return false, err
	}

	input, _ := json.Marshal(map[string]any{
		"phoneNumber":    "01012345678",
		"purpose":        "login",
		"idempotencyKey": idempotencyKey,
	})
	issued, err := client.Issue(ctx, input, kotp.RequestOptions{})
	var apiErr *kotp.APIError
	var transportErr *kotp.TransportError
	switch {
	case errors.As(err, &apiErr):
		return false, fmt.Errorf("%d %v %s", apiErr.Status, apiErr.Envelope["code"], apiErr.RequestID)
	case errors.As(err, &transportErr):
		return false, err // Outcome unknown: retry Issue with the same idempotencyKey.
	case err != nil:
		return false, err
	}
	issueID := issued.(map[string]any)["issueId"].(string)

	// Later, with the code the user entered:
	verifyInput, _ := json.Marshal(map[string]any{"issueId": issueID, "code": "123456"})
	result, err := client.Verify(ctx, verifyInput, kotp.RequestOptions{})
	if err != nil {
		return false, err
	}
	return result.(map[string]any)["verified"].(bool), nil
}

python -m pip install ./kotp_sdk-0.1.0-py3-none-any.whl

import asyncio
import os

from kotp_sdk import KotpApiError, KotpClient, KotpTransportError

async def main(idempotency_key: str) -> None:
    async with KotpClient(os.environ["KOTP_SECRET_KEY"]) as client:
        try:
            issued = await client.issue({
                "phoneNumber": "01012345678",
                "purpose": "login",
                "idempotencyKey": idempotency_key,  # e.g. str(uuid.uuid4()), stored for retries
            })

            # Later, with the code the user entered:
            result = await client.verify({"issueId": issued["issueId"], "code": "123456"})
            verified = result["verified"]
        except KotpApiError as e:
            print(e.status, e.envelope["code"], e.request_id)
        except KotpTransportError:
            pass  # Outcome unknown: retry issue with the same idempotency_key.


asyncio.run(main(idempotency_key))

gem install --local kotp_sdk-0.1.0.gem

require 'kotp_sdk'

client = KOtp::Client.new(ENV.fetch('KOTP_SECRET_KEY'))

begin
  issued = client.issue({
    'phoneNumber' => '01012345678',
    'purpose' => 'login',
    'idempotencyKey' => idempotency_key # e.g. SecureRandom.uuid, stored for retries
  })

  # Later, with the code the user entered:
  result = client.verify({ 'issueId' => issued['issueId'], 'code' => '123456' })
  verified = result['verified']
rescue KOtp::ApiError => e
  warn "#{e.status} #{e.envelope['code']} #{e.request_id}"
rescue KOtp::TransportError
  # Outcome unknown: retry issue with the same idempotency_key.
end

mkdir -p third_party/kotp_sdk
tar -xzf kotp-sdk-dart-0.1.0.tar.gz -C third_party/kotp_sdk

dependencies:
  kotp_sdk:
    path: third_party/kotp_sdk

import 'dart:io';

import 'package:kotp_sdk/kotp_sdk.dart';

final client = KotpClient(Platform.environment['KOTP_SECRET_KEY']!);
try {
  final issued = await client.issue({
    'phoneNumber': '01012345678',
    'purpose': 'login',
    'idempotencyKey': idempotencyKey, // stored for retries
  }) as Map<String, dynamic>;

  // Later, with the code the user entered:
  final result = await client.verify({
    'issueId': issued['issueId'],
    'code': '123456',
  }) as Map<String, dynamic>;
  final verified = result['verified'] as bool;
} on KotpApiError catch (e) {
  stderr.writeln('${e.status} ${e.envelope['code']} ${e.requestId}');
} on KotpTransportError {
  // Outcome unknown: retry issue with the same idempotencyKey.
} finally {
  client.close();
}

npm i @k-otp/sdk

import { KotpApiError, KotpClient, KotpTransportError } from "@k-otp/sdk/kiota";

const client = new KotpClient({ apiKey: process.env.KOTP_SECRET_KEY! });

try {
	const issued = (await client.issue({
		phoneNumber: "01012345678",
		purpose: "login",
		idempotencyKey, // e.g. crypto.randomUUID(), stored for retries
	})) as { issueId: string };

	// Later, with the code the user entered:
	const result = (await client.verify({ issueId: issued.issueId, code: "123456" })) as {
		verified: boolean;
		reasonCode?: string;
	};
} catch (error) {
	if (error instanceof KotpApiError) {
		console.error(error.status, error.envelope.code, error.requestId);
	} else if (error instanceof KotpTransportError) {
		// Outcome unknown: retry issue with the same idempotencyKey.
	} else {
		throw error;
	}
}