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 bytes as Data or Failure with error.

      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 {
              //todo: Do final signature later using preComputedSignature (lambda argument received here)
              Swift.print("PreComputeSignature : Success, Pre Computed Signature size : \(dataBytes.count)")
              return dataBytes
          }
      case .failure(let error):
          do {
              // 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 bytes as Data 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 bytes as Data or Failure with error.

  
      let messageHash = "e2a159d17b7bb714aed7675d7c7d394dec8d2e4337842848104694bf89c71c03"
  
      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 {
              //todo: Do final signature later using preComputedSignature (lambda argument received here)
              Swift.print("PreComputeSignature : Success, Pre Computed Signature size : \(dataBytes.count)")
  
  
              let finalResult = await trioSession.preSignatureFinal(
                  preSignature: dataBytes,
                  message: messageHash
              )
              // returns nil if operation fails or other flow you might have
              switch finalResult {
              case .success(let finalSignatureBytes):
                  do {
                      Swift.print("PreSignatureFinal : Success, Signature size : \(finalSignatureBytes.count)")
                      return dataBytes
                  }
              case .failure(let error):
                  do {
                      // show error to user or abort process
                      Swift.print(error)
                      return nil
                  }
              }
          }
      case .failure(let error):
          do {
              // show error to user or abort process
              Swift.print(error)
              return nil
          }
      }

  • preComputedSignature is the pre computed signature bytes as Data 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.kt

val messageHash = "e2a159d17b7bb714aed7675d7c7d394dec8d2e4337842848104694bf89c71c03"

suspend fun performPreComputeSignatureAndFinalisePreComputeSignature(
    keyshare: ByteArray,
    trioSession: TrioSession,
): Result<ByteArray> {
    //suspending operation
    return withContext(Dispatchers.IO) {
        //compute pre-signature
        trioSession.preSignature(keyshare = keyshare)
            .onSuccess { preComputedSignature: ByteArray ->
                //preSign success
                Log.i(
                    "PreComputeSignature",
                    "Success, Pre Computed Signature size : ${preComputedSignature.size}"
                )
                //since preSign was success, we can now perform the signature (finalize pre-sign) with the message
                trioSession.preSignatureFinal(
                    preSignature = preComputedSignature, message = messageHash,
                    derivationPath = "m" // This is the default, use your desired path here. For e.g 'm/1/2'
                ).onSuccess { finalSignature: ByteArray ->
                    //preSignFinal was a success
                    Log.i("PreSignatureFinal", "Success, Signature size : ${finalSignature.size}")
                }.onFailure { reason: Throwable ->
                    //preSignFinal failed
                    Log.e("PreSignatureFinal", reason.message ?: "")
                }
            }
            //preSign fail
            .onFailure { failureReason: Throwable ->
                Log.e("PreComputeSignature", failureReason.message ?: "")
            }
    }
}

• keyshare is the client's "share" of the MPC wallet.
• preComputedSignature is the pre computed signature bytes as Data 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 byte as Data which is expected to be used to finalise the signature later with message.
• Result of trioSession.preSignature() could be a Success with bytes as Data (ECDSA/EdDSA pre-computed signature), corresponding to the public key (or address) of the wallet or Failure with error.

---

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