Merge branch 'main' into main

Author: EnriqueL8

doc-site/docs/tutorials/chains/cardano.md

@@ -46,6 +46,20 @@ ff init cardano dev \
     --blockfrost-key previewXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 ```
 
+### Option 3: Use Blockfrost RYO
+
+You can run a Blockfrost API provider for free on your own infrastructure. This is called Blockfrost Run-Your-Own or Blockfrost RYO. See [the service's GitHub page](https://github.com/blockfrost/blockfrost-backend-ryo) for more information on this.
+
+The example below uses firefly-cli to
+ - Create a new Cardano-based stack named `dev`
+ - Connect to a Blockfrost RYO instance running at http://localhost:3000
+
+```sh
+ff init cardano dev \
+    --network preview \
+    --blockfrost-base-url http://localhost:3000
+```
+
 ## Start the stack
 
 Now you should be able to start your stack by running:
@@ -84,3 +98,7 @@ The response will look like
 ```
 
 If you're developing against a testnet such as preview, you can receive funds from the [testnet faucet](https://docs.cardano.org/cardano-testnets/tools/faucet). Pass the `address` from that response to the faucet.
+
+## Next steps: Develop a contract
+
+Now that you have a stack running, you're ready to start developing contracts for it. See the [Cardano custom contract guide](../custom_contracts/cardano.md) for more information.

internal/reference/reference.go

@@ -24,6 +24,7 @@ import (
 	"os"
 	"path/filepath"
 	"reflect"
+	"slices"
 	"strings"
 
 	"github.com/hyperledger/firefly-common/pkg/fftypes"
@@ -892,17 +893,11 @@ func writeStructFields(ctx context.Context, t reflect.Type, rootPageNames, simpl
 
 		fieldInRootPages := false
 		fieldInSimpleTypes := false
-		for _, rootPageName := range rootPageNames {
-			if strings.ToLower(fieldType.Name()) == rootPageName {
-				fieldInRootPages = true
-				break
-			}
+		if slices.Contains(rootPageNames, strings.ToLower(fieldType.Name())) {
+			fieldInRootPages = true
 		}
-		for _, simpleTypeName := range simpleTypeNames {
-			if strings.ToLower(fieldType.Name()) == simpleTypeName {
-				fieldInSimpleTypes = true
-				break
-			}
+		if slices.Contains(simpleTypeNames, strings.ToLower(fieldType.Name())) {
+			fieldInSimpleTypes = true
 		}
 
 		link := ""
@@ -920,13 +915,7 @@ func writeStructFields(ctx context.Context, t reflect.Type, rootPageNames, simpl
 			fireflyType = fmt.Sprintf("[%s](%s)", fireflyType, link)
 
 			// Generate the table for the sub type
-			tableAlreadyGenerated := false
-			for _, tableName := range generatedTableNames {
-				if strings.ToLower(fieldType.Name()) == tableName {
-					tableAlreadyGenerated = true
-					break
-				}
-			}
+			tableAlreadyGenerated := slices.Contains(generatedTableNames, strings.ToLower(fieldType.Name()))
 			if isStruct && !tableAlreadyGenerated && !fieldInRootPages && !fieldInSimpleTypes {
 				subFieldBuff.WriteString(fmt.Sprintf("## %s\n\n", fieldType.Name()))
 				subFieldMarkdown, newTableNames, _ := generateObjectReferenceMarkdown(ctx, false, nil, fieldType, rootPageNames, simpleTypeNames, generatedTableNames, outputPath)

internal/spievents/websockets.go

@@ -20,6 +20,7 @@ import (
 	"context"
 	"encoding/json"
 	"io"
+	"slices"
 	"sync"
 	"time"
 
@@ -66,36 +67,18 @@ func newWebSocket(ae *adminEventManager, wsConn *websocket.Conn) *webSocket {
 }
 
 func (wc *webSocket) eventMatches(changeEvent *core.ChangeEvent) bool {
-	collectionMatches := false
-	for _, c := range wc.collections {
-		if c == changeEvent.Collection {
-			collectionMatches = true
-			break
-		}
-	}
+	collectionMatches := slices.Contains(wc.collections, changeEvent.Collection)
 	if !collectionMatches {
 		return false
 	}
 	if len(wc.filter.Namespaces) > 0 {
-		namespaceMatches := false
-		for _, ns := range wc.filter.Namespaces {
-			if ns == changeEvent.Namespace {
-				namespaceMatches = true
-				break
-			}
-		}
+		namespaceMatches := slices.Contains(wc.filter.Namespaces, changeEvent.Namespace)
 		if !namespaceMatches {
 			return false
 		}
 	}
 	if len(wc.filter.Types) > 0 {
-		typeMatches := false
-		for _, t := range wc.filter.Types {
-			if t == changeEvent.Type {
-				typeMatches = true
-				break
-			}
-		}
+		typeMatches := slices.Contains(wc.filter.Types, changeEvent.Type)
 		if !typeMatches {
 			return false
 		}