Precompute Sign

Presign allows the signing parties to offline precompute expensive signanture material. Offline means before any active user needs to sign a specific message. By doing so the total running time for computing signatures is almost instant minimizing net work traffic load and computation demand.

We can finalise the precomputed signature with actual message later.

Step 1 : Create Session

---

• Create TrioSession if you haven't already.

Step 2 : Perform Precompute Signature

---

• Call trioSession.preSignature() which returns Result of Success with Precompute Signature ByteArray or Failure with exception.

      trioSession.preSignature(keyshare = keyshare).onSuccess { preComputedSignature ->
      //todo: Do final signature later using preComputedSignature (lambda argument received here)
          Log.i(
          "PreComputeSignature","Success, Pre Computed Signature size : ${preComputedSignature.size}")
          }.onFailure { failureReason ->
              Log.e("PreComputeSignature", failureReason.message ?: "")
          }
  • keyshare is the client's "share" of the MPC wallet.
  • preComputedSignature is the pre computed signature as ByteArray which could later be used to perform final signature.

Step 3 : Finalise Precompute Signature (Later in the future)

---

• Call trioSession.preSignatureFinal() which returns Result of Success with the Final Signature ByteArray or Failure with exception.

   val messageHash = "e2a159d17b7bb714aed7675d7c7d394dec8d2e4337842848104694bf89c71c03"
  
   //preSignature for context (Step 2)
   trioSession.preSignature(keyshare = keyshare).onSuccess { preComputedSignature ->
              Log.i(
              "PreComputeSignature","Success, Pre Computed Signature size : ${preComputedSignature.size}")
              trioSession.preSignatureFinal(
                                 preSignature = preComputedSignature, message = messageHash
                             ).onSuccess { finalSignature ->
                                 Log.i("PreSignatureFinal", "Success, Signature size : ${finalSignature.size}")
                             }.onFailure { reason ->
                                 Log.e("PreSignatureFinal", reason.message ?: "")
                             }
              }.onFailure { failureReason ->
                  Log.e("PreComputeSignature", failureReason.message ?: "")
              }
         }.onFailure { failureReason ->
             Log.e("PreComputeSignature", failureReason.message ?: "")
         }
  • preComputedSignature is the pre computed signature as ByteArray generated in step 2.
  • messageHash is the messageHash in Hex string without 0x suffix (absolute hex-string).

Example (Precompute Signature and Finalise Precomputed Signature)

---

Example.swift

func performPreSignature(keyshare: Data, trioSession: TrioSession) async -> Data?
{
    let messageHash = "e2a159d17b7bb714aed7675d7c7d394dec8d2e4337842848104694bf89c71c03"

    //compute pre-signature
    let result = await trioSession.preSignature(keyshare: keyshare)
    // returns nil if operation fails or other flow you might have
    switch result {
        case .success(let dataBytes):
        do {
            //preSign success
            //todo: Do final signature later using preComputedSignature (lambda argument received here)
            Swift.print("PreComputeSignature : Success, Pre Computed Signature size : \(dataBytes.count)")

            //since preSign was success, we can now perform the signature (finalize pre-sign) with the message
            let finalResult = await trioSession.preSignatureFinal(
                preSignature: dataBytes,
                message: messageHash,
                chainPath: "m" // This is the default, use your desired path here. For e.g 'm/1/2'
            )
            // returns nil if operation fails or other flow you might have
            switch finalResult {
                case .success(let finalSignatureBytes):
                //preSignFinal was a success
                do {
                    Swift.print("PreSignatureFinal : Success, Signature size : \(finalSignatureBytes.count)")
                    return dataBytes
                }
                case .failure(let error):
                do {
                    //preSignFinal failed
                    // show error to user or abort process
                    Swift.print(error)
                    return nil
                }
            }
        }
        case .failure(let error):
        do {
            //preSign fail
            // show error to user or abort process
            Swift.print(error)
            return nil
        }
    }
}

• keyshare is the client's "share" of the MPC wallet.
• preComputedSignature is the pre computed signature as ByteArray which could later be used to perform final signature.
• messageHash is the messageHash in Hex string without 0x suffix (absolute hex-string).

---

• trioSession.preSignature() performs message exchange between mobile and server to generate a pre computed ECDSA/EdDSA signature as ByteArray which is expected to be used to finalise the signature later with message.
• Result of trioSession.preSignature() could be a Success with ByteArray (ECDSA/EdDSA pre-computed signature), corresponding to the public key (or address) of the wallet or Failure with Exception.

---

• trioSession.preSignatureFinal() performs message exchange between mobile and server to generate a ECDSA/EdDSA signature.
• Result of trioSession.preSignatureFinal() could be a Success with ByteArray (ECDSA/EdDSA signature) of messageHash, corresponding to the public key (or address) of the wallet or Failure with Exception.