Initial commit: smart contract templates for bash, go, python, and typescript

2026-03-17 19:59:47 -04:00
commit 0634e66469
35 changed files with 3794 additions and 0 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,57 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+ENV/
+env/
+.venv/
+
+# Node
+node_modules/
+
+# Go
+smart-contract
+
+# Generated proto files
+*_pb2.py
+*_pb2_grpc.py
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Claude
+.claude/
+
+# Test config (contains credentials)
+test-config.yaml
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
--- a/README.md
+++ b/README.md
@@ -0,0 +1,197 @@
+# Dragonchain Smart Contract Templates
+
+This repository contains templates for creating smart contract clients that connect to Dragonchain Prime via gRPC.
+
+## Available Templates
+
+| Template | Language | Directory |
+|----------|----------|-----------|
+| Go | Go 1.21+ | [go/](./go/) |
+| Python | Python 3.10+ | [python/](./python/) |
+| TypeScript | Node.js 18+ | [typescript/](./typescript/) |
+
+## How It Works
+
+Smart contracts connect to the Dragonchain Prime server using a bi-directional gRPC stream. The server sends transaction requests to your smart contract, which processes them and sends back responses.
+
+```
+┌─────────────────┐                    ┌─────────────────────┐
+│                 │  SmartContractRequest │                     │
+│   Dragonchain   │ ──────────────────────► │   Smart Contract    │
+│   Prime Server  │                    │      Client          │
+│                 │ ◄────────────────────── │                     │
+│                 │  SmartContractResponse │                     │
+└─────────────────┘                    └─────────────────────┘
+```
+
+### Request Flow
+
+1. Your client connects to the server with API key and smart contract ID
+2. The server sends `SmartContractRequest` messages containing:
+   - `transaction_id` - Unique identifier for correlation
+   - `transaction_json` - The transaction data to process
+   - `env_vars` - Environment variables
+   - `secrets` - Secret values (API keys, credentials)
+3. Your client processes the transaction and sends back `SmartContractResponse`:
+   - `transaction_id` - Same ID from the request
+   - `result_json` - Your processing result as JSON
+   - `logs` - Any logs captured during execution
+   - `output_to_chain` - Whether to persist the result
+   - `error` - Error message if processing failed
+
+## Quick Start
+
+### 1. Choose a Template
+
+Pick the template for your preferred language:
+
+```bash
+# For Go
+cp -r go /path/to/my-smart-contract
+
+# For Python
+cp -r python /path/to/my-smart-contract
+
+# For TypeScript/JavaScript
+cp -r typescript /path/to/my-smart-contract
+```
+
+### 2. Configure
+
+Edit `config.yaml` with your credentials:
+
+```yaml
+server_address: "your-server:50051"
+smart_contract_id: "your-smart-contract-id"
+api_key: "your-api-key"
+```
+
+### 3. Implement Your Logic
+
+Each template has a `Process` (Go), `process` (Python/TypeScript) function. Implement your business logic there:
+
+**Go** (`cmd/main.go`):
+```go
+func Process(ctx context.Context, txJSON string, envVars, secrets map[string]string) ProcessResult {
+    // Your logic here
+    return ProcessResult{Data: result, OutputToChain: true}
+}
+```
+
+**Python** (`main.py`):
+```python
+def process(tx_json: str, env_vars: dict, secrets: dict) -> ProcessResult:
+    # Your logic here
+    return ProcessResult(data=result, output_to_chain=True)
+```
+
+**TypeScript** (`src/main.ts`):
+```typescript
+async function process(txJson: string, envVars: Record<string, string>, secrets: Record<string, string>): Promise<ProcessResult> {
+    // Your logic here
+    return { data: result, outputToChain: true };
+}
+```
+
+### 4. Build and Run
+
+Each template includes a Makefile:
+
+```bash
+# Install dependencies
+make setup
+
+# Generate proto code (Go and Python only)
+make proto
+
+# Build
+make build
+
+# Run
+make run
+```
+
+## Configuration Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `server_address` | gRPC server address (host:port) | Required |
+| `smart_contract_id` | Your smart contract ID | Required |
+| `api_key` | API key for authentication | Required |
+| `use_tls` | Enable TLS encryption | `false` |
+| `tls_cert_path` | Path to TLS certificate | - |
+| `num_workers` | Concurrent transaction processors | `10` |
+| `reconnect_delay_seconds` | Reconnection delay | `5` |
+| `max_reconnect_attempts` | Max retries (0 = infinite) | `0` |
+
+## Environment Variables
+
+Your smart contract receives these environment variables:
+
+| Variable | Description |
+|----------|-------------|
+| `TZ` | Timezone |
+| `ENVIRONMENT` | Deployment environment |
+| `INTERNAL_ID` | Internal identifier |
+| `DRAGONCHAIN_ID` | Dragonchain ID |
+| `DRAGONCHAIN_ENDPOINT` | Dragonchain API endpoint |
+| `SMART_CONTRACT_ID` | This smart contract's ID |
+| `SMART_CONTRACT_NAME` | This smart contract's name |
+| `SC_ENV_*` | Custom environment variables |
+
+## Secrets
+
+Secrets are passed separately from environment variables and are prefixed with `SC_SECRET_`. Access them via the `secrets` parameter in your process function.
+
+## Concurrent Processing
+
+All templates support concurrent transaction processing. Configure the number of workers with `num_workers` in your config file. Each incoming request is processed in parallel up to the worker limit.
+
+## Reconnection
+
+All templates include automatic reconnection logic. If the connection is lost, the client will attempt to reconnect with exponential backoff based on `reconnect_delay_seconds`. Set `max_reconnect_attempts` to limit retry attempts (0 = infinite).
+
+## Docker Examples
+
+Each template README includes a Docker example. General pattern:
+
+```dockerfile
+# Build stage
+FROM <base-image> AS builder
+COPY . .
+RUN <build-commands>
+
+# Runtime stage
+FROM <runtime-image>
+COPY --from=builder <artifacts> .
+CMD [<run-command>]
+```
+
+## Development
+
+### Prerequisites
+
+**Go:**
+- Go 1.21+
+- protoc
+- protoc-gen-go, protoc-gen-go-grpc
+
+**Python:**
+- Python 3.10+
+- pip
+
+**TypeScript:**
+- Node.js 18+
+- npm
+
+### Testing
+
+Each template supports testing. Add tests and run:
+
+```bash
+make test
+```
+
+## License
+
+[Your License Here]
--- a/bash/.gitignore
+++ b/bash/.gitignore
@@ -0,0 +1,27 @@
+# Python (infrastructure runtime)
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Virtual environments
+venv/
+ENV/
+env/
+.venv/
+
+# Generated proto files
+*_pb2.py
+*_pb2_grpc.py
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Test config (contains credentials)
+test-config.yaml
+
+# Logs
+*.log
--- a/bash/Makefile
+++ b/bash/Makefile
@@ -0,0 +1,53 @@
+.PHONY: proto run clean setup venv test deps check
+
+# Generate Python code from proto files (for the gRPC infrastructure)
+proto:
+	python -m grpc_tools.protoc \
+		-I./proto \
+		--python_out=. \
+		--grpc_python_out=. \
+		proto/remote_sc.proto
+
+# Create virtual environment and install dependencies
+setup: venv
+	. venv/bin/activate && pip install -r requirements.txt
+	@echo ""
+	@echo "Setup complete. Activate the virtual environment with:"
+	@echo "  source venv/bin/activate"
+
+# Create virtual environment
+venv:
+	python3 -m venv venv
+
+# Run the smart contract
+run:
+	python main.py --config config.yaml
+
+# Clean generated files
+clean:
+	rm -f *_pb2.py *_pb2_grpc.py
+	rm -rf __pycache__
+	rm -rf venv
+
+# Run tests
+test:
+	bash -n process.sh
+	@echo "Syntax check passed"
+	@echo "Running process.sh with sample transaction..."
+	echo '{"version":"1","header":{"tag":"test","dc_id":"test-dc","txn_id":"test-txn-123","block_id":"1","txn_type":"test","timestamp":"2024-01-01T00:00:00Z","invoker":"test-user"},"payload":{"action":"test","value":42}}' | \
+		bash process.sh "$$(cat /dev/stdin)" 2>/dev/null && echo "Test passed" || echo "Test failed"
+
+# Install dependencies (without venv)
+deps:
+	pip install -r requirements.txt
+
+# Check that required tools are available
+check:
+	@command -v python3 >/dev/null 2>&1 || { echo "python3 is required but not installed"; exit 1; }
+	@command -v bash >/dev/null 2>&1 || { echo "bash is required but not installed"; exit 1; }
+	@command -v jq >/dev/null 2>&1 || { echo "jq is required but not installed"; exit 1; }
+	@echo "All required tools are available"
+
+# Format process.sh with shfmt (if available)
+format:
+	@command -v shfmt >/dev/null 2>&1 && shfmt -w process.sh || echo "shfmt not installed, skipping format"
--- a/bash/README.md
+++ b/bash/README.md
@@ -0,0 +1,243 @@
+# Bash Smart Contract Template
+
+A Bash-based smart contract client for Dragonchain Prime that connects via gRPC.
+
+This template uses a thin Python gRPC infrastructure layer to handle the network protocol, while your smart contract logic lives entirely in `process.sh`.
+
+## Prerequisites
+
+- Bash 4.0+
+- Python 3.10+ (for gRPC infrastructure)
+- pip
+- jq (for JSON processing in bash)
+
+## Quick Start
+
+1. **Copy this template** to create your smart contract:
+   ```bash
+   cp -r bash /path/to/my-smart-contract
+   cd /path/to/my-smart-contract
+   ```
+
+2. **Set up the environment**:
+   ```bash
+   make setup
+   source venv/bin/activate
+   ```
+
+   Or without make:
+   ```bash
+   python3 -m venv venv
+   source venv/bin/activate
+   pip install -r requirements.txt
+   ```
+
+3. **Generate the protobuf code**:
+   ```bash
+   make proto
+   ```
+
+4. **Configure your connection** by editing `config.yaml`:
+   ```yaml
+   server_address: "your-dragonchain-server:50051"
+   smart_contract_id: "your-smart-contract-id"
+   api_key: "your-api-key"
+   ```
+
+5. **Implement your smart contract logic** in `process.sh`.
+
+6. **Run**:
+   ```bash
+   python main.py --config config.yaml
+   ```
+
+## Configuration
+
+| Field | Description | Default |
+|-------|-------------|---------|
+| `server_address` | gRPC server address | Required |
+| `smart_contract_id` | Your smart contract ID | Required |
+| `api_key` | API key for authentication | Required |
+| `use_tls` | Enable TLS encryption | `false` |
+| `tls_cert_path` | Path to TLS certificate | - |
+| `num_workers` | Concurrent transaction processors | `10` |
+| `reconnect_delay_seconds` | Delay between reconnection attempts | `5` |
+| `max_reconnect_attempts` | Max reconnect attempts (0 = infinite) | `0` |
+
+## Implementing Your Smart Contract
+
+Edit `process.sh`. The script receives the transaction JSON as its first argument (`$1`) and must output a JSON result to stdout.
+
+### Interface
+
+**Input:**
+- `$1` - Transaction JSON string
+- Environment variables - Server env vars and secrets are exported
+
+**Output (stdout):**
+```json
+{
+  "data": { "your": "result" },
+  "output_to_chain": true,
+  "error": ""
+}
+```
+
+**Logs (stderr):** Anything written to stderr is captured and returned as logs.
+
+**Exit code:** 0 = success, non-zero = error (stderr used as error message).
+
+### Example
+
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+TX_JSON="$1"
+
+# Parse transaction fields with jq
+TXN_ID=$(echo "$TX_JSON" | jq -r '.header.txn_id')
+TXN_TYPE=$(echo "$TX_JSON" | jq -r '.header.txn_type')
+PAYLOAD=$(echo "$TX_JSON" | jq -c '.payload')
+
+# Access environment variables
+SC_NAME="${SMART_CONTRACT_NAME:-}"
+DC_ID="${DRAGONCHAIN_ID:-}"
+
+# Access secrets
+MY_SECRET="${SC_SECRET_MY_SECRET:-}"
+
+# Log to stderr
+echo "Processing transaction $TXN_ID" >&2
+
+# Process based on payload action
+ACTION=$(echo "$TX_JSON" | jq -r '.payload.action // empty')
+case "$ACTION" in
+  create)
+    RESULT='{"status": "created"}'
+    ;;
+  update)
+    RESULT='{"status": "updated"}'
+    ;;
+  *)
+    RESULT='{"status": "unknown"}'
+    ;;
+esac
+
+# Output result as JSON
+jq -n --argjson result "$RESULT" '{
+  "data": $result,
+  "output_to_chain": true,
+  "error": ""
+}'
+```
+
+### Transaction Structure
+
+The transaction JSON passed to your script has this format:
+
+```json
+{
+  "version": "1",
+  "header": {
+    "tag": "my-tag",
+    "dc_id": "dragonchain-id",
+    "txn_id": "transaction-id",
+    "block_id": "block-id",
+    "txn_type": "my-type",
+    "timestamp": "2024-01-01T00:00:00Z",
+    "invoker": "user-id"
+  },
+  "payload": {
+    "your": "custom data"
+  }
+}
+```
+
+### Available Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `TZ` | Timezone |
+| `ENVIRONMENT` | Deployment environment |
+| `INTERNAL_ID` | Internal identifier |
+| `DRAGONCHAIN_ID` | Dragonchain ID |
+| `DRAGONCHAIN_ENDPOINT` | Dragonchain API endpoint |
+| `SMART_CONTRACT_ID` | This smart contract's ID |
+| `SMART_CONTRACT_NAME` | This smart contract's name |
+| `SC_ENV_*` | Custom environment variables |
+
+### Secrets
+
+Secrets are exported as environment variables with keys prefixed by `SC_SECRET_`.
+
+## Project Structure
+
+```
+.
+├── main.py              # gRPC infrastructure (do not modify)
+├── process.sh           # Your smart contract logic (modify this)
+├── proto/
+│   └── remote_sc.proto  # gRPC service definition
+├── config.yaml          # Configuration file
+├── requirements.txt     # Python dependencies (for infrastructure)
+├── Makefile             # Build commands
+└── README.md            # This file
+```
+
+### File Descriptions
+
+- **`process.sh`** - Your smart contract logic. This is the only file you need to modify for most use cases.
+- **`main.py`** - gRPC client infrastructure that invokes `process.sh` for each transaction. You typically don't need to modify this file.
+
+## Make Commands
+
+```bash
+make setup   # Create venv and install dependencies
+make proto   # Generate Python code from proto files
+make run     # Run with default config
+make test    # Syntax check and sample run of process.sh
+make clean   # Remove generated files and venv
+make deps    # Install dependencies (no venv)
+make check   # Verify required tools (python3, bash, jq)
+make format  # Format process.sh with shfmt (if installed)
+```
+
+## Concurrent Processing
+
+The client uses a thread pool to process multiple transactions concurrently. Each worker invokes a separate instance of `process.sh`. The number of workers is configurable via `num_workers` in the config file.
+
+## Error Handling
+
+- Return errors by setting the `error` field in your JSON output, or exit with a non-zero code
+- Anything written to stderr is captured as logs
+- The client automatically handles reconnection on connection failures
+
+## Docker
+
+Example `Dockerfile`:
+
+```dockerfile
+FROM python:3.11-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends jq bash && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+RUN chmod +x process.sh
+RUN python -m grpc_tools.protoc \
+    -I./proto \
+    --python_out=. \
+    --grpc_python_out=. \
+    proto/remote_sc.proto
+
+CMD ["python", "main.py", "--config", "config.yaml"]
+```
+
+## License
+
+[Your License Here]
--- a/bash/config.yaml
+++ b/bash/config.yaml
@@ -0,0 +1,24 @@
+# Smart Contract Client Configuration
+# Copy this file and fill in your values
+
+# The gRPC server address to connect to
+server_address: "localhost:50051"
+
+# Your smart contract ID (provided by Dragonchain)
+smart_contract_id: "your-smart-contract-id"
+
+# API key for authentication (provided by Dragonchain)
+api_key: "your-api-key"
+
+# Whether to use TLS for the connection
+use_tls: false
+
+# Path to TLS certificate (required if use_tls is true)
+# tls_cert_path: "/path/to/cert.pem"
+
+# Number of worker threads for processing transactions concurrently
+num_workers: 10
+
+# Reconnect settings
+reconnect_delay_seconds: 5
+max_reconnect_attempts: 0  # 0 = infinite retries
--- a/bash/process.sh
+++ b/bash/process.sh
@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+# =============================================================================
+# Smart Contract Processing Logic
+#
+# This file contains the transaction processing logic for your smart contract.
+# Modify this script to implement your business logic.
+#
+# Input:
+#   $1          - Transaction JSON string
+#   Environment - Server env vars and secrets are exported as environment variables
+#
+# Output (stdout):
+#   A JSON object with the following fields:
+#   {
+#     "data": { ... },           // Your result data (any JSON object)
+#     "output_to_chain": true,   // Whether to persist the result on chain
+#     "error": ""                // Error message (empty string if no error)
+#   }
+#
+# Logs (stderr):
+#   Anything written to stderr is captured and sent back as logs.
+#
+# Exit code:
+#   0 = success (stdout is parsed as JSON result)
+#   non-zero = error (stderr is used as the error message)
+# =============================================================================
+
+set -euo pipefail
+
+# Transaction JSON is passed as the first argument
+TX_JSON="$1"
+
+# =============================================================================
+# TODO: Implement your smart contract logic here
+# =============================================================================
+#
+# Parse transaction fields using jq:
+#   TXN_ID=$(echo "$TX_JSON" | jq -r '.header.txn_id')
+#   TXN_TYPE=$(echo "$TX_JSON" | jq -r '.header.txn_type')
+#   PAYLOAD=$(echo "$TX_JSON" | jq '.payload')
+#
+# Access environment variables (set by the server):
+#   echo "Smart Contract Name: $SMART_CONTRACT_NAME" >&2
+#   echo "Dragonchain ID: $DRAGONCHAIN_ID" >&2
+#
+# Access secrets (set by the server):
+#   MY_SECRET="${SC_SECRET_MY_SECRET:-}"
+#
+# Process based on payload action:
+#   ACTION=$(echo "$TX_JSON" | jq -r '.payload.action // empty')
+#   case "$ACTION" in
+#     create)
+#       # Handle create operation
+#       ;;
+#     update)
+#       # Handle update operation
+#       ;;
+#     *)
+#       echo '{"data": null, "output_to_chain": false, "error": "Unknown action: '"$ACTION"'"}'
+#       exit 0
+#       ;;
+#   esac
+#
+# Log messages to stderr (captured and sent back with response):
+#   echo "Processing transaction..." >&2
+
+# Parse transaction data
+TXN_ID=$(echo "$TX_JSON" | jq -r '.header.txn_id')
+TXN_TYPE=$(echo "$TX_JSON" | jq -r '.header.txn_type')
+PAYLOAD=$(echo "$TX_JSON" | jq -c '.payload')
+
+echo "Processing transaction $TXN_ID (type: $TXN_TYPE)" >&2
+
+# Default implementation: echo back the transaction
+jq -n \
+  --arg txn_id "$TXN_ID" \
+  --arg txn_type "$TXN_TYPE" \
+  --argjson payload "$PAYLOAD" \
+  '{
+    "data": {
+      "status": "processed",
+      "transaction_id": $txn_id,
+      "txn_type": $txn_type,
+      "payload": $payload,
+      "message": "Transaction processed successfully"
+    },
+    "output_to_chain": true,
+    "error": ""
+  }'
--- a/bash/proto/remote_sc.proto
+++ b/bash/proto/remote_sc.proto
@@ -0,0 +1,48 @@
+syntax = "proto3";
+
+package remote_sc;
+
+// SmartContractService defines the bi-directional streaming service for remote
+// smart contract execution. External workers connect to this service to receive
+// execution tasks and send back results.
+service SmartContractService {
+  // Run establishes a bi-directional stream. The server sends SmartContractRequest
+  // messages to the client for execution, and the client sends back
+  // SmartContractResponse messages with results.
+  rpc Run(stream SmartContractResponse) returns (stream SmartContractRequest);
+}
+
+// SmartContractRequest is sent from the server to the connected worker
+// to request execution of a smart contract.
+message SmartContractRequest {
+  // Unique identifier for this execution request, used to correlate responses
+  string transaction_id = 1;
+
+  // Full transaction JSON to be processed by the smart contract
+  string transaction_json = 2;
+
+  // Environment variables to set for the smart contract execution
+  map<string, string> env_vars = 3;
+
+  // Secrets to be made available to the smart contract
+  map<string, string> secrets = 4;
+}
+
+// SmartContractResponse is sent from the worker back to the server
+// with the results of smart contract execution.
+message SmartContractResponse {
+  // The transaction_id from the original request, for correlation
+  string transaction_id = 1;
+
+  // The result data from the smart contract execution as JSON
+  string result_json = 2;
+
+  // Logs captured during smart contract execution
+  string logs = 3;
+
+  // Whether to persist the output to the chain
+  bool output_to_chain = 4;
+
+  // Error message if execution failed
+  string error = 5;
+}
--- a/go/.gitignore
+++ b/go/.gitignore
@@ -0,0 +1,22 @@
+# Binary
+smart-contract
+
+# Generated proto files
+proto/*.pb.go
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Test config (contains credentials)
+test-config.yaml
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
--- a/go/Makefile
+++ b/go/Makefile
@@ -0,0 +1,45 @@
+SHELL := /bin/bash
+.PHONY: proto build run clean tools test deps fix-package-name
+
+# Generate Go code from proto files
+proto:
+	protoc --go_out=. --go_opt=paths=source_relative \
+		--go-grpc_out=. --go-grpc_opt=paths=source_relative \
+		proto/remote_sc.proto
+
+# Build the smart contract binary
+build:
+	go build -o smart-contract .
+
+# Run the smart contract
+run:
+	go run . -config config.yaml
+
+# Clean build artifacts
+clean:
+	rm -f smart-contract
+
+# Install required tools
+tools:
+	go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
+	go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
+
+# Run tests
+test:
+	go test -v ./...
+
+# Download dependencies
+deps:
+	go mod download
+	go mod tidy
+
+# Fix package name based on current working directory
+fix-package-name:
+	@NEW_MODULE=$$(go list -m 2>/dev/null || echo "$$(basename $$(dirname $$(pwd)))/$$(basename $$(pwd))"); \
+	if [ -z "$$NEW_MODULE" ]; then \
+		echo "Could not determine module name. Please run 'go mod init <module-name>' first."; \
+		exit 1; \
+	fi; \
+	echo "Updating package name to: $$NEW_MODULE"; \
+	find . -type f -name "*.go" ! -path "./proto/*" -exec sed -i 's|github.com/your-org/smart-contract|'$$NEW_MODULE'|g' {} +; \
+	echo "Done. Run 'make proto' to generate proto files, then 'make build' to build."
--- a/go/README.md
+++ b/go/README.md
@@ -0,0 +1,192 @@
+# Go Smart Contract Template
+
+A Go-based smart contract client for Dragonchain Prime that connects via gRPC.
+
+## Prerequisites
+
+- Go 1.21 or later
+- Protocol Buffers compiler (`protoc`)
+- Go protobuf plugins
+
+### Installing Tools
+
+```bash
+# Install protoc (Ubuntu/Debian)
+sudo apt install -y protobuf-compiler
+
+# Install protoc (macOS)
+brew install protobuf
+
+# Install Go protobuf plugins
+make tools
+```
+
+## Quick Start
+
+1. **Copy this template** to create your smart contract:
+   ```bash
+   cp -r go /path/to/my-smart-contract
+   cd /path/to/my-smart-contract
+   ```
+
+2. **Initialize your Go module and update package names**:
+   ```bash
+   go mod init github.com/your-org/your-project
+   make fix-package-name
+   ```
+
+3. **Generate the protobuf code**:
+   ```bash
+   make proto
+   ```
+
+4. **Configure your connection** by editing `config.yaml`:
+   ```yaml
+   server_address: "your-dragonchain-server:50051"
+   smart_contract_id: "your-smart-contract-id"
+   api_key: "your-api-key"
+   ```
+
+5. **Implement your smart contract logic** in `process.go` by modifying the `Process` function.
+
+6. **Build and run**:
+   ```bash
+   make build
+   ./smart-contract -config config.yaml
+   ```
+
+## Configuration
+
+| Field | Description | Default |
+|-------|-------------|---------|
+| `server_address` | gRPC server address | Required |
+| `smart_contract_id` | Your smart contract ID | Required |
+| `api_key` | API key for authentication | Required |
+| `use_tls` | Enable TLS encryption | `false` |
+| `tls_cert_path` | Path to TLS certificate | - |
+| `num_workers` | Concurrent transaction processors | `10` |
+| `reconnect_delay_seconds` | Delay between reconnection attempts | `5` |
+| `max_reconnect_attempts` | Max reconnect attempts (0 = infinite) | `0` |
+
+## Implementing Your Smart Contract
+
+Edit the `Process` function in `process.go`:
+
+```go
+func Process(ctx context.Context, txJSON string, envVars, secrets map[string]string) ProcessResult {
+    // Parse the transaction
+    var tx Transaction
+    if err := json.Unmarshal([]byte(txJSON), &tx); err != nil {
+        return ProcessResult{Error: fmt.Errorf("failed to parse transaction: %w", err)}
+    }
+
+    // Access transaction data
+    txnId := tx.Header.TxnId
+    txnType := tx.Header.TxnType
+    payload := tx.Payload
+
+    // Access environment variables
+    scName := envVars["SMART_CONTRACT_NAME"]
+    dcID := envVars["DRAGONCHAIN_ID"]
+
+    // Access secrets
+    mySecret := secrets["SC_SECRET_MY_SECRET"]
+
+    // Implement your logic here
+    result := map[string]any{
+        "status": "success",
+        "data":   "your result data",
+    }
+
+    return ProcessResult{
+        Data:          result,
+        OutputToChain: true,  // Set to true to persist result on chain
+        Error:         nil,
+    }
+}
+```
+
+### Transaction Structure
+
+The `Transaction` struct in `process.go` matches the Dragonchain transaction format:
+
+```go
+type Transaction struct {
+    Version string            `json:"version"`
+    Header  TransactionHeader `json:"header"`
+    Payload map[string]any    `json:"payload"`
+}
+
+type TransactionHeader struct {
+    Tag       string `json:"tag"`
+    DcId      string `json:"dc_id"`
+    TxnId     string `json:"txn_id"`
+    BlockId   string `json:"block_id"`
+    TxnType   string `json:"txn_type"`
+    Timestamp string `json:"timestamp"`
+    Invoker   string `json:"invoker"`
+}
+```
+
+### Available Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `TZ` | Timezone |
+| `ENVIRONMENT` | Deployment environment |
+| `INTERNAL_ID` | Internal identifier |
+| `DRAGONCHAIN_ID` | Dragonchain ID |
+| `DRAGONCHAIN_ENDPOINT` | Dragonchain API endpoint |
+| `SMART_CONTRACT_ID` | This smart contract's ID |
+| `SMART_CONTRACT_NAME` | This smart contract's name |
+| `SC_ENV_*` | Custom environment variables |
+
+### Secrets
+
+Secrets are provided in the `secrets` map with keys prefixed by `SC_SECRET_`.
+
+## Project Structure
+
+```
+.
+├── main.go              # Client infrastructure (do not modify)
+├── process.go           # Your smart contract logic (modify this)
+├── proto/
+│   └── remote_sc.proto  # gRPC service definition
+├── config.yaml          # Configuration file
+├── go.mod               # Go module definition
+├── Makefile             # Build commands
+└── README.md            # This file
+```
+
+### File Descriptions
+
+- **`process.go`** - Contains the `Process` function where you implement your smart contract logic. This is the only file you need to modify for most use cases.
+- **`main.go`** - Contains the gRPC client infrastructure, connection handling, and worker pool. You typically don't need to modify this file.
+
+## Make Commands
+
+```bash
+make proto              # Generate Go code from proto files
+make build              # Build the binary
+make run                # Run with default config
+make test               # Run tests
+make clean              # Remove build artifacts
+make tools              # Install required tools
+make deps               # Download dependencies
+make fix-package-name   # Update package name based on go.mod
+```
+
+## Concurrent Processing
+
+The client uses a worker pool pattern to process multiple transactions concurrently. The number of workers is configurable via `num_workers` in the config file.
+
+## Error Handling
+
+- Return errors from the `Process` function to report failures to the server
+- The client automatically handles reconnection on connection failures
+- Logs are captured and sent back with the response
+
+## License
+
+[Your License Here]
--- a/go/config.yaml
+++ b/go/config.yaml
@@ -0,0 +1,24 @@
+# Smart Contract Client Configuration
+# Copy this file and fill in your values
+
+# The gRPC server address to connect to
+server_address: "localhost:50051"
+
+# Your smart contract ID (provided by Dragonchain)
+smart_contract_id: "your-smart-contract-id"
+
+# API key for authentication (provided by Dragonchain)
+api_key: "your-api-key"
+
+# Whether to use TLS for the connection
+use_tls: false
+
+# Path to TLS certificate (required if use_tls is true)
+# tls_cert_path: "/path/to/cert.pem"
+
+# Number of worker goroutines for processing transactions concurrently
+num_workers: 10
+
+# Reconnect settings
+reconnect_delay_seconds: 5
+max_reconnect_attempts: 0  # 0 = infinite retries
--- a/go/go.mod
+++ b/go/go.mod
@@ -0,0 +1,18 @@
+module github.com/your-org/smart-contract
+
+go 1.24.0
+
+toolchain go1.24.5
+
+require (
+	google.golang.org/grpc v1.78.0
+	google.golang.org/protobuf v1.36.11
+	gopkg.in/yaml.v3 v3.0.1
+)
+
+require (
+	golang.org/x/net v0.47.0 // indirect
+	golang.org/x/sys v0.38.0 // indirect
+	golang.org/x/text v0.31.0 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20251029180050-ab9386a59fda // indirect
+)
--- a/go/go.sum
+++ b/go/go.sum
@@ -0,0 +1,40 @@
+github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
+github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
+github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
+github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
+github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
+go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
+golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY=
+golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
+golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
+golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
+golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
+gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
+gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251029180050-ab9386a59fda h1:i/Q+bfisr7gq6feoJnS/DlpdwEL4ihp41fvRiM3Ork0=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20251029180050-ab9386a59fda/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk=
+google.golang.org/grpc v1.78.0 h1:K1XZG/yGDJnzMdd/uZHAkVqJE+xIDOcmdSFZkBUicNc=
+google.golang.org/grpc v1.78.0/go.mod h1:I47qjTo4OKbMkjA/aOOwxDIiPSBofUtQUI5EfpWvW7U=
+google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
+google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
--- a/go/main.go
+++ b/go/main.go
@@ -0,0 +1,311 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+	"time"
+
+	pb "github.com/your-org/smart-contract/proto"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/credentials/insecure"
+	"google.golang.org/grpc/metadata"
+	"gopkg.in/yaml.v3"
+)
+
+// =============================================================================
+// Configuration and Client Infrastructure
+// Do not modify this file unless you need to customize the client behavior.
+// Implement your smart contract logic in process.go instead.
+// =============================================================================
+
+// Config holds the client configuration loaded from YAML
+type Config struct {
+	ServerAddress        string `yaml:"server_address"`
+	SmartContractID      string `yaml:"smart_contract_id"`
+	APIKey               string `yaml:"api_key"`
+	UseTLS               bool   `yaml:"use_tls"`
+	TLSCertPath          string `yaml:"tls_cert_path"`
+	NumWorkers           int    `yaml:"num_workers"`
+	ReconnectDelaySecs   int    `yaml:"reconnect_delay_seconds"`
+	MaxReconnectAttempts int    `yaml:"max_reconnect_attempts"`
+}
+
+// Client manages the gRPC connection and request processing
+type Client struct {
+	config     *Config
+	conn       *grpc.ClientConn
+	grpcClient pb.SmartContractServiceClient
+	workChan   chan *pb.SmartContractRequest
+	wg         sync.WaitGroup
+	logger     *log.Logger
+}
+
+// NewClient creates a new smart contract client
+func NewClient(config *Config) *Client {
+	return &Client{
+		config:   config,
+		workChan: make(chan *pb.SmartContractRequest, config.NumWorkers*2),
+		logger:   log.New(os.Stdout, "[SC-Client] ", log.LstdFlags|log.Lmicroseconds),
+	}
+}
+
+// Connect establishes a connection to the gRPC server
+func (c *Client) Connect() error {
+	var opts []grpc.DialOption
+
+	if c.config.UseTLS {
+		creds, err := credentials.NewClientTLSFromFile(c.config.TLSCertPath, "")
+		if err != nil {
+			return fmt.Errorf("failed to load TLS credentials: %w", err)
+		}
+		opts = append(opts, grpc.WithTransportCredentials(creds))
+	} else {
+		opts = append(opts, grpc.WithTransportCredentials(insecure.NewCredentials()))
+	}
+
+	conn, err := grpc.NewClient(c.config.ServerAddress, opts...)
+	if err != nil {
+		return fmt.Errorf("failed to connect to server: %w", err)
+	}
+
+	c.conn = conn
+	c.grpcClient = pb.NewSmartContractServiceClient(conn)
+	c.logger.Printf("Connected to server at %s", c.config.ServerAddress)
+	return nil
+}
+
+// Close closes the gRPC connection
+func (c *Client) Close() error {
+	if c.conn != nil {
+		return c.conn.Close()
+	}
+	return nil
+}
+
+// Run starts the client and processes incoming requests
+func (c *Client) Run(ctx context.Context) error {
+	// Create metadata with authentication headers
+	md := metadata.Pairs(
+		"x-api-key", c.config.APIKey,
+		"x-smart-contract-id", c.config.SmartContractID,
+	)
+	ctx = metadata.NewOutgoingContext(ctx, md)
+
+	// Establish the bi-directional stream
+	stream, err := c.grpcClient.Run(ctx)
+	if err != nil {
+		return fmt.Errorf("failed to establish stream: %w", err)
+	}
+
+	c.logger.Printf("Stream established, starting %d workers", c.config.NumWorkers)
+
+	// Channel to collect responses from workers
+	responseChan := make(chan *pb.SmartContractResponse, c.config.NumWorkers*2)
+	errChan := make(chan error, 1)
+
+	// Start worker goroutines
+	for i := 0; i < c.config.NumWorkers; i++ {
+		c.wg.Add(1)
+		go c.worker(ctx, responseChan)
+	}
+
+	// Goroutine to send responses back to server
+	go func() {
+		for resp := range responseChan {
+			if err := stream.Send(resp); err != nil {
+				c.logger.Printf("Error sending response: %v", err)
+				select {
+				case errChan <- err:
+				default:
+				}
+				return
+			}
+		}
+	}()
+
+	// Main loop: receive requests and dispatch to workers
+	for {
+		req, err := stream.Recv()
+		if err == io.EOF {
+			c.logger.Println("Server closed the stream")
+			break
+		}
+		if err != nil {
+			return fmt.Errorf("error receiving request: %w", err)
+		}
+
+		c.logger.Printf("Received request: transaction_id=%s", req.TransactionId)
+
+		select {
+		case c.workChan <- req:
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}
+
+	// Cleanup
+	close(c.workChan)
+	c.wg.Wait()
+	close(responseChan)
+
+	return nil
+}
+
+// worker processes requests from the work channel
+func (c *Client) worker(ctx context.Context, responseChan chan<- *pb.SmartContractResponse) {
+	defer c.wg.Done()
+
+	for {
+		select {
+		case req, ok := <-c.workChan:
+			if !ok {
+				return
+			}
+			c.processRequest(ctx, req, responseChan)
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+// processRequest handles a single request
+func (c *Client) processRequest(ctx context.Context, req *pb.SmartContractRequest, responseChan chan<- *pb.SmartContractResponse) {
+	// Capture logs (in production, you might want a more sophisticated logging approach)
+	var logs string
+
+	// Call the user-defined Process function
+	result := Process(ctx, req.TransactionJson, req.EnvVars, req.Secrets)
+
+	// Build the response
+	resp := &pb.SmartContractResponse{
+		TransactionId: req.TransactionId,
+		OutputToChain: result.OutputToChain,
+		Logs:          logs,
+	}
+
+	if result.Error != nil {
+		resp.Error = result.Error.Error()
+		c.logger.Printf("Error processing transaction %s: %v", req.TransactionId, result.Error)
+	} else {
+		// Marshal the result data to JSON
+		resultJSON, err := json.Marshal(result.Data)
+		if err != nil {
+			resp.Error = fmt.Sprintf("failed to marshal result: %v", err)
+			c.logger.Printf("Error marshaling result for transaction %s: %v", req.TransactionId, err)
+		} else {
+			resp.ResultJson = string(resultJSON)
+			c.logger.Printf("Successfully processed transaction %s", req.TransactionId)
+		}
+	}
+
+	select {
+	case responseChan <- resp:
+	case <-ctx.Done():
+	}
+}
+
+// LoadConfig loads configuration from a YAML file
+func LoadConfig(path string) (*Config, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read config file: %w", err)
+	}
+
+	config := &Config{
+		NumWorkers:         10,
+		ReconnectDelaySecs: 5,
+	}
+
+	if err := yaml.Unmarshal(data, config); err != nil {
+		return nil, fmt.Errorf("failed to parse config file: %w", err)
+	}
+
+	// Validate required fields
+	if config.ServerAddress == "" {
+		return nil, fmt.Errorf("server_address is required")
+	}
+	if config.SmartContractID == "" {
+		return nil, fmt.Errorf("smart_contract_id is required")
+	}
+	if config.APIKey == "" {
+		return nil, fmt.Errorf("api_key is required")
+	}
+
+	return config, nil
+}
+
+func main() {
+	configPath := flag.String("config", "config.yaml", "Path to configuration file")
+	flag.Parse()
+
+	// Load configuration
+	config, err := LoadConfig(*configPath)
+	if err != nil {
+		log.Fatalf("Failed to load config: %v", err)
+	}
+
+	// Create client
+	client := NewClient(config)
+
+	// Setup signal handling for graceful shutdown
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
+	go func() {
+		sig := <-sigChan
+		log.Printf("Received signal %v, shutting down...", sig)
+		cancel()
+	}()
+
+	// Connection loop with reconnection logic
+	attempts := 0
+	for {
+		if err := client.Connect(); err != nil {
+			log.Printf("Connection failed: %v", err)
+		} else {
+			attempts = 0
+			if err := client.Run(ctx); err != nil {
+				if ctx.Err() != nil {
+					log.Println("Shutdown requested")
+					break
+				}
+				log.Printf("Stream error: %v", err)
+			}
+		}
+
+		_ = client.Close()
+
+		// Check if we should stop reconnecting
+		if ctx.Err() != nil {
+			break
+		}
+
+		attempts++
+		if config.MaxReconnectAttempts > 0 && attempts >= config.MaxReconnectAttempts {
+			log.Printf("Max reconnection attempts (%d) reached, exiting", config.MaxReconnectAttempts)
+			break
+		}
+
+		delay := time.Duration(config.ReconnectDelaySecs) * time.Second
+		log.Printf("Reconnecting in %v (attempt %d)...", delay, attempts)
+
+		select {
+		case <-time.After(delay):
+		case <-ctx.Done():
+			break
+		}
+	}
+
+	log.Println("Client shut down")
+}
--- a/go/process.go
+++ b/go/process.go
@@ -0,0 +1,100 @@
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// =============================================================================
+// SMART CONTRACT IMPLEMENTATION - MODIFY THIS FILE
+// =============================================================================
+
+// Transaction represents the parsed transaction from the server.
+// Customize this struct to match your transaction payload structure.
+type Transaction struct {
+	Version string            `json:"version"`
+	Header  TransactionHeader `json:"header"`
+	Payload map[string]any    `json:"payload"`
+}
+
+// TransactionHeader contains transaction metadata from Dragonchain.
+type TransactionHeader struct {
+	Tag       string `json:"tag"`
+	DcId      string `json:"dc_id"`
+	TxnId     string `json:"txn_id"`
+	BlockId   string `json:"block_id"`
+	TxnType   string `json:"txn_type"`
+	Timestamp string `json:"timestamp"`
+	Invoker   string `json:"invoker"`
+}
+
+// ProcessResult is the result returned from the Process function.
+type ProcessResult struct {
+	Data          map[string]any
+	OutputToChain bool
+	Error         error
+}
+
+// Process is the main function that handles incoming transactions.
+// Implement your smart contract logic here.
+//
+// Parameters:
+//   - ctx: Context for cancellation and timeouts
+//   - txJSON: Raw transaction JSON string
+//   - envVars: Environment variables passed from the server
+//   - secrets: Secrets passed from the server (e.g., API keys, credentials)
+//
+// Returns:
+//   - ProcessResult containing the result data, whether to output to chain, and any error
+func Process(ctx context.Context, txJSON string, envVars, secrets map[string]string) ProcessResult {
+	// Parse the transaction JSON
+	var tx Transaction
+	if err := json.Unmarshal([]byte(txJSON), &tx); err != nil {
+		return ProcessResult{
+			Error: fmt.Errorf("failed to parse transaction: %w", err),
+		}
+	}
+
+	// ==========================================================================
+	// TODO: Implement your smart contract logic here
+	// ==========================================================================
+	//
+	// Example: Access transaction data
+	// txnId := tx.Header.TxnId
+	// txnType := tx.Header.TxnType
+	// payload := tx.Payload
+	//
+	// Example: Access environment variables
+	// scName := envVars["SMART_CONTRACT_NAME"]
+	// dcID := envVars["DRAGONCHAIN_ID"]
+	//
+	// Example: Access secrets
+	// apiKey := secrets["SC_SECRET_MY_API_KEY"]
+	//
+	// Example: Process based on payload action
+	// action, _ := tx.Payload["action"].(string)
+	// switch action {
+	// case "create":
+	//     // Handle create operation
+	// case "update":
+	//     // Handle update operation
+	// default:
+	//     return ProcessResult{Error: fmt.Errorf("unknown action: %s", action)}
+	// }
+
+	// Default implementation: echo back the transaction
+	result := map[string]any{
+		"status":         "processed",
+		"transaction_id": tx.Header.TxnId,
+		"txn_type":       tx.Header.TxnType,
+		"payload":        tx.Payload,
+		"message":        "Transaction processed successfully",
+	}
+
+	return ProcessResult{
+		Data:          result,
+		OutputToChain: true,
+		Error:         nil,
+	}
+}
--- a/go/proto/remote_sc.proto
+++ b/go/proto/remote_sc.proto
@@ -0,0 +1,50 @@
+syntax = "proto3";
+
+package remote_sc;
+
+option go_package = "git.dragonchain.com/dragonchain/sc-templates/go/proto";
+
+// SmartContractService defines the bi-directional streaming service for remote
+// smart contract execution. External workers connect to this service to receive
+// execution tasks and send back results.
+service SmartContractService {
+  // Run establishes a bi-directional stream. The server sends SmartContractRequest
+  // messages to the client for execution, and the client sends back
+  // SmartContractResponse messages with results.
+  rpc Run(stream SmartContractResponse) returns (stream SmartContractRequest);
+}
+
+// SmartContractRequest is sent from the server to the connected worker
+// to request execution of a smart contract.
+message SmartContractRequest {
+  // Unique identifier for this execution request, used to correlate responses
+  string transaction_id = 1;
+
+  // Full transaction JSON to be processed by the smart contract
+  string transaction_json = 2;
+
+  // Environment variables to set for the smart contract execution
+  map<string, string> env_vars = 3;
+
+  // Secrets to be made available to the smart contract
+  map<string, string> secrets = 4;
+}
+
+// SmartContractResponse is sent from the worker back to the server
+// with the results of smart contract execution.
+message SmartContractResponse {
+  // The transaction_id from the original request, for correlation
+  string transaction_id = 1;
+
+  // The result data from the smart contract execution as JSON
+  string result_json = 2;
+
+  // Logs captured during smart contract execution
+  string logs = 3;
+
+  // Whether to persist the output to the chain
+  bool output_to_chain = 4;
+
+  // Error message if execution failed
+  string error = 5;
+}
--- a/python/Makefile
+++ b/python/Makefile
@@ -0,0 +1,40 @@
+.PHONY: proto run clean setup venv test
+
+# Generate Python code from proto files
+proto:
+	python -m grpc_tools.protoc \
+		-I./proto \
+		--python_out=. \
+		--grpc_python_out=. \
+		proto/remote_sc.proto
+
+# Create virtual environment and install dependencies
+setup: venv
+	. venv/bin/activate && pip install -r requirements.txt
+
+# Create virtual environment
+venv:
+	python3 -m venv venv
+
+# Run the smart contract
+run:
+	python main.py --config config.yaml
+
+# Clean generated files
+clean:
+	rm -f *_pb2.py *_pb2_grpc.py
+	rm -rf __pycache__
+	rm -rf venv
+
+# Run tests
+test:
+	python -m pytest tests/ -v
+
+# Install dependencies (without venv)
+deps:
+	pip install -r requirements.txt
+
+# Format code
+format:
+	black .
+	isort .
--- a/python/README.md
+++ b/python/README.md
@@ -0,0 +1,205 @@
+# Python Smart Contract Template
+
+A Python-based smart contract client for Dragonchain Prime that connects via gRPC.
+
+## Prerequisites
+
+- Python 3.10 or later
+- pip
+
+## Quick Start
+
+1. **Copy this template** to create your smart contract:
+   ```bash
+   cp -r python /path/to/my-smart-contract
+   cd /path/to/my-smart-contract
+   ```
+
+2. **Set up the environment**:
+   ```bash
+   make setup
+   source venv/bin/activate
+   ```
+
+   Or without make:
+   ```bash
+   python3 -m venv venv
+   source venv/bin/activate
+   pip install -r requirements.txt
+   ```
+
+3. **Generate the protobuf code**:
+   ```bash
+   make proto
+   ```
+
+4. **Configure your connection** by editing `config.yaml`:
+   ```yaml
+   server_address: "your-dragonchain-server:50051"
+   smart_contract_id: "your-smart-contract-id"
+   api_key: "your-api-key"
+   ```
+
+5. **Implement your smart contract logic** in `process.py` by modifying the `process` function.
+
+6. **Run**:
+   ```bash
+   python main.py --config config.yaml
+   ```
+
+## Configuration
+
+| Field | Description | Default |
+|-------|-------------|---------|
+| `server_address` | gRPC server address | Required |
+| `smart_contract_id` | Your smart contract ID | Required |
+| `api_key` | API key for authentication | Required |
+| `use_tls` | Enable TLS encryption | `false` |
+| `tls_cert_path` | Path to TLS certificate | - |
+| `num_workers` | Concurrent transaction processors | `10` |
+| `reconnect_delay_seconds` | Delay between reconnection attempts | `5` |
+| `max_reconnect_attempts` | Max reconnect attempts (0 = infinite) | `0` |
+
+## Implementing Your Smart Contract
+
+Edit the `process` function in `process.py`:
+
+```python
+def process(
+    tx_json: str,
+    env_vars: dict[str, str],
+    secrets: dict[str, str],
+) -> ProcessResult:
+    # Parse the transaction
+    tx = Transaction.from_json(tx_json)
+
+    # Access transaction data
+    txn_id = tx.header.txn_id
+    txn_type = tx.header.txn_type
+    payload = tx.payload
+
+    # Access environment variables
+    sc_name = env_vars.get("SMART_CONTRACT_NAME")
+    dc_id = env_vars.get("DRAGONCHAIN_ID")
+
+    # Access secrets
+    my_secret = secrets.get("SC_SECRET_MY_SECRET")
+
+    # Implement your logic here
+    result = {
+        "status": "success",
+        "data": "your result data",
+    }
+
+    return ProcessResult(
+        data=result,
+        output_to_chain=True,  # Set to True to persist result on chain
+        error=None,
+    )
+```
+
+### Transaction Structure
+
+The `Transaction` class in `process.py` matches the Dragonchain transaction format:
+
+```python
+@dataclass
+class Transaction:
+    version: str
+    header: TransactionHeader
+    payload: dict[str, Any]
+
+@dataclass
+class TransactionHeader:
+    tag: str
+    dc_id: str
+    txn_id: str
+    block_id: str
+    txn_type: str
+    timestamp: str
+    invoker: str
+```
+
+### Available Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `TZ` | Timezone |
+| `ENVIRONMENT` | Deployment environment |
+| `INTERNAL_ID` | Internal identifier |
+| `DRAGONCHAIN_ID` | Dragonchain ID |
+| `DRAGONCHAIN_ENDPOINT` | Dragonchain API endpoint |
+| `SMART_CONTRACT_ID` | This smart contract's ID |
+| `SMART_CONTRACT_NAME` | This smart contract's name |
+| `SC_ENV_*` | Custom environment variables |
+
+### Secrets
+
+Secrets are provided in the `secrets` dict with keys prefixed by `SC_SECRET_`.
+
+## Project Structure
+
+```
+.
+├── main.py              # Client infrastructure (do not modify)
+├── process.py           # Your smart contract logic (modify this)
+├── proto/
+│   └── remote_sc.proto  # gRPC service definition
+├── config.yaml          # Configuration file
+├── requirements.txt     # Python dependencies
+├── Makefile             # Build commands
+└── README.md            # This file
+```
+
+### File Descriptions
+
+- **`process.py`** - Contains the `process` function where you implement your smart contract logic. This is the only file you need to modify for most use cases.
+- **`main.py`** - Contains the gRPC client infrastructure, connection handling, and worker pool. You typically don't need to modify this file.
+
+## Make Commands
+
+```bash
+make setup   # Create venv and install dependencies
+make proto   # Generate Python code from proto files
+make run     # Run with default config
+make test    # Run tests
+make clean   # Remove generated files and venv
+make deps    # Install dependencies (no venv)
+make format  # Format code with black and isort
+```
+
+## Concurrent Processing
+
+The client uses a thread pool to process multiple transactions concurrently. The number of workers is configurable via `num_workers` in the config file.
+
+## Error Handling
+
+- Return errors from the `process` function via `ProcessResult.error` to report failures
+- The client automatically handles reconnection on connection failures
+- Logs are captured and sent back with the response
+
+## Docker
+
+Example `Dockerfile`:
+
+```dockerfile
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+RUN python -m grpc_tools.protoc \
+    -I./proto \
+    --python_out=. \
+    --grpc_python_out=. \
+    proto/remote_sc.proto
+
+CMD ["python", "main.py", "--config", "config.yaml"]
+```
+
+## License
+
+[Your License Here]
--- a/python/config.yaml
+++ b/python/config.yaml
@@ -0,0 +1,24 @@
+# Smart Contract Client Configuration
+# Copy this file and fill in your values
+
+# The gRPC server address to connect to
+server_address: "localhost:50051"
+
+# Your smart contract ID (provided by Dragonchain)
+smart_contract_id: "your-smart-contract-id"
+
+# API key for authentication (provided by Dragonchain)
+api_key: "your-api-key"
+
+# Whether to use TLS for the connection
+use_tls: false
+
+# Path to TLS certificate (required if use_tls is true)
+# tls_cert_path: "/path/to/cert.pem"
+
+# Number of worker threads for processing transactions concurrently
+num_workers: 10
+
+# Reconnect settings
+reconnect_delay_seconds: 5
+max_reconnect_attempts: 0  # 0 = infinite retries
--- a/python/main.py
+++ b/python/main.py
@@ -0,0 +1,297 @@
+#!/usr/bin/env python3
+"""
+Dragonchain Smart Contract Client
+
+A gRPC client that connects to Dragonchain Prime server to process
+smart contract transactions.
+
+Do not modify this file unless you need to customize the client behavior.
+Implement your smart contract logic in process.py instead.
+"""
+
+import argparse
+import json
+import logging
+import queue
+import signal
+import sys
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from typing import Any, Optional
+
+import grpc
+import yaml
+
+import remote_sc_pb2 as pb
+import remote_sc_pb2_grpc as pb_grpc
+from process import ProcessResult, process
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
+logger = logging.getLogger("SmartContract")
+
+
+# =============================================================================
+# Configuration and Client Infrastructure
+# Do not modify this file unless you need to customize the client behavior.
+# Implement your smart contract logic in process.py instead.
+# =============================================================================
+
+
+@dataclass
+class Config:
+    """Client configuration loaded from YAML."""
+
+    server_address: str
+    smart_contract_id: str
+    api_key: str
+    use_tls: bool = False
+    tls_cert_path: Optional[str] = None
+    num_workers: int = 10
+    reconnect_delay_seconds: int = 5
+    max_reconnect_attempts: int = 0  # 0 = infinite
+
+
+class SmartContractClient:
+    """gRPC client for smart contract execution."""
+
+    def __init__(self, config: Config):
+        self.config = config
+        self.channel: Optional[grpc.Channel] = None
+        self.stub: Optional[pb_grpc.SmartContractServiceStub] = None
+        self.running = False
+        self.work_queue: queue.Queue = queue.Queue()
+        self.response_queue: queue.Queue = queue.Queue()
+        self.executor: Optional[ThreadPoolExecutor] = None
+
+    def connect(self) -> bool:
+        """Establish connection to the gRPC server."""
+        try:
+            if self.config.use_tls:
+                if not self.config.tls_cert_path:
+                    logger.error("TLS enabled but no certificate path provided")
+                    return False
+                with open(self.config.tls_cert_path, "rb") as f:
+                    creds = grpc.ssl_channel_credentials(f.read())
+                self.channel = grpc.secure_channel(self.config.server_address, creds)
+            else:
+                self.channel = grpc.insecure_channel(self.config.server_address)
+
+            self.stub = pb_grpc.SmartContractServiceStub(self.channel)
+            logger.info(f"Connected to server at {self.config.server_address}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to connect: {e}")
+            return False
+
+    def close(self):
+        """Close the gRPC connection."""
+        if self.channel:
+            self.channel.close()
+            self.channel = None
+            self.stub = None
+
+    def _response_generator(self):
+        """Generator that yields responses from the response queue."""
+        while self.running:
+            try:
+                response = self.response_queue.get(timeout=1.0)
+                if response is None:
+                    break
+                yield response
+            except queue.Empty:
+                continue
+
+    def _process_request(self, request: pb.SmartContractRequest):
+        """Process a single request and queue the response."""
+        logs = ""
+
+        try:
+            result = process(
+                tx_json=request.transaction_json,
+                env_vars=dict(request.env_vars),
+                secrets=dict(request.secrets),
+            )
+
+            response = pb.SmartContractResponse(
+                transaction_id=request.transaction_id,
+                output_to_chain=result.output_to_chain,
+                logs=logs,
+            )
+
+            if result.error:
+                response.error = result.error
+                logger.error(
+                    f"Error processing transaction {request.transaction_id}: {result.error}"
+                )
+            else:
+                response.result_json = json.dumps(result.data) if result.data else "{}"
+                logger.info(f"Successfully processed transaction {request.transaction_id}")
+
+        except Exception as e:
+            response = pb.SmartContractResponse(
+                transaction_id=request.transaction_id,
+                error=str(e),
+                logs=logs,
+            )
+            logger.exception(f"Exception processing transaction {request.transaction_id}")
+
+        self.response_queue.put(response)
+
+    def _worker(self):
+        """Worker thread that processes requests from the queue."""
+        while self.running:
+            try:
+                request = self.work_queue.get(timeout=1.0)
+                if request is None:
+                    break
+                self._process_request(request)
+            except queue.Empty:
+                continue
+
+    def run(self) -> bool:
+        """Run the client and process incoming requests."""
+        if not self.stub:
+            logger.error("Not connected to server")
+            return False
+
+        self.running = True
+        self.executor = ThreadPoolExecutor(max_workers=self.config.num_workers)
+
+        # Start worker threads
+        workers = []
+        for _ in range(self.config.num_workers):
+            future = self.executor.submit(self._worker)
+            workers.append(future)
+
+        logger.info(f"Started {self.config.num_workers} worker threads")
+
+        # Create metadata for authentication
+        metadata = [
+            ("x-api-key", self.config.api_key),
+            ("x-smart-contract-id", self.config.smart_contract_id),
+        ]
+
+        try:
+            # Establish bi-directional stream
+            stream = self.stub.Run(self._response_generator(), metadata=metadata)
+
+            logger.info("Stream established, waiting for requests...")
+
+            # Receive and dispatch requests
+            for request in stream:
+                if not self.running:
+                    break
+                logger.info(f"Received request: transaction_id={request.transaction_id}")
+                self.work_queue.put(request)
+
+            logger.info("Server closed the stream")
+            return True
+
+        except grpc.RpcError as e:
+            logger.error(f"gRPC error: {e.code()} - {e.details()}")
+            return False
+        except Exception as e:
+            logger.exception(f"Error in run loop: {e}")
+            return False
+        finally:
+            self.running = False
+
+            # Signal workers to stop
+            for _ in range(self.config.num_workers):
+                self.work_queue.put(None)
+            self.response_queue.put(None)
+
+            # Wait for workers to finish
+            if self.executor:
+                self.executor.shutdown(wait=True)
+
+    def stop(self):
+        """Stop the client gracefully."""
+        logger.info("Stopping client...")
+        self.running = False
+
+
+def load_config(path: str) -> Config:
+    """Load configuration from a YAML file."""
+    with open(path, "r") as f:
+        data = yaml.safe_load(f)
+
+    # Validate required fields
+    required = ["server_address", "smart_contract_id", "api_key"]
+    for field in required:
+        if field not in data or not data[field]:
+            raise ValueError(f"Missing required config field: {field}")
+
+    return Config(
+        server_address=data["server_address"],
+        smart_contract_id=data["smart_contract_id"],
+        api_key=data["api_key"],
+        use_tls=data.get("use_tls", False),
+        tls_cert_path=data.get("tls_cert_path"),
+        num_workers=data.get("num_workers", 10),
+        reconnect_delay_seconds=data.get("reconnect_delay_seconds", 5),
+        max_reconnect_attempts=data.get("max_reconnect_attempts", 0),
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Dragonchain Smart Contract Client")
+    parser.add_argument(
+        "--config",
+        "-c",
+        default="config.yaml",
+        help="Path to configuration file",
+    )
+    args = parser.parse_args()
+
+    # Load configuration
+    try:
+        config = load_config(args.config)
+    except Exception as e:
+        logger.error(f"Failed to load config: {e}")
+        sys.exit(1)
+
+    # Create client
+    client = SmartContractClient(config)
+
+    # Setup signal handling for graceful shutdown
+    def signal_handler(signum, frame):
+        logger.info(f"Received signal {signum}, shutting down...")
+        client.stop()
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    # Connection loop with reconnection logic
+    attempts = 0
+    while True:
+        if client.connect():
+            attempts = 0
+            if not client.run():
+                if not client.running:
+                    logger.info("Shutdown requested")
+                    break
+
+        client.close()
+
+        attempts += 1
+        if config.max_reconnect_attempts > 0 and attempts >= config.max_reconnect_attempts:
+            logger.error(f"Max reconnection attempts ({config.max_reconnect_attempts}) reached")
+            break
+
+        delay = config.reconnect_delay_seconds
+        logger.info(f"Reconnecting in {delay} seconds (attempt {attempts})...")
+        time.sleep(delay)
+
+    logger.info("Client shut down")
+
+
+if __name__ == "__main__":
+    main()
--- a/python/package-lock.json
+++ b/python/package-lock.json
@@ -0,0 +1,6 @@
+{
+  "name": "python",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}
--- a/python/process.py
+++ b/python/process.py
@@ -0,0 +1,140 @@
+"""
+Smart Contract Processing Logic
+
+This file contains the transaction processing logic for your smart contract.
+Modify the `process` function to implement your business logic.
+"""
+
+import json
+from dataclasses import dataclass
+from typing import Any, Optional
+
+
+# =============================================================================
+# SMART CONTRACT IMPLEMENTATION - MODIFY THIS FILE
+# =============================================================================
+
+
+@dataclass
+class TransactionHeader:
+    """Transaction metadata from Dragonchain."""
+
+    tag: str
+    dc_id: str
+    txn_id: str
+    block_id: str
+    txn_type: str
+    timestamp: str
+    invoker: str
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "TransactionHeader":
+        """Parse header from dictionary."""
+        return cls(
+            tag=data.get("tag", ""),
+            dc_id=data.get("dc_id", ""),
+            txn_id=data.get("txn_id", ""),
+            block_id=data.get("block_id", ""),
+            txn_type=data.get("txn_type", ""),
+            timestamp=data.get("timestamp", ""),
+            invoker=data.get("invoker", ""),
+        )
+
+
+@dataclass
+class Transaction:
+    """
+    Parsed transaction from the server.
+
+    Customize this class to match your transaction payload structure.
+    """
+
+    version: str
+    header: TransactionHeader
+    payload: dict[str, Any]
+
+    @classmethod
+    def from_json(cls, json_str: str) -> "Transaction":
+        """Parse a transaction from JSON string."""
+        data = json.loads(json_str)
+        return cls(
+            version=data.get("version", ""),
+            header=TransactionHeader.from_dict(data.get("header", {})),
+            payload=data.get("payload", {}),
+        )
+
+
+@dataclass
+class ProcessResult:
+    """Result from the process function."""
+
+    data: Optional[dict[str, Any]] = None
+    output_to_chain: bool = True
+    error: Optional[str] = None
+
+
+def process(
+    tx_json: str,
+    env_vars: dict[str, str],
+    secrets: dict[str, str],
+) -> ProcessResult:
+    """
+    Process an incoming transaction.
+
+    Implement your smart contract logic here.
+
+    Args:
+        tx_json: Raw transaction JSON string
+        env_vars: Environment variables passed from the server
+        secrets: Secrets passed from the server (e.g., API keys, credentials)
+
+    Returns:
+        ProcessResult containing the result data, whether to output to chain, and any error
+    """
+    try:
+        # Parse the transaction JSON
+        tx = Transaction.from_json(tx_json)
+    except json.JSONDecodeError as e:
+        return ProcessResult(error=f"Failed to parse transaction: {e}")
+
+    # ==========================================================================
+    # TODO: Implement your smart contract logic here
+    # ==========================================================================
+    #
+    # Example: Access transaction data
+    # txn_id = tx.header.txn_id
+    # txn_type = tx.header.txn_type
+    # payload = tx.payload
+    #
+    # Example: Access environment variables
+    # sc_name = env_vars.get("SMART_CONTRACT_NAME")
+    # dc_id = env_vars.get("DRAGONCHAIN_ID")
+    #
+    # Example: Access secrets
+    # api_key = secrets.get("SC_SECRET_MY_API_KEY")
+    #
+    # Example: Process based on payload action
+    # action = tx.payload.get("action")
+    # if action == "create":
+    #     # Handle create operation
+    #     pass
+    # elif action == "update":
+    #     # Handle update operation
+    #     pass
+    # else:
+    #     return ProcessResult(error=f"Unknown action: {action}")
+
+    # Default implementation: echo back the transaction
+    result = {
+        "status": "processed",
+        "transaction_id": tx.header.txn_id,
+        "txn_type": tx.header.txn_type,
+        "payload": tx.payload,
+        "message": "Transaction processed successfully",
+    }
+
+    return ProcessResult(
+        data=result,
+        output_to_chain=True,
+        error=None,
+    )
--- a/python/proto/remote_sc.proto
+++ b/python/proto/remote_sc.proto
@@ -0,0 +1,48 @@
+syntax = "proto3";
+
+package remote_sc;
+
+// SmartContractService defines the bi-directional streaming service for remote
+// smart contract execution. External workers connect to this service to receive
+// execution tasks and send back results.
+service SmartContractService {
+  // Run establishes a bi-directional stream. The server sends SmartContractRequest
+  // messages to the client for execution, and the client sends back
+  // SmartContractResponse messages with results.
+  rpc Run(stream SmartContractResponse) returns (stream SmartContractRequest);
+}
+
+// SmartContractRequest is sent from the server to the connected worker
+// to request execution of a smart contract.
+message SmartContractRequest {
+  // Unique identifier for this execution request, used to correlate responses
+  string transaction_id = 1;
+
+  // Full transaction JSON to be processed by the smart contract
+  string transaction_json = 2;
+
+  // Environment variables to set for the smart contract execution
+  map<string, string> env_vars = 3;
+
+  // Secrets to be made available to the smart contract
+  map<string, string> secrets = 4;
+}
+
+// SmartContractResponse is sent from the worker back to the server
+// with the results of smart contract execution.
+message SmartContractResponse {
+  // The transaction_id from the original request, for correlation
+  string transaction_id = 1;
+
+  // The result data from the smart contract execution as JSON
+  string result_json = 2;
+
+  // Logs captured during smart contract execution
+  string logs = 3;
+
+  // Whether to persist the output to the chain
+  bool output_to_chain = 4;
+
+  // Error message if execution failed
+  string error = 5;
+}
--- a/python/requirements.txt
+++ b/python/requirements.txt
@@ -0,0 +1,4 @@
+grpcio>=1.60.0
+grpcio-tools>=1.60.0
+protobuf>=4.25.0
+pyyaml>=6.0
--- a/typescript/.gitignore
+++ b/typescript/.gitignore
@@ -0,0 +1,28 @@
+# Dependencies
+node_modules/
+
+# Build output
+dist/
+
+# Generated proto files
+src/proto/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Test config (contains credentials)
+test-config.yaml
+
+# Logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# OS
+.DS_Store
+Thumbs.db
--- a/typescript/Makefile
+++ b/typescript/Makefile
@@ -0,0 +1,38 @@
+.PHONY: proto build run clean setup test
+
+# Generate TypeScript types from proto files
+proto:
+	npm run proto
+
+# Install dependencies
+setup:
+	npm install
+
+# Build the TypeScript code
+build:
+	npm run build
+
+# Run the smart contract (production)
+run: build
+	npm start -- --config config.yaml
+
+# Run in development mode (with ts-node)
+dev:
+	npm run dev -- --config config.yaml
+
+# Clean build artifacts
+clean:
+	npm run clean
+	rm -rf node_modules
+
+# Run tests
+test:
+	npm test
+
+# Lint code
+lint:
+	npm run lint
+
+# Format code
+format:
+	npm run format
--- a/typescript/README.md
+++ b/typescript/README.md
@@ -0,0 +1,220 @@
+# TypeScript Smart Contract Template
+
+A TypeScript/JavaScript-based smart contract client for Dragonchain Prime that connects via gRPC.
+
+## Prerequisites
+
+- Node.js 18 or later
+- npm
+
+## Quick Start
+
+1. **Copy this template** to create your smart contract:
+   ```bash
+   cp -r typescript /path/to/my-smart-contract
+   cd /path/to/my-smart-contract
+   ```
+
+2. **Install dependencies**:
+   ```bash
+   npm install
+   ```
+
+3. **Configure your connection** by editing `config.yaml`:
+   ```yaml
+   server_address: "your-dragonchain-server:50051"
+   smart_contract_id: "your-smart-contract-id"
+   api_key: "your-api-key"
+   ```
+
+4. **Implement your smart contract logic** in `src/process.ts` by modifying the `processTransaction` function.
+
+5. **Build and run**:
+   ```bash
+   npm run build
+   npm start -- --config config.yaml
+   ```
+
+   Or run in development mode:
+   ```bash
+   npm run dev -- --config config.yaml
+   ```
+
+## Configuration
+
+| Field | Description | Default |
+|-------|-------------|---------|
+| `server_address` | gRPC server address | Required |
+| `smart_contract_id` | Your smart contract ID | Required |
+| `api_key` | API key for authentication | Required |
+| `use_tls` | Enable TLS encryption | `false` |
+| `tls_cert_path` | Path to TLS certificate | - |
+| `num_workers` | Concurrent transaction processors | `10` |
+| `reconnect_delay_seconds` | Delay between reconnection attempts | `5` |
+| `max_reconnect_attempts` | Max reconnect attempts (0 = infinite) | `0` |
+
+## Implementing Your Smart Contract
+
+Edit the `processTransaction` function in `src/process.ts`:
+
+```typescript
+export async function processTransaction(
+  txJson: string,
+  envVars: Record<string, string>,
+  secrets: Record<string, string>
+): Promise<ProcessResult> {
+  // Parse the transaction
+  const tx: Transaction = JSON.parse(txJson);
+
+  // Access transaction data
+  const txnId = tx.header.txn_id;
+  const txnType = tx.header.txn_type;
+  const payload = tx.payload;
+
+  // Access environment variables
+  const scName = envVars["SMART_CONTRACT_NAME"];
+  const dcId = envVars["DRAGONCHAIN_ID"];
+
+  // Access secrets
+  const mySecret = secrets["SC_SECRET_MY_SECRET"];
+
+  // Implement your logic here
+  const result = {
+    status: "success",
+    data: "your result data",
+  };
+
+  return {
+    data: result,
+    outputToChain: true,  // Set to true to persist result on chain
+  };
+}
+```
+
+### Transaction Structure
+
+The `Transaction` interface in `src/process.ts` matches the Dragonchain transaction format:
+
+```typescript
+interface Transaction {
+  version: string;
+  header: TransactionHeader;
+  payload: Record<string, unknown>;
+}
+
+interface TransactionHeader {
+  tag: string;
+  dc_id: string;
+  txn_id: string;
+  block_id: string;
+  txn_type: string;
+  timestamp: string;
+  invoker: string;
+}
+```
+
+### Available Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `TZ` | Timezone |
+| `ENVIRONMENT` | Deployment environment |
+| `INTERNAL_ID` | Internal identifier |
+| `DRAGONCHAIN_ID` | Dragonchain ID |
+| `DRAGONCHAIN_ENDPOINT` | Dragonchain API endpoint |
+| `SMART_CONTRACT_ID` | This smart contract's ID |
+| `SMART_CONTRACT_NAME` | This smart contract's name |
+| `SC_ENV_*` | Custom environment variables |
+
+### Secrets
+
+Secrets are provided in the `secrets` object with keys prefixed by `SC_SECRET_`.
+
+## Project Structure
+
+```
+.
+├── src/
+│   ├── main.ts          # Client infrastructure (do not modify)
+│   └── process.ts       # Your smart contract logic (modify this)
+├── proto/
+│   └── remote_sc.proto  # gRPC service definition
+├── config.yaml          # Configuration file
+├── package.json         # Node.js dependencies
+├── tsconfig.json        # TypeScript configuration
+├── Makefile             # Build commands
+└── README.md            # This file
+```
+
+### File Descriptions
+
+- **`src/process.ts`** - Contains the `processTransaction` function where you implement your smart contract logic. This is the only file you need to modify for most use cases.
+- **`src/main.ts`** - Contains the gRPC client infrastructure, connection handling, and worker pool. You typically don't need to modify this file.
+
+## NPM Scripts
+
+```bash
+npm install        # Install dependencies
+npm run build      # Compile TypeScript to JavaScript
+npm start          # Run the compiled application
+npm run dev        # Run with ts-node (development)
+npm run proto      # Generate TypeScript types from proto
+npm run clean      # Remove build artifacts
+npm run lint       # Lint the code
+npm run format     # Format code with prettier
+```
+
+## Make Commands
+
+```bash
+make setup   # Install dependencies
+make proto   # Generate TypeScript types from proto
+make build   # Build TypeScript
+make run     # Build and run
+make dev     # Run in development mode
+make clean   # Remove build artifacts
+make lint    # Lint code
+make format  # Format code
+```
+
+## Concurrent Processing
+
+The client uses async/await with a concurrency limit to process multiple transactions simultaneously. The number of concurrent workers is configurable via `num_workers` in the config file.
+
+## Error Handling
+
+- Return errors from the `processTransaction` function via `ProcessResult.error` to report failures
+- The client automatically handles reconnection on connection failures
+- Logs are captured and sent back with the response
+
+## Docker
+
+Example `Dockerfile`:
+
+```dockerfile
+FROM node:20-slim
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm ci --only=production
+
+COPY . .
+RUN npm run build
+
+CMD ["node", "dist/main.js", "--config", "config.yaml"]
+```
+
+## Using with JavaScript
+
+If you prefer plain JavaScript instead of TypeScript:
+
+1. Write your code in `src/process.js` instead of `src/process.ts`
+2. Skip the build step and run directly:
+   ```bash
+   node src/main.js --config config.yaml
+   ```
+
+## License
+
+[Your License Here]
--- a/typescript/config.yaml
+++ b/typescript/config.yaml
@@ -0,0 +1,24 @@
+# Smart Contract Client Configuration
+# Copy this file and fill in your values
+
+# The gRPC server address to connect to
+server_address: "localhost:50051"
+
+# Your smart contract ID (provided by Dragonchain)
+smart_contract_id: "your-smart-contract-id"
+
+# API key for authentication (provided by Dragonchain)
+api_key: "your-api-key"
+
+# Whether to use TLS for the connection
+use_tls: false
+
+# Path to TLS certificate (required if use_tls is true)
+# tls_cert_path: "/path/to/cert.pem"
+
+# Number of concurrent workers for processing transactions
+num_workers: 10
+
+# Reconnect settings
+reconnect_delay_seconds: 5
+max_reconnect_attempts: 0  # 0 = infinite retries
--- a/typescript/package-lock.json
+++ b/typescript/package-lock.json
@@ -0,0 +1,603 @@
+{
+  "name": "smart-contract",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "smart-contract",
+      "version": "1.0.0",
+      "dependencies": {
+        "@grpc/grpc-js": "^1.9.0",
+        "@grpc/proto-loader": "^0.7.0",
+        "js-yaml": "^4.1.0"
+      },
+      "devDependencies": {
+        "@types/js-yaml": "^4.0.9",
+        "@types/node": "^20.0.0",
+        "ts-node": "^10.9.0",
+        "typescript": "^5.3.0"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@cspotcode/source-map-support": {
+      "version": "0.8.1",
+      "resolved": "https://registry.npmjs.org/@cspotcode/source-map-support/-/source-map-support-0.8.1.tgz",
+      "integrity": "sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/trace-mapping": "0.3.9"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@grpc/grpc-js": {
+      "version": "1.14.3",
+      "resolved": "https://registry.npmjs.org/@grpc/grpc-js/-/grpc-js-1.14.3.tgz",
+      "integrity": "sha512-Iq8QQQ/7X3Sac15oB6p0FmUg/klxQvXLeileoqrTRGJYLV+/9tubbr9ipz0GKHjmXVsgFPo/+W+2cA8eNcR+XA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@grpc/proto-loader": "^0.8.0",
+        "@js-sdsl/ordered-map": "^4.4.2"
+      },
+      "engines": {
+        "node": ">=12.10.0"
+      }
+    },
+    "node_modules/@grpc/grpc-js/node_modules/@grpc/proto-loader": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/@grpc/proto-loader/-/proto-loader-0.8.0.tgz",
+      "integrity": "sha512-rc1hOQtjIWGxcxpb9aHAfLpIctjEnsDehj0DAiVfBlmT84uvR0uUtN2hEi/ecvWVjXUGf5qPF4qEgiLOx1YIMQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "lodash.camelcase": "^4.3.0",
+        "long": "^5.0.0",
+        "protobufjs": "^7.5.3",
+        "yargs": "^17.7.2"
+      },
+      "bin": {
+        "proto-loader-gen-types": "build/bin/proto-loader-gen-types.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/@grpc/proto-loader": {
+      "version": "0.7.15",
+      "resolved": "https://registry.npmjs.org/@grpc/proto-loader/-/proto-loader-0.7.15.tgz",
+      "integrity": "sha512-tMXdRCfYVixjuFK+Hk0Q1s38gV9zDiDJfWL3h1rv4Qc39oILCu1TRTDt7+fGUI8K4G1Fj125Hx/ru3azECWTyQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "lodash.camelcase": "^4.3.0",
+        "long": "^5.0.0",
+        "protobufjs": "^7.2.5",
+        "yargs": "^17.7.2"
+      },
+      "bin": {
+        "proto-loader-gen-types": "build/bin/proto-loader-gen-types.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.9",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.9.tgz",
+      "integrity": "sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.0.3",
+        "@jridgewell/sourcemap-codec": "^1.4.10"
+      }
+    },
+    "node_modules/@js-sdsl/ordered-map": {
+      "version": "4.4.2",
+      "resolved": "https://registry.npmjs.org/@js-sdsl/ordered-map/-/ordered-map-4.4.2.tgz",
+      "integrity": "sha512-iUKgm52T8HOE/makSxjqoWhe95ZJA1/G1sYsGev2JDKUSS14KAgg1LHb+Ba+IPow0xflbnSkOsZcO08C7w1gYw==",
+      "license": "MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/js-sdsl"
+      }
+    },
+    "node_modules/@protobufjs/aspromise": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
+      "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/base64": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz",
+      "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/codegen": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.4.tgz",
+      "integrity": "sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/eventemitter": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.0.tgz",
+      "integrity": "sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/fetch": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.0.tgz",
+      "integrity": "sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.1",
+        "@protobufjs/inquire": "^1.1.0"
+      }
+    },
+    "node_modules/@protobufjs/float": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz",
+      "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/inquire": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.0.tgz",
+      "integrity": "sha512-kdSefcPdruJiFMVSbn801t4vFK7KB/5gd2fYvrxhuJYg8ILrmn9SKSX2tZdV6V+ksulWqS7aXjBcRXl3wHoD9Q==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/path": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz",
+      "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/pool": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz",
+      "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/utf8": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.0.tgz",
+      "integrity": "sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@tsconfig/node10": {
+      "version": "1.0.12",
+      "resolved": "https://registry.npmjs.org/@tsconfig/node10/-/node10-1.0.12.tgz",
+      "integrity": "sha512-UCYBaeFvM11aU2y3YPZ//O5Rhj+xKyzy7mvcIoAjASbigy8mHMryP5cK7dgjlz2hWxh1g5pLw084E0a/wlUSFQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@tsconfig/node12": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/@tsconfig/node12/-/node12-1.0.11.tgz",
+      "integrity": "sha512-cqefuRsh12pWyGsIoBKJA9luFu3mRxCA+ORZvA4ktLSzIuCUtWVxGIuXigEwO5/ywWFMZ2QEGKWvkZG1zDMTag==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@tsconfig/node14": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@tsconfig/node14/-/node14-1.0.3.tgz",
+      "integrity": "sha512-ysT8mhdixWK6Hw3i1V2AeRqZ5WfXg1G43mqoYlM2nc6388Fq5jcXyr5mRsqViLx/GJYdoL0bfXD8nmF+Zn/Iow==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@tsconfig/node16": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@tsconfig/node16/-/node16-1.0.4.tgz",
+      "integrity": "sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/js-yaml": {
+      "version": "4.0.9",
+      "resolved": "https://registry.npmjs.org/@types/js-yaml/-/js-yaml-4.0.9.tgz",
+      "integrity": "sha512-k4MGaQl5TGo/iipqb2UDG2UwjXziSWkh0uysQelTlJpX1qGlpUZYm8PnO4DxG1qBomtJUdYJ6qR6xdIah10JLg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/node": {
+      "version": "20.19.30",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.30.tgz",
+      "integrity": "sha512-WJtwWJu7UdlvzEAUm484QNg5eAoq5QR08KDNx7g45Usrs2NtOPiX8ugDqmKdXkyL03rBqU5dYNYVQetEpBHq2g==",
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.15.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.15.0.tgz",
+      "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-walk": {
+      "version": "8.3.4",
+      "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.4.tgz",
+      "integrity": "sha512-ueEepnujpqee2o5aIYnvHU6C0A42MNdsIDeqy5BydrkuC5R1ZuUFnm27EeFJGoEHJQgn3uleRvmTXaJgfXbt4g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "acorn": "^8.11.0"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/arg": {
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/arg/-/arg-4.1.3.tgz",
+      "integrity": "sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "license": "Python-2.0"
+    },
+    "node_modules/cliui": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.1",
+        "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "license": "MIT"
+    },
+    "node_modules/create-require": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/create-require/-/create-require-1.1.1.tgz",
+      "integrity": "sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/diff": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/diff/-/diff-4.0.4.tgz",
+      "integrity": "sha512-X07nttJQkwkfKfvTPG/KSnE2OMdcUCao6+eXF3wmnIQRn2aPAHH3VxDbDOdegkd6JbPsXqShpvEOHfAT+nCNwQ==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.3.1"
+      }
+    },
+    "node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "license": "ISC",
+      "engines": {
+        "node": "6.* || 8.* || >= 10.*"
+      }
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/lodash.camelcase": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/lodash.camelcase/-/lodash.camelcase-4.3.0.tgz",
+      "integrity": "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA==",
+      "license": "MIT"
+    },
+    "node_modules/long": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz",
+      "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
+      "license": "Apache-2.0"
+    },
+    "node_modules/make-error": {
+      "version": "1.3.6",
+      "resolved": "https://registry.npmjs.org/make-error/-/make-error-1.3.6.tgz",
+      "integrity": "sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/protobufjs": {
+      "version": "7.5.4",
+      "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.5.4.tgz",
+      "integrity": "sha512-CvexbZtbov6jW2eXAvLukXjXUW1TzFaivC46BpWc/3BpcCysb5Vffu+B3XHMm8lVEuy2Mm4XGex8hBSg1yapPg==",
+      "hasInstallScript": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.2",
+        "@protobufjs/base64": "^1.1.2",
+        "@protobufjs/codegen": "^2.0.4",
+        "@protobufjs/eventemitter": "^1.1.0",
+        "@protobufjs/fetch": "^1.1.0",
+        "@protobufjs/float": "^1.0.2",
+        "@protobufjs/inquire": "^1.1.0",
+        "@protobufjs/path": "^1.1.2",
+        "@protobufjs/pool": "^1.1.0",
+        "@protobufjs/utf8": "^1.1.0",
+        "@types/node": ">=13.7.0",
+        "long": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ts-node": {
+      "version": "10.9.2",
+      "resolved": "https://registry.npmjs.org/ts-node/-/ts-node-10.9.2.tgz",
+      "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@cspotcode/source-map-support": "^0.8.0",
+        "@tsconfig/node10": "^1.0.7",
+        "@tsconfig/node12": "^1.0.7",
+        "@tsconfig/node14": "^1.0.0",
+        "@tsconfig/node16": "^1.0.2",
+        "acorn": "^8.4.1",
+        "acorn-walk": "^8.1.1",
+        "arg": "^4.1.0",
+        "create-require": "^1.1.0",
+        "diff": "^4.0.1",
+        "make-error": "^1.1.1",
+        "v8-compile-cache-lib": "^3.0.1",
+        "yn": "3.1.1"
+      },
+      "bin": {
+        "ts-node": "dist/bin.js",
+        "ts-node-cwd": "dist/bin-cwd.js",
+        "ts-node-esm": "dist/bin-esm.js",
+        "ts-node-script": "dist/bin-script.js",
+        "ts-node-transpile-only": "dist/bin-transpile.js",
+        "ts-script": "dist/bin-script-deprecated.js"
+      },
+      "peerDependencies": {
+        "@swc/core": ">=1.2.50",
+        "@swc/wasm": ">=1.2.50",
+        "@types/node": "*",
+        "typescript": ">=2.7"
+      },
+      "peerDependenciesMeta": {
+        "@swc/core": {
+          "optional": true
+        },
+        "@swc/wasm": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "license": "MIT"
+    },
+    "node_modules/v8-compile-cache-lib": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/v8-compile-cache-lib/-/v8-compile-cache-lib-3.0.1.tgz",
+      "integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/y18n": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yargs": {
+      "version": "17.7.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^8.0.1",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.3",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^21.1.1"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/yargs-parser": {
+      "version": "21.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/yn": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz",
+      "integrity": "sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    }
+  }
+}
--- a/typescript/package.json
+++ b/typescript/package.json
@@ -0,0 +1,29 @@
+{
+  "name": "smart-contract",
+  "version": "1.0.0",
+  "description": "Dragonchain Smart Contract Client",
+  "main": "dist/main.js",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/main.js",
+    "dev": "ts-node src/main.ts",
+    "proto": "proto-loader-gen-types --grpcLib=@grpc/grpc-js --outDir=src/proto proto/remote_sc.proto",
+    "clean": "rm -rf dist",
+    "lint": "eslint src/**/*.ts",
+    "format": "prettier --write src/**/*.ts"
+  },
+  "dependencies": {
+    "@grpc/grpc-js": "^1.9.0",
+    "@grpc/proto-loader": "^0.7.0",
+    "js-yaml": "^4.1.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.3.0",
+    "ts-node": "^10.9.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}
--- a/typescript/proto/remote_sc.proto
+++ b/typescript/proto/remote_sc.proto
@@ -0,0 +1,48 @@
+syntax = "proto3";
+
+package remote_sc;
+
+// SmartContractService defines the bi-directional streaming service for remote
+// smart contract execution. External workers connect to this service to receive
+// execution tasks and send back results.
+service SmartContractService {
+  // Run establishes a bi-directional stream. The server sends SmartContractRequest
+  // messages to the client for execution, and the client sends back
+  // SmartContractResponse messages with results.
+  rpc Run(stream SmartContractResponse) returns (stream SmartContractRequest);
+}
+
+// SmartContractRequest is sent from the server to the connected worker
+// to request execution of a smart contract.
+message SmartContractRequest {
+  // Unique identifier for this execution request, used to correlate responses
+  string transaction_id = 1;
+
+  // Full transaction JSON to be processed by the smart contract
+  string transaction_json = 2;
+
+  // Environment variables to set for the smart contract execution
+  map<string, string> env_vars = 3;
+
+  // Secrets to be made available to the smart contract
+  map<string, string> secrets = 4;
+}
+
+// SmartContractResponse is sent from the worker back to the server
+// with the results of smart contract execution.
+message SmartContractResponse {
+  // The transaction_id from the original request, for correlation
+  string transaction_id = 1;
+
+  // The result data from the smart contract execution as JSON
+  string result_json = 2;
+
+  // Logs captured during smart contract execution
+  string logs = 3;
+
+  // Whether to persist the output to the chain
+  bool output_to_chain = 4;
+
+  // Error message if execution failed
+  string error = 5;
+}
--- a/typescript/src/main.ts
+++ b/typescript/src/main.ts
@@ -0,0 +1,369 @@
+/**
+ * Dragonchain Smart Contract Client
+ *
+ * A gRPC client that connects to Dragonchain Prime server to process
+ * smart contract transactions.
+ *
+ * Do not modify this file unless you need to customize the client behavior.
+ * Implement your smart contract logic in process.ts instead.
+ */
+
+import * as grpc from "@grpc/grpc-js";
+import * as protoLoader from "@grpc/proto-loader";
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+
+import { ProcessResult, processTransaction } from "./process";
+
+// Load proto definition
+const PROTO_PATH = path.join(__dirname, "../proto/remote_sc.proto");
+const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
+  keepCase: false,
+  longs: String,
+  enums: String,
+  defaults: true,
+  oneofs: true,
+});
+
+const protoDescriptor = grpc.loadPackageDefinition(packageDefinition) as any;
+const SmartContractService = protoDescriptor.remote_sc.SmartContractService;
+
+// =============================================================================
+// Configuration and Client Infrastructure
+// Do not modify this file unless you need to customize the client behavior.
+// Implement your smart contract logic in process.ts instead.
+// =============================================================================
+
+interface Config {
+  serverAddress: string;
+  smartContractId: string;
+  apiKey: string;
+  useTls: boolean;
+  tlsCertPath?: string;
+  numWorkers: number;
+  reconnectDelaySeconds: number;
+  maxReconnectAttempts: number;
+}
+
+interface SmartContractRequest {
+  transactionId: string;
+  transactionJson: string;
+  envVars: Record<string, string>;
+  secrets: Record<string, string>;
+}
+
+interface SmartContractResponse {
+  transactionId: string;
+  resultJson: string;
+  logs: string;
+  outputToChain: boolean;
+  error: string;
+}
+
+class SmartContractClient {
+  private config: Config;
+  private client: any;
+  private running: boolean = false;
+  private workQueue: SmartContractRequest[] = [];
+  private processing: Set<string> = new Set();
+  private stream: any;
+
+  constructor(config: Config) {
+    this.config = config;
+  }
+
+  /**
+   * Connect to the gRPC server.
+   */
+  connect(): boolean {
+    try {
+      let credentials: grpc.ChannelCredentials;
+
+      if (this.config.useTls) {
+        if (!this.config.tlsCertPath) {
+          console.error("[SC-Client] TLS enabled but no certificate path provided");
+          return false;
+        }
+        const rootCert = fs.readFileSync(this.config.tlsCertPath);
+        credentials = grpc.credentials.createSsl(rootCert);
+      } else {
+        credentials = grpc.credentials.createInsecure();
+      }
+
+      this.client = new SmartContractService(
+        this.config.serverAddress,
+        credentials
+      );
+
+      console.log(`[SC-Client] Connected to server at ${this.config.serverAddress}`);
+      return true;
+    } catch (e) {
+      console.error(`[SC-Client] Failed to connect: ${e}`);
+      return false;
+    }
+  }
+
+  /**
+   * Close the gRPC connection.
+   */
+  close(): void {
+    if (this.stream) {
+      this.stream.end();
+      this.stream = null;
+    }
+    if (this.client) {
+      grpc.closeClient(this.client);
+      this.client = null;
+    }
+  }
+
+  /**
+   * Process a single request.
+   */
+  private async processRequest(request: SmartContractRequest): Promise<SmartContractResponse> {
+    const logs = "";
+
+    try {
+      const result = await processTransaction(
+        request.transactionJson,
+        request.envVars,
+        request.secrets
+      );
+
+      const response: SmartContractResponse = {
+        transactionId: request.transactionId,
+        resultJson: result.data ? JSON.stringify(result.data) : "{}",
+        logs,
+        outputToChain: result.outputToChain,
+        error: result.error || "",
+      };
+
+      if (result.error) {
+        console.error(
+          `[SC-Client] Error processing transaction ${request.transactionId}: ${result.error}`
+        );
+      } else {
+        console.log(
+          `[SC-Client] Successfully processed transaction ${request.transactionId}`
+        );
+      }
+
+      return response;
+    } catch (e) {
+      console.error(
+        `[SC-Client] Exception processing transaction ${request.transactionId}: ${e}`
+      );
+      return {
+        transactionId: request.transactionId,
+        resultJson: "",
+        logs,
+        outputToChain: false,
+        error: String(e),
+      };
+    }
+  }
+
+  /**
+   * Run the client and process incoming requests.
+   */
+  async run(): Promise<boolean> {
+    if (!this.client) {
+      console.error("[SC-Client] Not connected to server");
+      return false;
+    }
+
+    this.running = true;
+
+    // Create metadata for authentication
+    const metadata = new grpc.Metadata();
+    metadata.add("x-api-key", this.config.apiKey);
+    metadata.add("x-smart-contract-id", this.config.smartContractId);
+
+    return new Promise((resolve) => {
+      // Establish bi-directional stream
+      this.stream = this.client.Run(metadata);
+
+      console.log(
+        `[SC-Client] Stream established, ready to process requests (workers: ${this.config.numWorkers})`
+      );
+
+      // Handle incoming requests
+      this.stream.on("data", async (request: SmartContractRequest) => {
+        if (!this.running) return;
+
+        console.log(
+          `[SC-Client] Received request: transaction_id=${request.transactionId}`
+        );
+
+        // Process with concurrency limit
+        if (this.processing.size >= this.config.numWorkers) {
+          this.workQueue.push(request);
+        } else {
+          this.startProcessing(request);
+        }
+      });
+
+      this.stream.on("end", () => {
+        console.log("[SC-Client] Server closed the stream");
+        this.running = false;
+        resolve(true);
+      });
+
+      this.stream.on("error", (err: grpc.ServiceError) => {
+        console.error(`[SC-Client] Stream error: ${err.code} - ${err.message}`);
+        this.running = false;
+        resolve(false);
+      });
+    });
+  }
+
+  /**
+   * Start processing a request with concurrency tracking.
+   */
+  private async startProcessing(request: SmartContractRequest): Promise<void> {
+    this.processing.add(request.transactionId);
+
+    try {
+      const response = await this.processRequest(request);
+      if (this.stream && this.running) {
+        this.stream.write(response);
+      }
+    } finally {
+      this.processing.delete(request.transactionId);
+
+      // Process next queued request if any
+      if (this.workQueue.length > 0 && this.running) {
+        const next = this.workQueue.shift()!;
+        this.startProcessing(next);
+      }
+    }
+  }
+
+  /**
+   * Stop the client gracefully.
+   */
+  stop(): void {
+    console.log("[SC-Client] Stopping client...");
+    this.running = false;
+  }
+}
+
+// =============================================================================
+// Configuration Loading
+// =============================================================================
+
+interface RawConfig {
+  server_address: string;
+  smart_contract_id: string;
+  api_key: string;
+  use_tls?: boolean;
+  tls_cert_path?: string;
+  num_workers?: number;
+  reconnect_delay_seconds?: number;
+  max_reconnect_attempts?: number;
+}
+
+function loadConfig(configPath: string): Config {
+  const content = fs.readFileSync(configPath, "utf8");
+  const raw = yaml.load(content) as RawConfig;
+
+  // Validate required fields
+  const required = ["server_address", "smart_contract_id", "api_key"];
+  for (const field of required) {
+    if (!(field in raw) || !raw[field as keyof RawConfig]) {
+      throw new Error(`Missing required config field: ${field}`);
+    }
+  }
+
+  return {
+    serverAddress: raw.server_address,
+    smartContractId: raw.smart_contract_id,
+    apiKey: raw.api_key,
+    useTls: raw.use_tls ?? false,
+    tlsCertPath: raw.tls_cert_path,
+    numWorkers: raw.num_workers ?? 10,
+    reconnectDelaySeconds: raw.reconnect_delay_seconds ?? 5,
+    maxReconnectAttempts: raw.max_reconnect_attempts ?? 0,
+  };
+}
+
+// =============================================================================
+// Main Entry Point
+// =============================================================================
+
+async function main(): Promise<void> {
+  // Parse command line arguments
+  const args = process.argv.slice(2);
+  let configPath = "config.yaml";
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--config" || args[i] === "-c") {
+      configPath = args[i + 1];
+      i++;
+    }
+  }
+
+  // Load configuration
+  let config: Config;
+  try {
+    config = loadConfig(configPath);
+  } catch (e) {
+    console.error(`[SC-Client] Failed to load config: ${e}`);
+    process.exit(1);
+  }
+
+  // Create client
+  const client = new SmartContractClient(config);
+
+  // Setup signal handling for graceful shutdown
+  const shutdown = () => {
+    console.log("[SC-Client] Received shutdown signal...");
+    client.stop();
+  };
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  // Connection loop with reconnection logic
+  let attempts = 0;
+
+  while (true) {
+    if (client.connect()) {
+      attempts = 0;
+      const success = await client.run();
+      if (!success) {
+        // Check if it was a graceful shutdown
+        client.close();
+        break;
+      }
+    }
+
+    client.close();
+
+    attempts++;
+    if (
+      config.maxReconnectAttempts > 0 &&
+      attempts >= config.maxReconnectAttempts
+    ) {
+      console.error(
+        `[SC-Client] Max reconnection attempts (${config.maxReconnectAttempts}) reached`
+      );
+      break;
+    }
+
+    const delay = config.reconnectDelaySeconds;
+    console.log(
+      `[SC-Client] Reconnecting in ${delay} seconds (attempt ${attempts})...`
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, delay * 1000));
+  }
+
+  console.log("[SC-Client] Client shut down");
+}
+
+main().catch((e) => {
+  console.error(`[SC-Client] Fatal error: ${e}`);
+  process.exit(1);
+});
--- a/typescript/src/process.ts
+++ b/typescript/src/process.ts
@@ -0,0 +1,112 @@
+/**
+ * Smart Contract Processing Logic
+ *
+ * This file contains the transaction processing logic for your smart contract.
+ * Modify the `processTransaction` function to implement your business logic.
+ */
+
+// =============================================================================
+// SMART CONTRACT IMPLEMENTATION - MODIFY THIS FILE
+// =============================================================================
+
+/**
+ * Transaction header metadata from Dragonchain.
+ */
+export interface TransactionHeader {
+  tag: string;
+  dc_id: string;
+  txn_id: string;
+  block_id: string;
+  txn_type: string;
+  timestamp: string;
+  invoker: string;
+}
+
+/**
+ * Parsed transaction from the server.
+ * Customize this interface to match your transaction payload structure.
+ */
+export interface Transaction {
+  version: string;
+  header: TransactionHeader;
+  payload: Record<string, unknown>;
+}
+
+/**
+ * Result from the processTransaction function.
+ */
+export interface ProcessResult {
+  data?: Record<string, unknown>;
+  outputToChain: boolean;
+  error?: string;
+}
+
+/**
+ * Process an incoming transaction.
+ *
+ * Implement your smart contract logic here.
+ *
+ * @param txJson - Raw transaction JSON string
+ * @param envVars - Environment variables passed from the server
+ * @param secrets - Secrets passed from the server (e.g., API keys, credentials)
+ * @returns ProcessResult containing the result data, whether to output to chain, and any error
+ */
+export async function processTransaction(
+  txJson: string,
+  envVars: Record<string, string>,
+  secrets: Record<string, string>
+): Promise<ProcessResult> {
+  // Parse the transaction JSON
+  let tx: Transaction;
+  try {
+    tx = JSON.parse(txJson);
+  } catch (e) {
+    return {
+      outputToChain: false,
+      error: `Failed to parse transaction: ${e}`,
+    };
+  }
+
+  // ==========================================================================
+  // TODO: Implement your smart contract logic here
+  // ==========================================================================
+  //
+  // Example: Access transaction data
+  // const txnId = tx.header.txn_id;
+  // const txnType = tx.header.txn_type;
+  // const payload = tx.payload;
+  //
+  // Example: Access environment variables
+  // const scName = envVars["SMART_CONTRACT_NAME"];
+  // const dcId = envVars["DRAGONCHAIN_ID"];
+  //
+  // Example: Access secrets
+  // const apiKey = secrets["SC_SECRET_MY_API_KEY"];
+  //
+  // Example: Process based on payload action
+  // const action = tx.payload.action as string;
+  // switch (action) {
+  //   case "create":
+  //     // Handle create operation
+  //     break;
+  //   case "update":
+  //     // Handle update operation
+  //     break;
+  //   default:
+  //     return { outputToChain: false, error: `Unknown action: ${action}` };
+  // }
+
+  // Default implementation: echo back the transaction
+  const result = {
+    status: "processed",
+    transaction_id: tx.header.txn_id,
+    txn_type: tx.header.txn_type,
+    payload: tx.payload,
+    message: "Transaction processed successfully",
+  };
+
+  return {
+    data: result,
+    outputToChain: true,
+  };
+}
--- a/typescript/tsconfig.json
+++ b/typescript/tsconfig.json
@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}