Paladin

https://lf-decentralized-trust-labs.github.io/paladin/head
Admin
Paladin provides programmable privacy for the Ethereum Virtual Machine (EVM), offering enterprises...
Tokens:74,176
Snippets:387
Trust Score:8.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install Paladin in Devnet Mode

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-advanced

Deploys a default Paladin network in devnet mode, suitable for quick starts and demonstrations. This command installs the Paladin operator and creates the necessary namespace.

```bash
helm install paladin paladin/paladin-operator -n paladin --create-namespace

```

--------------------------------

### Paladin Customnet Configuration Example

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-advanced

An example values.yaml file for Paladin in customnet mode, demonstrating detailed configuration for nodes, domains, registries, transports, services, databases, and signers. This configuration allows for granular control over each component of the Paladin network.

```yaml
mode: customnet
paladinNodes:
  - name: central-bank
    baseLedgerEndpoint:
      type: endpoint       # or "local" for built-in Besu
      endpoint:
        jsonrpc: https://mychain.rpc
        ws:    wss://mychain.ws
        auth:
          enabled: false    # set true + secretName if basic auth
          secretName: creds
    domains:
      - noto
      - zeto
      - pente
    registries:
      - evm-registry
    transports:
      - name: grpc
        plugin:
          type: c-shared
          library: /app/transports/libgrpc.so
        config:
          port: 9000
          address: 0.0.0.0
        ports:
          transportGrpc:
            port: 9000
            targetPort: 9000
    service:
      type: NodePort    # change service type if needed
      ports:
        rpcHttp:
          port: 8548
          nodePort: 31748   # Do not set nodePort in case the service.type is not NodePort
        rpcWs:
          port: 8549
          nodePort: 31749   # Do not set nodePort in case the service.type is not NodePort
    database:
      mode: sidecarPostgres
      migrationMode: auto
      # pvcTemplate:         # Optional - Set a custom PVC for the DB
      #   storageClassName: "my-storage"
      #   accessModes:
      #   - ReadWriteOnce
      #   capacity:
      #     storage: 10Gi
    secretBackedSigners:
      - name: signer-auto-wallet
        secret: central-bank.keys
        type: autoHDWallet  # or preConfigured. in case of preConfigured you must create the secret with the seed
        keySelector: ".*"
    paladinRegistration:
      registryAdminNode: central-bank  # The admin node that manages the registry
      registryAdminKey: registry.operator
      registry: evm-registry
    config: |
      log:
        level: debug  # Log levels: debug, info, warn, error
      publicTxManager:
        gasLimit:
          gasEstimateFactor: 2.0


```

--------------------------------

### Example values-attach.yaml for Paladin Deployment

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-advanced

A comprehensive example of a values file for deploying Paladin in 'attach' mode. It includes configurations for smart contract references, node endpoints, domains, registries, transports, services, databases, and signer configurations.

```yaml
mode: attach
smartContractsReferences:
  notoFactory:
    address: "0xd93630936d854fb718b89537cce4acc97fd50463"
  zetoFactory:
    address: "0xc29ed8a902ff787445bdabee9ae5e2380089959d"
  penteFactory:
    address: "0x48c11bbb7caa77329d53b89235fec64733a24ca1"
  registry:
    address: "0x4456307ef3f119dac17a5e974d2640f714e6edb0"

paladinNodes:
paladinNodes:
- name: bank-a
  baseLedgerEndpoint:
    type: endpoint
    endpoint:
      jsonrpc: https://mychain.rpc
      ws:    wss://mychain.ws
      auth:
        enabled: false    # set true + secretName if basic auth
        secretName: creds
  domains:
    - noto
    - zeto
    - pente
  registries:
    - evm-registry
  transports:
    - name: grpc
      plugin:
        type: c-shared
        library: /app/transports/libgrpc.so
      config:
        port: 9000
        address: 0.0.0.0
      ports:
        transportGrpc:
          port: 9000
          targetPort: 9000
  service:
    type: NodePort    # change service type if needed
    ports:
      rpcHttp:
        port: 8548
        nodePort: 31748  # Do not set nodePort in case the service.type is not NodePort
      rpcWs:
        port: 8549
        nodePort: 31749  # Do not set nodePort in case the service.type is not NodePort
  database:
    mode: sidecarPostgres
    migrationMode: auto
  secretBackedSigners:
    - name: signer-auto-wallet
      secret: central-bank.keys
      type: autoHDWallet  # or preConfigured. in case of preConfigured you must create the secret with the seed
      keySelector: ".*"
  config: |
    log:
      level: debug
    publicTxManager:
      gasLimit:
        gasEstimateFactor: 2.0
  paladinRegistration:
    registryAdminNode: central-bank
    registryAdminKey:  registry.operator
    registry:         evm-registry


```

--------------------------------

### Customized Devnet Installation with Helm

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-advanced

Performs a custom installation of Paladin in devnet mode using Helm, allowing configuration of node count and name prefixes. This enables finer control over the initial network setup.

```bash
helm install paladin paladin/paladin-operator -n paladin --create-namespace \
  --set nodeCount=5 \
  --set paladin.nodeNamePrefix=worker \
  --set besu.nodeNamePrefix=evm

```

--------------------------------

### Verify Running Pods with Kubectl

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation

This command set configures the kubectl context to the 'paladin' namespace and then lists all running pods within that namespace. It's used to confirm that all Besu and Paladin nodes, as well as the operator, have started successfully.

```bash
kubectl config set-context --current --namespace paladin
kubectl get pods
```

--------------------------------

### Download and Extract Artifacts

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-manual

Downloads the latest release artifacts for Paladin and extracts them. This step retrieves necessary files for deploying smart contracts.

```bash
wget https://github.com/LF-Decentralized-Trust-labs/paladin/releases/download/latest/artifacts.tar.gz
tar -xzvf artifacts.tar.gz
```

--------------------------------

### Install Paladin Operator

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-manual

Installs the Paladin operator in `operator-only` mode, which deploys the operator without additional resources. This command sets up the core operator component.

```bash
helm upgrade --install paladin paladin/paladin-operator -n paladin --create-namespace --set mode=operator-only
```

--------------------------------

### Create and Configure kind Kubernetes Cluster

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation

This snippet demonstrates how to download a Paladin-specific configuration file for kind and then create a new Kubernetes cluster named 'paladin' using this configuration. It's useful for quickly setting up a local development environment. Ensure 'curl' and 'kind' are installed.

```bash
curl https://raw.githubusercontent.com/LF-Decentralized-Trust-labs/paladin/refs/heads/main/operator/paladin-kind.yaml -L -O
kind create cluster --name paladin --config paladin-kind.yaml
```

--------------------------------

### Customnet Mode Installation with Helm

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-advanced

Installs Paladin in customnet mode using a specified values file, providing maximum flexibility for advanced configurations. This mode is ideal for integrating with external blockchain nodes.

```bash
helm install paladin paladin/paladin-operator -n paladin --create-namespace \
  -f values-customnet.yaml

```

--------------------------------

### Apply Kubernetes Custom Resources for Paladin

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-manual

Applies various Kubernetes Custom Resources (CRs) to the Paladin namespace. These CRs define the configuration for smart contracts and other Paladin network components.

```bash
kubectl -n paladin apply -f cert_issuer_selfsigned.yaml
kubectl -n paladin apply -f core_v1alpha1_paladinregistry.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_noto_factory.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_pente_factory.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_registry.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_factory.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_g16_anon_batch.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_g16_anon_enc_batch.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_g16_anon_enc.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_g16_anon_nullifier_transfer_batch.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_g16_anon_nullifier_transfer.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_g16_anon.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_g16_deposit.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_g16_withdraw_batch.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_g16_withdraw_nullifier_batch.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_g16_withdraw_nullifier.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_g16_withdraw.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_impl_anon_enc.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_impl_anon_nullifier.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_impl_anon.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_poseidon_unit2l.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_poseidon_unit3l.yaml
kubectl -n paladin apply -f core_v1alpha1_smartcontractdeployment_zeto_smt_lib.yaml
kubectl -n paladin apply -f core_v1alpha1_transactioninvoke_zeto_register_anon_enc.yaml
kubectl -n paladin apply -f core_v1alpha1_transactioninvoke_zeto_register_anon_nullifier.yaml
kubectl -n paladin apply -f core_v1alpha1_transactioninvoke_zeto_register_anon.yaml
```

--------------------------------

### Deploy 'pente' Domain - PaladinDomain CR

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-manual

This YAML defines a PaladinDomain Custom Resource (CR) for the 'pente' domain. It specifies a JAR-based plugin and indicates that the 'pente-factory' should be used for smart contract deployment. This configuration is for initial deployment.

```yaml
apiVersion: core.paladin.io/v1alpha1
kind: PaladinDomain
metadata:
  labels:
    paladin.io/domain-name: pente
  name: pente
  namespace: paladin
spec:
  plugin:
    class: io.kaleido.paladin.pente.domain.PenteDomainFactory
    library: /app/domains/pente.jar
    type: jar
  smartContractDeployment: pente-factory

```

--------------------------------

### Install Paladin CRD Helm Chart

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation

This command adds the Paladin Helm repository and then upgrades or installs the 'paladin-operator-crd' chart, which contains the necessary Custom Resource Definitions for the Paladin operator. This is the first step in installing the Paladin operator. Requires Helm v3 installed.

```bash
helm repo add paladin https://LF-Decentralized-Trust-labs.github.io/paladin --force-update
helm upgrade --install paladin-crds paladin/paladin-operator-crd
```

--------------------------------

### Install Paladin Operator Helm Chart

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation

This command upgrades or installs the 'paladin-operator' chart into a new namespace named 'paladin'. This is the final step in the Paladin operator installation process after the CRDs and cert-manager have been set up. Requires Helm v3 installed.

```bash
helm upgrade --install paladin paladin/paladin-operator -n paladin --create-namespace
```

--------------------------------

### Receipt Listener Configuration Example (JSON)

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/reference/types/transactionreceiptlistener

An example JSON object illustrating the structure for configuring a receipt listener, including name, creation timestamp, start status, filters, and options.

```json
{
    "name": "",
    "created": 0,
    "started": null,
    "filters": {},
    "options": {
        "domainReceipts": false
    }
}

```

--------------------------------

### Retrieve Existing Smart Contract Addresses

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-advanced

Kubernetes command to fetch the addresses of deployed Paladin domains and registries. This information is crucial for configuring Paladin to attach to an existing network.

```bash
kubectl -n paladin get paladindomains,paladinregistries

```

--------------------------------

### Install Paladin Operator using Helm

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-advanced

Helm command to install the Paladin operator in a specified namespace. This command requires a custom values file (e.g., values-attach.yaml) to configure the deployment.

```bash
helm install paladin paladin/paladin-operator -n paladin --create-namespace \
  -f values-attach.yaml

```

--------------------------------

### Install cert-manager CRDs Helm Chart

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation

This command adds the Jetstack Helm repository and then installs the 'cert-manager' chart from that repository into the 'cert-manager' namespace, ensuring CRDs are enabled. This is a prerequisite for installing the Paladin operator, as it manages certificates. Requires Helm v3 installed.

```bash
helm repo add jetstack https://charts.jetstack.io --force-update
helm install cert-manager --namespace cert-manager --version v1.16.1 jetstack/cert-manager --create-namespace --set crds.enabled=true
```

--------------------------------

### Deploy Paladin Node Configuration (YAML)

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-manual

This YAML configuration defines a Paladin node, including its API version, kind, metadata, and specifications for connecting to a ledger endpoint, configuring logging, database settings, domain and registry selections, signer configurations, and service ports for network exposure. It is essential for deploying and managing Paladin nodes within a network.

```yaml
apiVersion: core.paladin.io/v1alpha1
kind: Paladin
metadata:
  name: node1
  namespace: paladin
spec:
  baseLedgerEndpoint:
    type: endpoint
    endpoint:
      jsonrpc: https://chain-json-rpc-endpoint
      ws: wss://chain-json-ws-endpoint
      auth:
        type: secret
        secret:
          name: node1-auth
  config: |
    log:
      level: debug
  database:
    migrationMode: auto
    mode: sidecarPostgres
  domains:
  - labelSelector:
      matchLabels:
        paladin.io/domain-name: noto
  - labelSelector:
      matchLabels:
        paladin.io/domain-name: zeto
  - labelSelector:
      matchLabels:
        paladin.io/domain-name: pente
  registries:
  - labelSelector:
      matchLabels:
        paladin.io/registry-name: evm-registry
  secretBackedSigners:
  - keySelector: .*
    name: signer-1
    secret: node1.keys
    type: autoHDWallet
  service:
    ports:
    - name: rpc-http
      nodePort: 31548
      port: 8548
      protocol: TCP
    - name: rpc-ws
      nodePort: 31549
      port: 8549
      protocol: TCP
    type: NodePort
  transports:
  - configJSON: |
      {
        "port": 9000,
        "address": "0.0.0.0"
      }
    name: grpc
    plugin:
      library: /app/transports/libgrpc.so
      type: c-shared
    ports:
    - name: transport-grpc
      port: 9000
      protocol: TCP
      targetPort: 9000
    tls:
      certName: paladin-node1-mtls
      issuer: selfsigned-issuer
      secretName: paladin-node1-mtls

```

--------------------------------

### PrivacyGroupMessageListener Example

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/reference/types/privacygroupmessagelistener

This example demonstrates the expected JSON structure for creating a PrivacyGroupMessageListener. It includes fields for naming, creation timestamp, start status, filters, and options. The 'started' field can be set to false to disable server-side delivery.

```json
{
    "name": "",
    "created": 0,
    "started": null,
    "filters": {},
    "options": {}
}
```

--------------------------------

### Deploy 'zeto' Domain - PaladinDomain CR with Config

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-manual

This YAML defines a PaladinDomain Custom Resource (CR) for the 'zeto' domain, including detailed configuration for domain contracts and snark prover settings. It uses a C-shared library plugin and specifies 'zeto-factory' for smart contract deployment. The 'configJSON' field outlines various circuit implementations for anonymity and nullifier usage.

```yaml
apiVersion: core.paladin.io/v1alpha1
kind: PaladinDomain
metadata:
  labels:
    paladin.io/domain-name: zeto
  name: zeto
  namespace: paladin
spec:
  allowSigning: true
  configJSON: |
    {
      "domainContracts": {
        "implementations": [
          {
            "name": "Zeto_Anon",
            "circuits": {
              "deposit": {
                "name": "deposit"
              },
              "withdraw": {
                "name": "withdraw"
              },
              "transfer": {
                "name": "anon"
              },
              "transferLocked": {
                "name": "anon"
              }
            }
          },
          {
            "name": "Zeto_AnonEnc",
            "circuits": {
              "deposit": {
                "name": "deposit"
              },
              "withdraw": {
                "name": "withdraw"
              },
              "transfer": {
                "name": "anon_enc",
                "usesEncryption": true
              },
              "transferLocked": {
                "name": "anon_enc",
                "usesEncryption": true
              }
            }
          },
          {
            "name": "Zeto_AnonNullifier",
            "circuits": {
              "deposit": {
                "name": "deposit"
              },
              "withdraw": {
                "name": "withdraw_nullifier",
                "usesNullifiers": true
              },
              "transfer": {
                "name": "anon_nullifier_transfer",
                "usesNullifiers": true
              },
              "transferLocked": {
                "name": "anon_nullifier_transferLocked",
                "usesNullifiers": true
              }
            }
          }
        ]
      },
      "snarkProver": {
        "circuitsDir": "/app/domains/zeto/zkp",
        "provingKeysDir": "/app/domains/zeto/zkp"
      }
    }
  plugin:
    library: /app/domains/libzeto.so
    type: c-shared
  smartContractDeployment: zeto-factory

```

--------------------------------

### Check Service Details with Kubectl

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation

This command retrieves and displays the details of all services running within the current Kubernetes namespace. It's useful for identifying the cluster IP, type, and port mappings for Besu and Paladin services, which are crucial for network communication.

```bash
kubectl get service
```

--------------------------------

### Start Transaction Receipt Listener (API)

Source: https://context7.com/context7/lf-decentralized-trust-labs_github_io_paladin_head/llms.txt

Starts a previously created transaction receipt listener. Requires the name of the listener to be started.

```bash
curl -X POST http://localhost:31548/api/v1/ptx_startReceiptListener \
  -H "Content-Type: application/json" \
  -d '{
    "listenerName": "my-transactions"
  }'
```

--------------------------------

### Deploy 'noto' Domain - PaladinDomain CR

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-manual

This YAML defines a PaladinDomain Custom Resource (CR) for the 'noto' domain. It specifies the plugin library and type, and indicates that the smart contract for this domain should be deployed. Similar to the registry, 'contractAddress' can be used for subsequent cluster references.

```yaml
apiVersion: core.paladin.io/v1alpha1
kind: PaladinDomain
metadata:
  name: noto
  namespace: paladin
  labels:
    paladin.io/domain-name: noto
spec:
  plugin:
    library: /app/domains/libnoto.so
    type: c-shared
  smartContractDeployment: noto-factory  # use 'contractAddress' for existing deployments
  # contractAddress: "0x...."

```

--------------------------------

### Example KeyMappingAndVerifier JSON Configuration

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/reference/types/keymappingandverifier

This snippet shows an example JSON object representing a KeyMappingAndVerifier configuration. It demonstrates the structure and potential null values for certain fields, such as 'verifier'.

```json
{
    "verifier": null
}
```

--------------------------------

### Configure GRPC Transport Plugin

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-manual

This YAML configuration defines the settings for the GRPC transport plugin. It specifies the port, address, and TLS certificate details. The `configJSON` field contains specific GRPC transport configurations like port and external hostname.

```yaml
transports:
- configJSON: |
    {
      "port": 9000,
      "address": "0.0.0.0",
      "externalHostname": ...
    }
  name: grpc
  plugin:
    library: /app/transports/libgrpc.so
    type: c-shared
  ports:
  - name: transport-grpc
    port: 9000
    protocol: TCP
    targetPort: 9000
  tls:
    certName: paladin-node1-mtls
    issuer: selfsigned-issuer
    secretName: paladin-node1-mtls

```

--------------------------------

### Configure Pre-Configured Secret-Backed Signers

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-advanced

This configuration uses pre-configured seed phrases stored in Kubernetes secrets. It references an existing secret that contains the seed phrase, allowing Paladin to use it for signing operations.

```yaml
secretBackedSigners:
- keySelector: .*
  name: signer-1
  secret: central-bank.keys

```

--------------------------------

### PreparedTransaction Example (JSON)

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/reference/types/preparedtransaction

This snippet shows an example of a PreparedTransaction in JSON format. It includes an empty 'states' object, which will be populated with transaction-specific state details.

```json
{
    "states": {}
}
```

--------------------------------

### Check Smart Contract Deployment Status with Kubectl

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation

This command queries the status of Smart Contract Deployments (SCD) within the Kubernetes cluster. It provides information such as the deployment status, dependencies, transaction IDs, contract addresses, and transaction hashes, allowing for verification of successful smart contract deployment.

```bash
kubectl get scd
```

--------------------------------

### Create Kubernetes Secret for Seed Phrase

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-advanced

Command to create a Kubernetes secret containing a seed phrase for use with Paladin's signing mechanisms. The secret can be created from a file or directly from a string.

```bash
kubectl create secret generic <secret name> --from-file=keys.yaml=<file name>

```

--------------------------------

### BlockchainEventListener Example Configuration (JSON)

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/reference/types/blockchaineventlistener

An example JSON object representing a BlockchainEventListener configuration. This structure defines the essential parameters for setting up a listener, including its name, creation timestamp, operational status, event sources, and associated options.

```json
{
    "name": "",
    "created": 0,
    "started": null,
    "sources": null,
    "options": {}
}
```

--------------------------------

### Create EVM Registry - PaladinRegistry CR

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-manual

This YAML defines a PaladinRegistry Custom Resource (CR) for an EVM-compatible registry. It specifies the registry's type as 'evm' and indicates that a smart contract should be deployed for it. The 'paladin.io/registry-name' label is crucial for Paladin nodes to reference this registry.

```yaml
apiVersion: core.paladin.io/v1alpha1
kind: PaladinRegistry
metadata:
  name: evm-registry
  namespace: paladin
  labels:
    paladin.io/registry-name: evm-registry
spec:
  type: evm
  evm:
    smartContractDeployment: registry  # use 'contractAddress' if referencing existing deployment
    # contractAddress: "0x...."
  plugin:
    library: /app/registries/libevm.so
    type: c-shared

```

--------------------------------

### Install Cert-Manager with Helm (Installation)

Source: https://context7.com/context7/lf-decentralized-trust-labs_github_io_paladin_head/llms.txt

Installs cert-manager, a certificate management controller for Kubernetes, using Helm. It is a dependency for Paladin operator and requires specific namespace and version settings.

```bash
helm repo add jetstack https://charts.jetstack.io --force-update
helm install cert-manager --namespace cert-manager --version v1.16.1 \
  jetstack/cert-manager --create-namespace --set crds.enabled=true
```

--------------------------------

### Check Docker and Kind Versions

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/troubleshooting

These commands verify the installed versions of Docker and Kind, which are essential for running the Paladin cluster. Outdated versions can lead to networking issues and affect UI accessibility. The output directly shows the version number for each tool.

```bash
docker --version
kind --version
```

--------------------------------

### Debugging Paladin Transactions with ptx_getTransactionFull RPC

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/guides/administering_peers

This example demonstrates how to use a curl command to make an RPC call to the `ptx_getTransactionFull` method. This is used to get detailed information about a specific transaction (identified by its Transaction ID) to help debug failures.

```bash
curl http://localhost:31548 --header 'Content-Type: application/json' \
--data '{
    "jsonrpc": "2.0",
    "id": "1",
    "method": "ptx_getTransactionFull",
    "params": ["83278a5f-5f89-412c-b8a4-9757bdb1f382"]
}'
```

--------------------------------

### TransactionFull Example JSON

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/reference/types/transactionfull

An example JSON structure for a TransactionFull object, illustrating the expected fields and their null values for receipt and public data.

```json
{
    "receipt": null,
    "public": null
}
```

--------------------------------

### Configure Secret-Backed Signers for HD Wallets

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-advanced

This configuration enables the use of automatically generated HD wallet seed phrases stored in Kubernetes secrets. It specifies the name of the secret where the seed phrase will be stored and a key selector to match specific keys.

```yaml
secretBackedSigners:
- keySelector: .*
  name: signer-1
  secret: central-bank.keys
  type: autoHDWallet

```

--------------------------------

### ptx_startReceiptListener

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/reference/apis/ptx

Starts a previously created transaction receipt listener.

```APIDOC
## ptx_startReceiptListener

### Description
Starts a previously created transaction receipt listener.

### Method
POST (assumed)

### Endpoint
/ptx/startReceiptListener (assumed)

### Parameters
#### Query Parameters
- **listenerName** (string) - Required - The name of the listener to start.

### Response
#### Success Response (200)
- **success** (bool) - True if the listener started successfully, false otherwise.
```

--------------------------------

### Example State JSON Object

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/reference/types/state

This JSON object represents an example of the 'State' structure. It includes fields like id, created, domain, schema, contractAddress, and data, along with their expected types and purposes.

```json
{
    "id": "0x",
    "created": 0,
    "domain": "",
    "schema": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "contractAddress": null,
    "data": null
}
```

--------------------------------

### Filter Paladin Logs by Component (Kubectl)

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/guides/logging

Demonstrates how to filter logs from Paladin pods in a Kubernetes environment based on the 'component' field. This allows for targeted analysis of specific system parts. It includes examples for filtering a single component, multiple components using regex, and excluding specific components.

```bash
# Filter logs for a specific component
kubectl logs -l app=paladin | grep "component=txmanager"

# Filter logs for multiple components
kubectl logs -l app=paladin | grep -E "component=(txmanager|statemanager)"

# Filter logs excluding certain components
kubectl logs -l app=paladin | grep -v "component=retry"

```

--------------------------------

### Real-time Paladin Log Monitoring (Kubectl)

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/guides/logging

Provides commands for real-time monitoring of Paladin logs in Kubernetes, including filtering by component or log level. The `-f` flag enables following the logs as they are generated, which is essential for live debugging and operational oversight.

```bash
# Follow logs for transaction manager in real-time
kubectl logs -f -l app=paladin -l app.kubernetes.io/instance=node1 | grep "component=txmanager"

# Follow error logs from all components
kubectl logs -f -l app=paladin -l app.kubernetes.io/instance=node1 | grep "ERROR"

# Follow logs for multiple components
kubectl logs -f -l app=paladin -l app.kubernetes.io/instance=node1 | grep -E "component=(txmanager|statemanager|domainmanager)"

```

--------------------------------

### Configure Paladin Node Authentication Secret (YAML)

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-manual

This YAML defines a Kubernetes Secret resource used for authenticating a Paladin node to a blockchain node. It specifies the secret's name, namespace, data fields for username and password, and its type as Opaque. This is crucial for securing the connection between Paladin and the underlying ledger.

```yaml
apiVersion: v1
kind: Secret
metadata:
  name: node1-auth
  namespace: paladin
data:
  password: ...
  username: ...
type: Opaque

```

--------------------------------

### ptx_startBlockchainEventListener

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/reference/apis/ptx

Starts a previously created blockchain event listener.

```APIDOC
## ptx_startBlockchainEventListener

### Description
Starts a previously created blockchain event listener.

### Method
POST (assumed)

### Endpoint
/ptx/startBlockchainEventListener (assumed)

### Parameters
#### Query Parameters
- **listenerName** (string) - Required - The name of the listener to start.

### Response
#### Success Response (200)
- **success** (bool) - True if the listener started successfully, false otherwise.
```

--------------------------------

### PrivacyGroupEVMTXInput Example (JSON)

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/reference/types/privacygroupevmtxinput

This example demonstrates the basic structure of the PrivacyGroupEVMTXInput object, specifically the publicTxOptions field, for submitting transactions to EVM privacy groups. It shows an empty publicTxOptions object.

```json
{
    "publicTxOptions": {}
}
```

--------------------------------

### Schema JSON Example

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/reference/types/schema

This JSON object represents an example schema. It includes fields for ID, creation timestamp, domain, type, signature, definition, and labels. The 'definition' field can hold complex structures like ABI definitions, and 'labels' is an array of strings for filtering.

```json
{
    "id": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "created": 0,
    "domain": "",
    "type": "",
    "signature": "",
    "definition": null,
    "labels": null
}
```

--------------------------------

### EventWithData JSON Example

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/reference/types/eventwithdata

This is a JSON representation of the EventWithData structure. It shows the expected format for event data, including placeholders for Solidity signature, address, and event data.

```json
{
    "soliditySignature": "",
    "address": "0x0000000000000000000000000000000000000000",
    "data": null
}
```

--------------------------------

### Example Registry Transport Properties (JSON)

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/guides/administering_peers

This JSON object displays an example of transport properties for a node within the Paladin registry. It includes the owner's address and the gRPC transport configuration, which specifies the endpoint and certificate issuers. This data is crucial for understanding node connectivity and security settings.

```json
{
   "$owner": "0xbd788c85660d249f23e084ee25cf82dd63861965",
   "transport.grpc": "{\"endpoint\":\"dns:///paladin-node3.default.svc.cluster.local:9000\",\"issuers\":\"-----BEGIN CERTIFICATE-----\nMIIC/jCCAeagAwIBAgIQTFQ97yE+BI1FVWT53PlyHDANBgkqhkiG9w0BAQsFADAQ\nMQ4wDAYDVQQDEwVub2RlMzAeFw0yNTA5MDkxNTExMThaFw0yNTEyMDgxNTExMTha\nMBAxDjAMBgNVBAMTBW5vZGUzMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC\nAQEAwhcU9dX0jAqIymu23QwIwBkQsh/Tj9AOUNIlVlAL7+Wrx/7bKoeUCW9kU4hn\nGJSC23NGAtPWckXAVlTyWzz+Ssn8UCEUO/9drwhJPjXHjKmnwSI2is0koSG0Rm9e\nFBfpi56KqbByXgDaiTzJDeANr67hKnB5ve6KlolTFheQdwiJ/rKI7TOlX8VgKHlj\nPpIVxdpbmkwtOHJMl039RG6hWuCaf3r5AOreNKU2XxdFK51Zn0Md4KdcMs9HYOKj\n0LSz8pw4rM8YJsb5RRcAtLljf0QRzjIrPF+70iWvZY0cvQiKbRr/J6fYN3Door+I\nVJW8DD4h0jA3EOOk9deFO7WKTQIDAQABo1QwUjAOBgNVHQ8BAf8EBAMCBaAwDAYD\nVR0TAQH/BAIwADAyBgNVHREEKzApgidwYWxhZGluLW5vZGUzLmRlZmF1bHQuc3Zj\nLmNsdXN0ZXIubG9jYWwwDQYJKoZIhvcNAQELBQADggEBAHKHxoLYfd0VrzD0NXL9\nJnnPHxF9S5u6uhMtJtFXtgOixQbTzM4eNL6Z+HtpJRbEZpUGeFvb85gmPryY2OvB\nzlNZWPnkpfmrQnmFZOlmcjWh/slK8mp7DUjQMeYL42YevLmv2sn+eEbKNO7Z3rDw\nX8IdOCJju5+HUeGnDobkgCWT8fx9xu6+RLIOhpsUQocoDSSTDP1b3kOjs8vQbF/T\nCs1g3tP7tE4ARZOlSJXqacCkeStpXftpkI2vAm2bDf3dTNsHxjxRHU1GnEQQFyMW\nXjvxzuL5J8ArAUVyfyhYjaC0AFMkbaedXI+MsCOmROGYdfYQWZyNbB7HNSJJny4D\n7gI=\n-----END CERTIFICATE-----\n"}
```

--------------------------------

### JSON Serialization - Default Example

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/reference/types/jsonformatoptions

Illustrates the JSON output for a given ABI structure using the default formatting options. The output shows numbers as decimal strings, bytes and addresses in hex format, and the overall structure as JSON objects.

```json
{
    "date": "1729450200",
    "stock": [
        {
            "count": "100",
            "description": "widgetA",
            "valueDiff": "-123456789012345678901234567890",
            "item": "0xbb36636e2b58f2ca2538a966b95a253ed78c6bd1d176255be5a58c7ced3c21ea",
            "supplier": "0xb8f7764d413b518c49824fb5e6078b41b2549d4e"
        }
    ]
}
```

--------------------------------

### Deploy HelloWorld Smart Contract with Paladin SDK

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/tutorials/hello-world

Deploys the HelloWorld smart contract using the Paladin SDK's sendTransaction method. It requires the contract's ABI and bytecode, and specifies the public transaction type and sender address.

```javascript
const deploymentTxID = await paladin.ptx.sendTransaction({
  type: TransactionType.PUBLIC,
  abi: helloWorldJson.abi,
  bytecode: helloWorldJson.bytecode,
  from: owner.lookup,
  data: {},
});
```

--------------------------------

### Clone Paladin Repository with Latest Release Tag

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/tutorials/hello-world

This command clones the Paladin repository, ensuring you use the most recent stable release tag instead of the main branch. It fetches the latest tag, which is not a release candidate, and uses it for cloning.

```bash
REPO=https://github.com/LF-Decentralized-Trust-labs/paladin.git
TAG=$(git ls-remote --tags $REPO | cut -d/ -f3 | grep -v \'-rc\' | sort -V | tail -n1)
git clone $REPO -b $TAG
```

--------------------------------

### Delete kind Kubernetes Cluster

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation

This command is used to delete a previously created 'kind' Kubernetes cluster named 'paladin'. It's a cleanup step to remove the local development environment when no longer needed. Ensure 'kind' is installed.

```bash
kind delete cluster --name paladin
```

--------------------------------

### Kubernetes Secret for Authentication

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-advanced

Defines a Kubernetes Secret resource to store authentication credentials (username and password) for securing a blockchain node connection. This secret can be referenced in the Paladin node configuration.

```yaml
apiVersion: v1
kind: Secret
metadata:
  name: central-bank-auth
  namespace: paladin
data:
  password: ...
  username: ...
type: Opaque

```

--------------------------------

### Confirm Smart Contract Deployment with Paladin SDK

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/tutorials/hello-world

Polls for the confirmation of a smart contract deployment transaction using Paladin SDK's pollForReceipt. It waits for the transaction to be confirmed and checks for the presence of a contractAddress in the receipt.

```javascript
const deploymentReceipt = await paladin.pollForReceipt(
  deploymentTxID,
  10000,
  true
);
if (!deploymentReceipt?.contractAddress) {
  logger.error("Deployment failed!");
  return false;
}
logger.log(
  "Contract deployed successfully at address:",
  deploymentReceipt.contractAddress
);
```

--------------------------------

### Clone Paladin Repository with Latest Release Tag

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/tutorials

This script clones the Paladin GitHub repository, automatically identifying and checking out the most recent stable release tag. It ensures you are working with the latest version to avoid compatibility issues.

```shell
REPO=https://github.com/LF-Decentralized-Trust-labs/paladin.git
TAG=$(git ls-remote --tags $REPO | cut -d/ -f3 | grep -v '\-rc' | sort -V | tail -n1)
git clone $REPO -b $TAG

```

--------------------------------

### Call sayHello Function on Deployed Contract with Paladin SDK

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/tutorials/hello-world

Calls the sayHello function on the deployed HelloWorld contract using the Paladin SDK's sendTransaction. It specifies the contract address, function name, sender, and data including the name argument.

```javascript
const name = "Paladin User"; // Example name for the greeting

const sayHelloTxID = await paladin.ptx.sendTransaction({
  type: TransactionType.PUBLIC,
  abi: helloWorldJson.abi,
  function: "sayHello",
  from: owner.lookup,
  to: deploymentReceipt.contractAddress,
  data: { name: name },
});
```

--------------------------------

### Override Block Indexer fromBlock Configuration (YAML)

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/guides/administering_peers

This YAML snippet shows how to override the default `fromBlock` setting for the block indexer in a Paladin installation. This is typically done in a `customnet` configuration to specify a custom starting block for indexing, which can be 'latest' or a specific block number.

```yaml
paladinNodes:
  - name: node1
    config: |
      blockIndexer:
        fromBlock: 17543 # can also be latest
```

--------------------------------

### Register Paladin Node with Kubernetes CR

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/getting-started/installation-manual

This Kubernetes Custom Resource (CR) definition for `PaladinRegistration` registers a Paladin node. It includes details such as the node name, administrative keys for registry and node operations, and the transports to be used. This CR is essential for integrating nodes into the Paladin network.

```yaml
apiVersion: core.paladin.io/v1alpha1
kind: PaladinRegistration
metadata:
  name: node1
spec:
  node: node1 # <node name>
  nodeAdminKey: registry.node1 # registry.<node name>
  registry: evm-registry
  registryAdminKey: registry.operator
  registryAdminNode: node1 # <admin node name>
  transports:
  - grpc

```

--------------------------------

### Filter Paladin Logs by Level (Kubectl)

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/guides/logging

Shows how to filter Paladin logs in Kubernetes based on log levels. This is useful for focusing on critical events like errors or warnings, or for excluding verbose debug messages. It includes examples for displaying only errors, warnings and errors, and excluding debug logs.

```bash
# Show only error logs
kubectl logs -l app=paladin  -l app.kubernetes.io/instance=node1 | grep "ERROR"

# Show warnings and errors
kubectl logs -l app=paladin  -l app.kubernetes.io/instance=node1 | grep -E "(WARN|ERROR)"

# Exclude debug logs
kubectl logs -l app=paladin  -l app.kubernetes.io/instance=node1 | grep -v "DEBUG"

```

--------------------------------

### Describing Paladin Registration Details

Source: https://lf-decentralized-trust-labs.github.io/paladin/head/guides/administering_peers

This command provides detailed information about a specific Paladin registration, including node details, registry configuration, and the status of individual transactions (registration and publish). Useful for in-depth debugging.

```bash
kubectl describe paladinregistration node1
```

--------------------------------

### Deploy and Manage Zeto Privacy Tokens with Paladin API

Source: https://context7.com/context7/lf-decentralized-trust-labs_github_io_paladin_head/llms.txt

Shows how to deploy a new Zeto (Zero-Knowledge Proof based) token contract, mint initial supply, and perform token transfers using the Paladin Transaction Manager API. This involves a multi-step process of deployment, receipt retrieval, and subsequent function calls.

```bash
# Deploy Zeto token contract
curl -X POST http://localhost:31548/api/v1/ptx_sendTransaction \
  -H "Content-Type: application/json" \
  -d '{ \
    "type": "private", \
    "domain": "zeto", \
    "from": "issuer@node1", \
    "function": "constructor", \
    "inputs": { \
      "tokenName": "Zeto_Anon" \
    } \
  }'

# Response: { "id": "txid-001" }

# Get deployed contract address
curl -X POST http://localhost:31548/api/v1/ptx_getTransactionReceipt \
  -H "Content-Type: application/json" \
  -d '{"transactionId": "txid-001"}'

# Response includes contractAddress: "0xabcd..."

# Mint tokens
curl -X POST http://localhost:31548/api/v1/ptx_sendTransaction \
  -H "Content-Type: application/json" \
  -d '{ \
    "type": "private", \
    "domain": "zeto", \
    "from": "issuer@node1", \
    "to": "0xabcd...", \
    "function": "mint", \
    "inputs": { \
      "mints": [ \
        { \
          "to": "alice@node1", \
          "amount": "100000" \
        } \
      ] \
    } \
  }'

# Transfer tokens with ZKP
curl -X POST http://localhost:31548/api/v1/ptx_sendTransaction \
  -H "Content-Type: application/json" \
  -d '{ \
    "type": "private", \
    "domain": "zeto", \
    "from": "alice@node1", \
    "to": "0xabcd...", \
    "function": "transfer", \
    "inputs": { \
      "transfers": [ \
        { \
          "to": "bob@node2", \
          "amount": "5000" \
        } \
      ] \
    } \
  }'
```
Tokens:
Raw