Merge pull request #475 from LF-Decentralized-Trust-labs/paladin-sdk

Misc SDK and operator fixes

domains/pente/src/test/java/io/kaleido/paladin/pente/domain/BondTest.java

@@ -130,6 +130,7 @@ void testBond() throws Exception {
                     assertEquals("type=TransactionData(bytes32 salt,bytes data),labels=[]", schema.signature());
                 }
             }
+            assertNotNull(notoSchema);
 
             String bondTrackerPublicBytecode = ResourceLoader.jsonResourceEntryText(
                     this.getClass().getClassLoader(),
@@ -287,7 +288,7 @@ void testBond() throws Exception {
                     "");
             var deployEvent = events.stream().filter(ev -> ev.get("soliditySignature").toString().startsWith("event AtomDeployed")).findFirst();
             assertFalse(deployEvent.isEmpty());
-            var deployEventData = (HashMap<String, Object>) deployEvent.get().get("data");
+            var deployEventData = mapper.convertValue(deployEvent.get().get("data"), HashMap.class);
             var atomAddress = JsonHex.addressFrom(deployEventData.get("addr").toString());
 
             // Alice approves payment transfer

operator/api/v1alpha1/paladin_types.go

@@ -189,21 +189,29 @@ const (
 	// AuthTypeSecret is used to authenticate with a secret
 	// The secret must contain keys "username" and "password"
 	AuthTypeSecret AuthType = "secret"
+	AuthTypeInline AuthType = "inline"
 )
 
 type Auth struct {
 	// auth method to use for the connection
-	// +kubebuilder:validation:Enum=secret
+	// +kubebuilder:validation:Enum=secret;inline
 	Type AuthType `json:"type"`
 
 	// Secret is used to provide the name of the secret to use for authentication
 	Secret *AuthSecret `json:"secretRef,omitempty"`
+
+	// Auth details are provided inline (not recommended)
+	Inline *AuthInline `json:"inline,omitempty"`
 }
 
 type AuthSecret struct {
 	// The name of the secret to use for authentication
 	Name string `json:"name"`
 }
+type AuthInline struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
 
 // StatusReason is an enumeration of possible failure causes.  Each StatusReason
 // must map to a single HTTP status code, but multiple reasons may map

operator/config/crd/bases/core.paladin.io_paladins.yaml

@@ -50,6 +50,17 @@ spec:
                   Deprecated: Use 'baseLedgerEndpoint' instead. Example:
                   { "baseLedgerEndpoint": {"type": "network", "network": {"auth": {}}} }
                 properties:
+                  inline:
+                    description: Auth details are provided inline (not recommended)
+                    properties:
+                      password:
+                        type: string
+                      username:
+                        type: string
+                    required:
+                    - password
+                    - username
+                    type: object
                   secretRef:
                     description: Secret is used to provide the name of the secret
                       to use for authentication
@@ -64,6 +75,7 @@ spec:
                     description: auth method to use for the connection
                     enum:
                     - secret
+                    - inline
                     type: string
                 required:
                 - type
@@ -78,6 +90,17 @@ spec:
                     properties:
                       auth:
                         properties:
+                          inline:
+                            description: Auth details are provided inline (not recommended)
+                            properties:
+                              password:
+                                type: string
+                              username:
+                                type: string
+                            required:
+                            - password
+                            - username
+                            type: object
                           secretRef:
                             description: Secret is used to provide the name of the
                               secret to use for authentication
@@ -92,6 +115,7 @@ spec:
                             description: auth method to use for the connection
                             enum:
                             - secret
+                            - inline
                             type: string
                         required:
                         - type

operator/internal/controller/paladin_controller.go

@@ -808,6 +808,15 @@ func (r *PaladinReconciler) generatePaladinAuthConfig(ctx context.Context, node
 		if err := mapToStruct(sec.Data, &pldConf.Blockchain.WS.Auth); err != nil {
 			return err
 		}
+
+	case corev1alpha1.AuthTypeInline:
+		if authConfig.Inline == nil {
+			return fmt.Errorf("AuthInline must be provided when using AuthTypeInline")
+		}
+		pldConf.Blockchain.HTTP.Auth.Username = authConfig.Inline.Username
+		pldConf.Blockchain.HTTP.Auth.Password = authConfig.Inline.Password
+		pldConf.Blockchain.WS.Auth.Username = authConfig.Inline.Username
+		pldConf.Blockchain.WS.Auth.Password = authConfig.Inline.Password
 	}
 	return nil
 }

sdk/typescript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lfdecentralizedtrust-labs/paladin-sdk",
-  "version": "0.0.4-alpha.1",
+  "version": "0.0.6-alpha.1",
   "description": "",
   "main": "build/index.js",
   "scripts": {

sdk/typescript/src/interfaces/transaction.ts

@@ -60,14 +60,26 @@ export interface ITransactionReceipt {
   transactionHash: string;
   source: string;
   contractAddress?: string;
-  domainReceipt?: {
-    receipt: {
-      contractAddress?: string;
-    };
-  };
+  states?: ITransactionStates;
+  domainReceipt?: IPenteDomainReceipt;
   failureMessage?: string;
 }
 
+export interface IPenteDomainReceipt {
+  receipt: {
+    from?: string;
+    to?: string;
+    contractAddress?: string;
+    logs?: IPenteLog[];
+  };
+}
+
+export interface IPenteLog {
+  address: string;
+  topics: string[];
+  data: string;
+}
+
 export interface ITransactionStates {
   none?: boolean;
   spent?: IStateBase[];
@@ -125,3 +137,10 @@ export enum TransactionType {
   Private = "private",
   Public = "public",
 }
+
+export interface IDecodedEvent {
+  signature: string;
+  definition: ethers.JsonFragment;
+  data: any;
+  summary: string; // errors only
+}

sdk/typescript/src/paladin.ts

@@ -13,8 +13,10 @@ import {
   IPreparedTransaction,
   ITransactionReceipt,
   ITransactionStates,
+  IDecodedEvent,
 } from "./interfaces/transaction";
 import { Algorithms, Verifiers } from "./interfaces";
+import { ethers } from "ethers";
 
 const POLL_INTERVAL_MS = 100;
 
@@ -189,4 +191,24 @@ export default class PaladinClient {
     ]);
     return res.data.result;
   }
+
+  async storeABI(abi: ethers.InterfaceAbi) {
+    await this.post("ptx_storeABI", [abi]);
+  }
+
+  async decodeEvent(topics: string[], data: string) {
+    try {
+      const res = await this.post<JsonRpcResult<IDecodedEvent>>(
+        "ptx_decodeEvent",
+        [topics, data, ""]
+      );
+      return res.data.result;
+    } catch (err) {
+      const parsed = this.parseAxiosErrorMessage(err);
+      if (typeof parsed === "string" && parsed.indexOf("PD012229") >= 0) {
+        return undefined;
+      }
+      throw err;
+    }
+  }
 }

toolkit/java/src/main/java/io/kaleido/paladin/toolkit/JsonABI.java

@@ -193,6 +193,9 @@ public JsonABI.Entry getABIEntry(String entryType, String entryName) {
                 }
             }
         }
+        if (entryType.equals("constructor")) {
+            return JsonABI.newConstructor(null);
+        }
         throw new IllegalArgumentException("%s %s not found in ABI".formatted(entryType, entryName));
     }