Add an option to let go remote signer respond directly through webhooks.

examples/remote-signing-server/config.go

@@ -13,13 +13,15 @@ const API_CLIENT_ID = "API_CLIENT_ID"
 const API_CLIENT_SECRET = "API_CLIENT_SECRET"
 const WEBHOOK_SECRET = "WEBHOOK_SECRET"
 const MASTER_SEED_HEX = "MASTER_SEED_HEX"
+const RESPOND_DIRECTLY = "RESPOND_DIRECTLY"
 
 type Config struct {
 	ApiEndpoint     *string
 	ApiClientId     string
 	ApiClientSecret string
 	WebhookSecret   string
 	MasterSeed      []byte
+	RespondDirectly bool
 }
 
 func NewConfigFromEnv() (*Config, error) {
@@ -54,6 +56,8 @@ func NewConfigFromEnv() (*Config, error) {
 		return nil, fmt.Errorf("invalid master seed: %s", err)
 	}
 
+	_, respondDirectly := os.LookupEnv(RESPOND_DIRECTLY)
+
 	log.Print("Loaded configuration:")
 	log.Printf("  - API_ENDPOINT: %s", showEmpty(apiEndpointStr))
 	log.Printf("  - API_CLIENT_ID: %s", showEmpty(apiClientId))
@@ -67,6 +71,7 @@ func NewConfigFromEnv() (*Config, error) {
 		ApiClientSecret: apiClientSecret,
 		WebhookSecret:   webhookSecret,
 		MasterSeed:      masterSeed,
+		RespondDirectly: respondDirectly,
 	}, nil
 }
 

examples/remote-signing-server/server.go

@@ -64,21 +64,37 @@ func main() {
 
 		switch event.EventType {
 		case objects.WebhookEventTypeRemoteSigning:
-			resp, err := remotesigning.HandleRemoteSigningWebhook(
-				lsClient, remotesigning.PositiveValidator{}, *event, config.MasterSeed)
-			if err != nil {
-				log.Printf("ERROR: Unable to handle remote signing webhook: %s", err)
-				c.AbortWithStatus(http.StatusInternalServerError)
-				return
-			}
+			if config.RespondDirectly {
+				resp, err := remotesigning.GraphQLResponseForRemoteSigningWebhook(
+					*event, config.MasterSeed)
+				if err != nil {
+					log.Printf("ERROR: Unable to handle remote signing webhook: %s", err)
+					c.AbortWithStatus(http.StatusInternalServerError)
+					return
+				}
 
-			if resp != "" {
-				log.Printf("Webhook complete with response: %s", resp)
+				if resp != nil {
+					c.JSON(http.StatusOK, resp.GraphqlResponse().Variables)
+				} else {
+					c.Status(http.StatusNoContent)
+				}
 			} else {
-				log.Printf("Webhook complete")
-			}
+				resp, err := remotesigning.HandleRemoteSigningWebhook(
+					lsClient, remotesigning.PositiveValidator{}, *event, config.MasterSeed)
+				if err != nil {
+					log.Printf("ERROR: Unable to handle remote signing webhook: %s", err)
+					c.AbortWithStatus(http.StatusInternalServerError)
+					return
+				}
 
-			c.Status(http.StatusNoContent)
+				if resp != "" {
+					log.Printf("Webhook complete with response: %s", resp)
+				} else {
+					log.Printf("Webhook complete")
+				}
+
+				c.Status(http.StatusNoContent)
+			}
 		default:
 			c.Status(http.StatusNoContent)
 		}

remotesigning/remote_signing.go

@@ -34,41 +34,54 @@ func HandleRemoteSigningWebhook(
 	webhook webhooks.WebhookEvent,
 	seedBytes []byte,
 ) (string, error) {
+	if !validator.ShouldSign(webhook) {
+		return DeclineToSignMessages(client, webhook)
+	}
+
+	response, err := GraphQLResponseForRemoteSigningWebhook(webhook, seedBytes)
+
+	if err != nil {
+		return "", err
+	}
+
+	if response == nil {
+		// No response is required for this event type.
+		return "", nil
+	}
+
+	return HandleSigningResponse(client, response)
+}
+
+func GraphQLResponseForRemoteSigningWebhook(
+	webhook webhooks.WebhookEvent,
+	seedBytes []byte,
+) (SigningResponse, error) {
 	if webhook.EventType != objects.WebhookEventTypeRemoteSigning {
-		return "", errors.New("webhook event is not for remote signing")
+		return nil, errors.New("webhook event is not for remote signing")
 	}
 	if webhook.Data == nil {
-		return "", errors.New("webhook data is missing")
+		return nil, errors.New("webhook data is missing")
 	}
 	var subtype objects.RemoteSigningSubEventType
 	subEventTypeStr := (*webhook.Data)["sub_event_type"].(string)
 	log.Printf("Received remote signing webhook with sub_event_type %s", subEventTypeStr)
 	err := subtype.UnmarshalJSON([]byte(`"` + subEventTypeStr + `"`))
 	if err != nil {
-		return "", errors.New("invalid remote signing sub_event_type")
-	}
-
-	if !validator.ShouldSign(webhook) {
-		return DeclineToSignMessages(client, webhook)
+		return nil, errors.New("invalid remote signing sub_event_type")
 	}
 
 	request, err := ParseRemoteSigningRequest(webhook)
 	if err != nil {
-		return "", err
+		return nil, err
 	}
 
 	response, err := HandleSigningRequest(request, seedBytes)
 
 	if err != nil {
-		return "", err
-	}
-
-	if response == nil {
-		// No response is required for this event type.
-		return "", nil
+		return nil, err
 	}
 
-	return HandleSigningResponse(client, response)
+	return response, nil
 }
 
 func HandleSigningRequest(request SigningRequest, seedBytes []byte) (SigningResponse, error) {