presignatureIDs, err := client.EdDSA().GeneratePresignatures(ctx, sessionConfig, keyID, presigCount)

presignatureID := presignatureIDs[0] // Use the first presignature in the batch
partialSignResult, err := client.EdDSA().SignWithPresignature(ctx, keyID, presignatureID, nil, message)

partialSignResult, err := client.EdDSA().SignWithPresignature(ctx, keyID, nil, derivationPath, message)
presignatureID := partialSignResult.PresignatureID

partialSignatures := [][]byte{ partialSignResult1.partialSignature, ...}
signature, err := tsm.EDDSAFinalizeSignature(message, partialSignatures)

// Delete all the player's presignature shares for a key.
err := client.KeyManagement().DeletePresignatures(ctx, keyID)

	// CountPresignatures returns a count of the presignatures available for a key.
presigCount, err := client.KeyManagement().CountPresignatures(ctx, keyID)

package main

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"gitlab.com/Blockdaemon/go-tsm-sdkv2/v70/tsm"
	"golang.org/x/sync/errgroup"
)

func main() {

	// Create clients for two of the nodes

	configs := []*tsm.Configuration{
		tsm.Configuration{URL: "http://localhost:8500"}.WithAPIKeyAuthentication("apikey0"),
		tsm.Configuration{URL: "http://localhost:8502"}.WithAPIKeyAuthentication("apikey2"),
	}

	clients := make([]*tsm.Client, len(configs))
	for i, config := range configs {
		var err error
		if clients[i], err = tsm.NewClient(config); err != nil {
			panic(err)
		}
	}

	// Generate ECDSA key

	threshold := 1         // Security threshold for this key
	players := []int{0, 2} // We want to use MPC node 0 and 2
	sessionID := tsm.GenerateSessionID()
	keyGenSessionConfig := tsm.NewSessionConfig(sessionID, players, nil)

	keyIDs := make([]string, len(clients))
	var eg errgroup.Group
	for i, client := range clients {
		client, i := client, i
		eg.Go(func() error {
			var err error
			keyIDs[i], err = client.ECDSA().GenerateKey(context.TODO(), keyGenSessionConfig, threshold, "secp256k1", "")
			return err
		})
	}

	if err := eg.Wait(); err != nil {
		panic(err)
	}

	// Validate key IDs

	for i := 1; i < len(keyIDs); i++ {
		if keyIDs[0] != keyIDs[i] {
			panic("key IDs do not match")
		}
	}
	keyID := keyIDs[0]
	fmt.Println("Generated key with ID", keyID, "on MPC nodes", players)

	// Generate ten presignatures

	presigSessionID := tsm.GenerateSessionID()
	presigSessionConfig := tsm.NewSessionConfig(presigSessionID, players, nil)
	presignatureIDs := make([][]string, len(players))

	for i, client := range clients {
		i, client := i, client
		eg.Go(func() error {
			var err error
			presignatureIDs[i], err = client.ECDSA().GeneratePresignatures(context.TODO(), presigSessionConfig, keyID, 10)
			return err
		})
	}

	if err := eg.Wait(); err != nil {
		panic(err)
	}

	// Validate presignature IDs

	for i := 1; i < len(presignatureIDs); i++ {
		if len(presignatureIDs[0]) != len(presignatureIDs[i]) {
			panic(fmt.Sprintf("size mismatch between index 0 (%d) and %d (%d)", len(presignatureIDs[0]), i, len(presignatureIDs[i])))
		}
		for j := 0; j < len(presignatureIDs[i]); j++ {
			if presignatureIDs[0][j] != presignatureIDs[i][j] {
				panic(fmt.Sprintf("values mismatch between index 0,%d (%s) and %d,%d (%s)", j, presignatureIDs[0][j], i, j, presignatureIDs[i][j]))
			}
		}
	}

	// We can now sign with the created key and one of the presignatures ;
	// this does not require MPC nodes to interact, so we don't have to do this concurrently.

	message := []byte("This is the message to be signed")
	msgHash := sha256.Sum256(message)

	partialSignatures := make([][]byte, 0)
	for _, client := range clients {
		client := client
		partialSignResult, err := client.ECDSA().SignWithPresignature(context.TODO(), keyID, presignatureIDs[0][0], nil, msgHash[:])
		if err != nil {
			panic(err)
		}
		partialSignatures = append(partialSignatures, partialSignResult.PartialSignature)
	}

	// Combine partial signatures from each of the MPC nodes into the final signature

	signature, err := tsm.ECDSAFinalizeSignature(msgHash[:], partialSignatures)
	if err != nil {
		panic(err)
	}

	fmt.Println("Signature:", hex.EncodeToString(signature.ASN1()))

}

package com.example;

import com.sepior.tsm.sdkv2.*;

import java.util.*;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.function.Supplier;

public class EcdsaSignWithPresigExample {

    public static void main(String[] args) throws Exception {

        // Create a client for each MPC node

        Configuration[] configs = {
                new Configuration("http://localhost:8500"),
                new Configuration("http://localhost:8501"),
                new Configuration("http://localhost:8502"),
        };
        configs[0].withApiKeyAuthentication("apikey0");
        configs[1].withApiKeyAuthentication("apikey1");
        configs[2].withApiKeyAuthentication("apikey2");

        Client[] clients = {
                new Client(configs[0]),
                new Client(configs[1]),
                new Client(configs[2]),
        };


        // Generate an ECDSA key

        final int[] keyGenPlayers = {0, 1, 2}; // The key should be secret shared among all three MPC nodes
        final int threshold = 1; // The security threshold for this key
        final String curveName = "secp256k1"; // We want the key to be a secp256k1 key (e.g., for Bitcoin)

        String keyGenSessionId = SessionConfig.generateSessionId();
        final SessionConfig keyGenSessionConfig = SessionConfig.newSessionConfig(keyGenSessionId, keyGenPlayers, null);

        System.out.println("Generating key using players " + Arrays.toString(keyGenPlayers));
        List<String> keyGenResults = runConcurrent(
                () -> clients[0].getEcdsa().generateKey(keyGenSessionConfig, threshold, curveName, null),
                () -> clients[1].getEcdsa().generateKey(keyGenSessionConfig, threshold, curveName, null),
                () -> clients[2].getEcdsa().generateKey(keyGenSessionConfig, threshold, curveName, null));
        String keyId = keyGenResults.get(0);
        System.out.println("Generated key with ID: " + keyId);

        // Generate ten presignatures for the key

        int[] presigGenPlayers = {0, 1, 2}; // We must use same set of players as when we generated the key
        int presigCount = 10;

        System.out.println("Generating " + presigCount + " presignatures using players " + Arrays.toString(presigGenPlayers));
        String presigGenSessionId = SessionConfig.generateSessionId();
        SessionConfig presigGenSessionConfig = SessionConfig.newSessionConfig(presigGenSessionId, presigGenPlayers, null);
        List<String[]> presigGenResults = runConcurrent(
                () -> clients[0].getEcdsa().generatePresignatures(presigGenSessionConfig, keyId, presigCount),
                () -> clients[1].getEcdsa().generatePresignatures(presigGenSessionConfig, keyId, presigCount),
                () -> clients[2].getEcdsa().generatePresignatures(presigGenSessionConfig, keyId, presigCount));
        String[] presigIds = presigGenResults.get(0);

        // We can now sign a message with the created key and one of the presignatures ;
        // this does not require MPC nodes to interact, so we don't have to do this concurrently.

        byte[] messageHash = new byte[32];  // Normally, this is the SHA256 hash of the message.
        int[] signPlayers = {0, 1, 2}; // All players needed for signing when using presignatures
        int[] derivationPath = null; // In this example we do not use key derivation

        System.out.println("Signing message with players " + Arrays.toString(signPlayers) + " and using presig " + presigIds[0]);

        // No MPC node interaction required; no need to do this in parallel
        byte[][] partialSignatures = {
                clients[0].getEcdsa().signWithPresignature(keyId, presigIds[0], derivationPath, messageHash).getPartialSignature(),
                clients[1].getEcdsa().signWithPresignature(keyId, presigIds[0], derivationPath, messageHash).getPartialSignature(),
                clients[2].getEcdsa().signWithPresignature(keyId, presigIds[0], derivationPath, messageHash).getPartialSignature(),
        };

        // Combine partial signatures from each of the MPC nodes into the final signature and validate it against the message

        EcdsaSignature signature = com.sepior.tsm.sdkv2.Ecdsa.finalizeSignature(messageHash, partialSignatures);
        System.out.println("Signature: 0x" + bytesToHex(signature.getSignature()));

    }


    @SafeVarargs
    static <T> List<T> runConcurrent(Supplier<T>... players) throws Exception {
        List<T> result = new ArrayList<T>(players.length);
        Queue<Exception> errors = new ConcurrentLinkedQueue<Exception>();
        for (int i = 0; i < players.length; i++) {
            result.add(null);
        }
        Thread[] threads = new Thread[players.length];
        for (int i = 0; i < players.length; i++) {
            final int index = i;
            Thread thread = new Thread() {
                public void run() {
                    try {
                        T runResult = players[index].get();
                        result.set(index, runResult);
                    } catch (Exception e) {
                        errors.add(e);
                    }
                }
            };
            threads[i] = thread;
            thread.start();
        }
        for (int i = 0; i < players.length; i++) {
            threads[i].join();
        }
        if (!errors.isEmpty()) {
            throw new RuntimeException("One of the threads failed executing command", errors.remove());
        }
        return result;
    }

    static char[] HEX_ARRAY = "0123456789ABCDEF".toCharArray();

    public static String bytesToHex(byte[] bytes) {
        char[] hexChars = new char[bytes.length * 2];
        for (int j = 0; j < bytes.length; j++) {
            int v = bytes[j] & 0xFF;
            hexChars[j * 2] = HEX_ARRAY[v >>> 4];
            hexChars[j * 2 + 1] = HEX_ARRAY[v & 0x0F];
        }
        return new String(hexChars);
    }

}

const { TSMClient, Configuration, SessionConfig, curves } = require("@sepior/tsmsdkv2");
const crypto = require('crypto');

async function main() {
  // Create clients for two of the nodes

  const configs = [
    {
      url: "http://localhost:8500",
      apiKey: "apikey0",
    },
    {
      url: "http://localhost:8502",
      apiKey: "apikey2",
    },
  ];

  const clients = [];

  for (const rawConfig of configs) {
    const config = await new Configuration(rawConfig.url);
    await config.withAPIKeyAuthentication(rawConfig.apiKey);
    const client = await TSMClient.withConfiguration(config);

    clients.push(client);
  }

  // Generate an ECDSA

  const threshold = 1; // The security threshold for this key
  const players = [0, 2]; // We want to use MPC node 0 and 2
  const keygenSessionConfig = await SessionConfig.newSessionConfig(
    await SessionConfig.GenerateSessionID(),
    new Uint32Array(players),
    {}
  );

  const keyIds = ["", ""];

  const generateKeyPromises = [];

  for (const [i, client] of clients.entries()) {
    const func = async () => {
      const ecdsaApi = client.ECDSA();
      keyIds[i] = await ecdsaApi.generateKey(
        keygenSessionConfig,
        threshold,
        curves.SECP256K1,
        ""
      );
    };
    generateKeyPromises.push(func());
  }

  await Promise.all(generateKeyPromises);

  // Validate key IDs

  for (let i = 1; i < keyIds.length; i++) {
    if (keyIds[0] !== keyIds[i]) {
      console.log("Key ids do not match");
      return;
    }
  }

  const keyId = keyIds[0];

  console.log(`Generated key with id: ${keyId} on MPC nodes ${players}`);

  // Generate ten presignatures
  const presigSessionId = await SessionConfig.GenerateSessionID();
  const presigSessionConfig = await SessionConfig.newSessionConfig(
    presigSessionId,
    new Uint32Array(players),
    {}
  );
  const presignatureIds = [[], []];

  const presignaturePromises = [];

  for (const [i, client] of clients.entries()) {
    const func = async () => {
      const ecdsaApi = client.ECDSA();

      presignatureIds[i] = await ecdsaApi.generatePresignatures(
        presigSessionConfig,
        keyId,
        10
      );
    };

    presignaturePromises.push(func());
  }

  await Promise.all(presignaturePromises);

  // Validate presignature IDs
  for (let i = 1; i < presignatureIds; i++) {
    if (presignatureIds[0].length !== presignatureIds[1].length) {
      console.log(
        `Size mismatch between index 0 (${presignatureIds[0].length}) and ${i} (${presignatureIds[i].length})`
      );
      return;
    }

    for (let j = 0; j < presignatureIds[i]; j++) {
      if (presignatureIds[0][j] !== presignatureIds[i][j]) {
        console.log(
          `Value mismatch between index 0,${j} (${presignatureIds[0][j]}) and ${i},${j} (${presignatureIds[i][j]})`
        );
        return;
      }
    }
  }

  // We can now sign with the created key and one of the presignatures ;
  // this does not require MPC nodes to interact, so we don't have to do this concurrently.

  const message = "This is a message to be signed";
  const messageHash = crypto.createHash("sha256").update(message).digest();

  const partialSignatures = [];

  for (const client of clients) {
    const ecdsaApi = client.ECDSA();
    const partialSignResult = await ecdsaApi.signWithPresignature(
      keyId,
      presignatureIds[0][0],
      new Uint32Array([]),
      messageHash
    );

    partialSignatures.push(partialSignResult.partialSignature);
  }

  // Combine partial signatures from each of the MPC nodes into the final signature

  const ecdsaApi = clients[0].ECDSA();
  const signature = await ecdsaApi.finalizeSignature(
    messageHash,
    partialSignatures
  );

  console.log(`Signature: ${Buffer.from(signature.signature).toString("hex")}`);
}

main()