const { TSMClient, algorithms, curves } = require('@sepior/tsm');
const crypto = require("crypto");

let example = async function() {

  // Remember to change player count and threshold to match your TSM configuration
  let playerCount = 2;
  let threshold = 1;
  let tsmClient = await TSMClient.init(playerCount, threshold, [
        {
            url: 'http://tsm-node-1',
            userID: 'user',
            password: 'password1'
        },
        {
            url: 'http://tsm-node-2',
            userID: 'user',
            password: 'password2'
        }]);

    // Create a key in the TSM
    let keyID = await tsmClient.keygen(algorithms.EDDSA, curves.ED25519);
  
    // The message hash we want to sign
    const message = Buffer.from("some data to sign");

    // Sign the message hash using the key
    const chainPath = new Uint32Array();
    const signature = await tsmClient.sign(algorithms.EDDSA, keyID, chainPath, message);

    // Get the public key
    let pk = await tsmClient.publicKey(algorithms.EDDSA, keyID, chainPath);
  
    // Check that the signature is valid
    let isValid = await tsmClient.verify(algorithms.EDDSA, pk, message, signature, curves.ED25519);
    console.log("valid?", isValid)

    // Delete the key
    await tsmClient.delete(keyID);
    await tsmClient.close();

}

example();

const { TSMClient, algorithms, curves } = require('@sepior/tsm');
const crypto = require("crypto");

let example = async function() {

    // Initialize a separate SDK for each MPC node in the TSM
    // Remember to change player count and threshold to match you configuration
    let playerCount = 3;
    let threshold = 1;
    let tsmClient1 = await TSMClient.init(playerCount, threshold, [
        {
            url: 'http://tsm-node-1',
            userID: 'user',
            password: 'password1'
        }]);

    let tsmClient2 = await TSMClient.init(playerCount, threshold, [
        {
            url: 'http://tsm-node-2',
            userID: 'user',
            password: 'password2'
        }]);


    let tsmClient3 = await TSMClient.init(playerCount, threshold, [
        {
            url: 'http://tsm-node-3',
            userID: 'user',
            password: 'password3'
        }]);


    // Step 1: Generate a key in the TSM

    // The three SDKs need to first agree on a unique session ID.
    let sessionID = "session1";

    // Each SDK must call keygenWithSessionID with the session ID.
    let results = await Promise.all([
        tsmClient1.keygenWithSessionID(algorithms.ECDSA, sessionID, curves.SECP256K1),
        tsmClient2.keygenWithSessionID(algorithms.ECDSA, sessionID, curves.SECP256K1),
        tsmClient3.keygenWithSessionID(algorithms.ECDSA, sessionID, curves.SECP256K1)]);

    // As a result of the interactive protocol, each SDK receives the key ID.
    keyID = results[0];
    console.log("Generated key with key ID:", keyID);


    // Step 2: Generate five pre-signatures

    sessionID = "session2"
    presigCount = 5;
    results = await Promise.all([
        tsmClient1.presigGenWithSessionID(algorithms.ECDSA, sessionID, keyID, presigCount),
        tsmClient2.presigGenWithSessionID(algorithms.ECDSA, sessionID, keyID, presigCount),
        tsmClient3.presigGenWithSessionID(algorithms.ECDSA, sessionID, keyID, presigCount)]);
    presigIDs = results[0];
    console.log("Generated presigs with IDs:", presigIDs);

  
    // Step 3: Create partial signatures of a message non-interactively using one of the presignatures.

    // The message hash to sign
    let msg = "some data to sign";
    let sha256 = crypto.createHash('sha256');
    sha256.update(msg);
    let msgHash = sha256.digest();

    // In this example we will not sign with the master key, but with a key derived from the
    // master key using the chain path m/0/3.
    let chainPath = new Uint32Array([0, 3]);

    // Create a set of partial signatures using one of the presignatures.
    // Note that this does not require interaction between the MPC nodes, so we don't have to do this in parallel.
    sessionID = "session3";
    presigID = presigIDs[0];
    let [partialSignature1] = await tsmClient1.partialSignWithPresig(algorithms.ECDSA, keyID, presigID, chainPath, msgHash);
    let [partialSignature2] = await tsmClient2.partialSignWithPresig(algorithms.ECDSA, keyID, presigID, chainPath, msgHash);
    let [partialSignature3] = await tsmClient3.partialSignWithPresig(algorithms.ECDSA, keyID, presigID, chainPath, msgHash);

  
    // Step 4: Combine the partial signatures into the final signature

    let [signature] = await tsmClient1.finalize(algorithms.ECDSA, [partialSignature1, partialSignature2, partialSignature3]);

    // Check that the signature is valid
    let [,pk] = await tsmClient1.publicKey(algorithms.ECDSA, keyID, chainPath);
    let isValid = await tsmClient1.verify(algorithms.ECDSA, pk, msgHash, signature, curves.SECP256K1);
    console.log("Is signature valid?", isValid)

}

example();

const { TSMClient, algorithms, curves} = require('./tsmclient');

const crypto = require("crypto");
const fs = require("fs");

let example = async function() {
  const clientPrivateKey = fs.readFileSync('./mtlscerts/client/client.key');
  const clientCertificate = fs.readFileSync('./mtlscerts/client/client.crt');
	const serverPrivateKey = fs.readFileSync('./mtlscerts/server/server.key')

	const serverPublicKey = crypto.createPublicKey({
		key: serverPrivateKey,
			format: 'pem'
		});

	const derServerPublicKey = serverPublicKey.export({
  	type: 'spki',
    format: "der"
	});

  const urls = ["https://localhost:8097", "https://localhost:8098", "https://localhost:8099"];

  const mTLSClient = await TSMClient.initMTLS(urls, clientCertificate, clientPrivateKey, derServerPublicKey);

  const ecdsaKeyID = await mTLSClient.keygen(algorithms.ECDSA, curves.SECP256K1);
  console.log(ecdsaKeyID);

  const eddsaKeyID = await mTLSClient.keygen(algorithms.EDDSA, curves.ED448);
  console.log(eddsaKeyID);

  await mTLSClient.delete(ecdsaKeyID);
  await mTLSClient.delete(eddsaKeyID);
  await mTLSClient.close();
}

example();

FROM node:current

WORKDIR /root

# Set up NPM auth
RUN npm config set @sepior:registry=https://nexus.sepior.net/repository/sepior-nodejs-tsm-sdk-group/
RUN npm config set //nexus.sepior.net/repository/sepior-nodejs-tsm-sdk-group/:username=YOURUSERNAME
RUN npm config set //nexus.sepior.net/repository/sepior-nodejs-tsm-sdk-group/:_password=`echo -n 'YOURPASSWORD' | base64`
RUN npm config set //nexus.sepior.net/repository/sepior-nodejs-tsm-sdk-group/:email=YOUREMAIL

RUN npm install --verbose @sepior/tsm --registry=https://nexus.sepior.net/repository/sepior-nodejs-tsm-sdk-group/