@lfdecentralizedtrust/paladin-sdk 0.13.0-rc.1

package/build/transaction.d.ts

@@ -0,0 +1,8 @@
+import PaladinClient from "./paladin";
+export declare class TransactionFuture {
+    protected paladin: PaladinClient;
+    readonly id: string | Promise<string>;
+    constructor(paladin: PaladinClient, id: string | Promise<string>);
+    toString(): string | Promise<string>;
+    waitForReceipt(waitMs?: number, full?: boolean): Promise<import("./interfaces").ITransactionReceipt | undefined>;
+}

package/build/transaction.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionFuture = void 0;
+// Represents an in-flight transaction
+class TransactionFuture {
+    constructor(paladin, id) {
+        this.paladin = paladin;
+        this.id = id;
+    }
+    toString() {
+        return this.id;
+    }
+    async waitForReceipt(waitMs = 5000, full = false) {
+        return this.paladin.pollForReceipt(await this.id, waitMs, full);
+    }
+}
+exports.TransactionFuture = TransactionFuture;

package/build/utils.d.ts

@@ -0,0 +1,5 @@
+import { IStateBase, IStateEncoded } from "./interfaces";
+export declare function encodeHex(data: string): string;
+export declare function decodeHex(data: string): string;
+export declare function newTransactionId(): string;
+export declare const encodeStates: (states: IStateBase[]) => IStateEncoded[];

package/build/utils.js

@@ -0,0 +1,49 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeStates = void 0;
+exports.encodeHex = encodeHex;
+exports.decodeHex = decodeHex;
+exports.newTransactionId = newTransactionId;
+const uuid = __importStar(require("uuid"));
+function encodeHex(data) {
+    return "0x" + Buffer.from(data, "utf8").toString("hex");
+}
+function decodeHex(data) {
+    return Buffer.from(data.slice(2), "hex").toString("utf8");
+}
+function newTransactionId() {
+    return encodeHex(uuid.v4()) + "00000000000000000000000000000000";
+}
+const encodeStates = (states) => {
+    return states.map((state) => ({
+        id: state.id,
+        domain: state.domain,
+        schema: state.schema,
+        contractAddress: state.contractAddress,
+        data: encodeHex(JSON.stringify(state.data)),
+    }));
+};
+exports.encodeStates = encodeStates;

package/build/verifier.d.ts

@@ -0,0 +1,16 @@
+import { Algorithms, Verifiers } from "./interfaces";
+import PaladinClient from "./paladin";
+export declare class PaladinVerifier {
+    private paladin;
+    readonly lookup: string;
+    constructor(paladin: PaladinClient, lookup: string);
+    toString(): string;
+    split(): {
+        0: string;
+        1: string;
+        identity: string;
+        node: string;
+    };
+    resolve(algorithm: Algorithms, verifierType: Verifiers): Promise<string>;
+    address(): Promise<string>;
+}

package/build/verifier.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaladinVerifier = void 0;
+const interfaces_1 = require("./interfaces");
+class PaladinVerifier {
+    constructor(paladin, lookup) {
+        this.paladin = paladin;
+        this.lookup = lookup;
+    }
+    toString() {
+        return this.lookup;
+    }
+    split() {
+        const [identity, node] = this.lookup.split("@");
+        return { 0: identity, 1: node, identity, node };
+    }
+    resolve(algorithm, verifierType) {
+        return this.paladin.ptx.resolveVerifier(this.lookup, algorithm, verifierType);
+    }
+    address() {
+        return this.resolve(interfaces_1.Algorithms.ECDSA_SECP256K1, interfaces_1.Verifiers.ETH_ADDRESS);
+    }
+}
+exports.PaladinVerifier = PaladinVerifier;

package/build/websocket.d.ts

@@ -0,0 +1,35 @@
+import { PrivacyGroupWebSocketEvent, WebSocketClientOptions, WebSocketEvent, WebSocketEventCallback } from "./interfaces/websocket";
+declare abstract class PaladinWebSocketClientBase<TMessageTypes extends string, TEvent> {
+    private options;
+    private callback;
+    private logger;
+    private socket;
+    private closed?;
+    private pingTimer?;
+    private disconnectTimer?;
+    private reconnectTimer?;
+    private disconnectDetected;
+    private counter;
+    constructor(options: WebSocketClientOptions<TMessageTypes>, callback: WebSocketEventCallback<TEvent>);
+    private connect;
+    private clearPingTimers;
+    private schedulePing;
+    private reconnect;
+    send(json: object): void;
+    sendRpc(method: string, params: any[]): void;
+    close(wait?: boolean): Promise<void>;
+    abstract subscribe(type: TMessageTypes, name: string): void;
+    abstract ack(subscription: string): void;
+    abstract nack(subscription: string): void;
+}
+export declare class PaladinWebSocketClient extends PaladinWebSocketClientBase<"receipts" | "blockchainevents", WebSocketEvent> {
+    subscribe(type: "receipts" | "blockchainevents", name: string): void;
+    ack(subscription: string): void;
+    nack(subscription: string): void;
+}
+export declare class PrivacyGroupWebSocketClient extends PaladinWebSocketClientBase<"messages", PrivacyGroupWebSocketEvent> {
+    subscribe(type: "messages", name: string): void;
+    ack(subscription: string): void;
+    nack(subscription: string): void;
+}
+export {};

package/build/websocket.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivacyGroupWebSocketClient = exports.PaladinWebSocketClient = void 0;
+const stream_1 = require("stream");
+const ws_1 = __importDefault(require("ws"));
+class PaladinWebSocketClientBase {
+    constructor(options, callback) {
+        this.options = options;
+        this.callback = callback;
+        this.closed = () => { };
+        this.disconnectDetected = false;
+        this.counter = 1;
+        this.logger = options.logger ?? console;
+        this.connect();
+    }
+    connect() {
+        // Ensure we've cleaned up any old socket
+        this.close();
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            delete this.reconnectTimer;
+        }
+        const auth = this.options.username && this.options.password
+            ? `${this.options.username}:${this.options.password}`
+            : undefined;
+        const socket = (this.socket = new ws_1.default(this.options.url, {
+            ...this.options.socketOptions,
+            auth,
+            handshakeTimeout: this.options.heartbeatInterval,
+        }));
+        this.closed = undefined;
+        socket
+            .on("open", () => {
+            if (this.disconnectDetected) {
+                this.disconnectDetected = false;
+                this.logger.log("Connection restored");
+            }
+            else {
+                this.logger.log("Connected");
+            }
+            this.schedulePing();
+            for (const sub of this.options.subscriptions ?? []) {
+                // Automatically connect subscriptions
+                this.subscribe(sub.type, sub.name);
+                this.logger.log(`Started listening on subscription ${sub.name}`);
+            }
+            if (this.options?.afterConnect !== undefined) {
+                this.options.afterConnect(this);
+            }
+        })
+            .on("error", (err) => {
+            this.logger.error("Error", err.stack);
+        })
+            .on("close", () => {
+            if (this.closed) {
+                this.logger.log("Closed");
+                this.closed(); // do this after all logging
+            }
+            else {
+                this.disconnectDetected = true;
+                this.reconnect("Closed by peer");
+            }
+        })
+            .on("pong", () => {
+            this.logger.debug && this.logger.debug(`WS received pong`);
+            this.schedulePing();
+        })
+            .on("unexpected-response", (req, res) => {
+            let responseData = "";
+            res.pipe(new stream_1.Transform({
+                transform(chunk, encoding, callback) {
+                    responseData += chunk;
+                    callback();
+                },
+                flush: () => {
+                    this.reconnect(`Websocket connect error [${res.statusCode}]: ${responseData}`);
+                },
+            }));
+        })
+            .on("message", (data) => {
+            const event = JSON.parse(data.toString());
+            this.callback(this, event);
+        });
+    }
+    clearPingTimers() {
+        if (this.disconnectTimer) {
+            clearTimeout(this.disconnectTimer);
+            delete this.disconnectTimer;
+        }
+        if (this.pingTimer) {
+            clearTimeout(this.pingTimer);
+            delete this.pingTimer;
+        }
+    }
+    schedulePing() {
+        this.clearPingTimers();
+        const heartbeatInterval = this.options.heartbeatInterval ?? 30000;
+        this.disconnectTimer = setTimeout(() => this.reconnect("Heartbeat timeout"), Math.ceil(heartbeatInterval * 1.5) // 50% grace period
+        );
+        this.pingTimer = setTimeout(() => {
+            this.logger.debug && this.logger.debug(`WS sending ping`);
+            this.socket?.ping("ping", true, (err) => {
+                if (err)
+                    this.reconnect(err.message);
+            });
+        }, heartbeatInterval);
+    }
+    reconnect(msg) {
+        if (!this.reconnectTimer) {
+            this.close();
+            this.logger.error(`Websocket closed: ${msg}`);
+            if (this.options.reconnectDelay === -1) {
+                // do not attempt to reconnect
+            }
+            else {
+                this.reconnectTimer = setTimeout(() => this.connect(), this.options.reconnectDelay ?? 5000);
+            }
+        }
+    }
+    send(json) {
+        if (this.socket !== undefined) {
+            this.socket.send(JSON.stringify(json));
+        }
+    }
+    sendRpc(method, params) {
+        this.send({
+            jsonrpc: "2.0",
+            id: this.counter++,
+            method,
+            params,
+        });
+    }
+    async close(wait) {
+        const closedPromise = new Promise((resolve) => {
+            this.closed = resolve;
+        });
+        this.clearPingTimers();
+        if (this.socket) {
+            try {
+                this.socket.close();
+            }
+            catch (e) {
+                this.logger.warn(`Failed to clean up websocket: ${e.message}`);
+            }
+            if (wait)
+                await closedPromise;
+            this.socket = undefined;
+        }
+    }
+}
+class PaladinWebSocketClient extends PaladinWebSocketClientBase {
+    subscribe(type, name) {
+        this.sendRpc("ptx_subscribe", [type, name]);
+    }
+    ack(subscription) {
+        this.sendRpc("ptx_ack", [subscription]);
+    }
+    nack(subscription) {
+        this.sendRpc("ptx_nack", [subscription]);
+    }
+}
+exports.PaladinWebSocketClient = PaladinWebSocketClient;
+class PrivacyGroupWebSocketClient extends PaladinWebSocketClientBase {
+    subscribe(type, name) {
+        this.sendRpc("pgroup_subscribe", [type, name]);
+    }
+    ack(subscription) {
+        this.sendRpc("pgroup_ack", [subscription]);
+    }
+    nack(subscription) {
+        this.sendRpc("pgroup_nack", [subscription]);
+    }
+}
+exports.PrivacyGroupWebSocketClient = PrivacyGroupWebSocketClient;

package/build.gradle

@@ -0,0 +1,75 @@
+/*
+ * Copyright © 2024 Kaleido, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+configurations {
+    // Resolvable configurations
+    contractCompile {
+        canBeConsumed = false
+        canBeResolved = true
+    }
+    zetoArtifacts {
+        canBeConsumed = false
+        canBeResolved = true
+    }
+
+    // Consumable configurations
+    buildSDK {
+        canBeConsumed = true
+        canBeResolved = false
+    }
+}
+
+dependencies {
+    contractCompile project(path: ":solidity", configuration: "compiledContracts")
+    zetoArtifacts project(path: ":domains:zeto", configuration: "zetoArtifacts")
+}
+
+task install(type: Exec) {
+    executable 'npm'
+    args 'install'
+
+    inputs.files("package.json")
+    outputs.files("package-lock.json")
+    outputs.dir("node_modules")
+}
+
+task copyABI(type: Exec, dependsOn: install) {
+    executable 'npm'
+    args 'run'
+    args 'abi'
+
+    inputs.files(configurations.contractCompile)
+    inputs.files(configurations.zetoArtifacts)
+    outputs.dir('src/domains/abis')
+}
+
+task build(type: Exec, dependsOn: [install, copyABI]) {
+    executable 'npm'
+    args 'run'
+    args 'build'
+
+    inputs.dir("src")
+    outputs.dir("build")
+}
+
+task clean(type: Delete) {
+    delete "node_modules"
+    delete "build"
+    delete "src/domains/abis"
+}
+
+dependencies {
+    buildSDK files(build)
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@lfdecentralizedtrust/paladin-sdk",
+  "version": "0.13.0-rc.1",
+  "description": "",
+  "main": "build/index.js",
+  "scripts": {
+    "build": "tsc",
+    "abi": "node scripts/abi.mjs",
+    "download-abi": "node scripts/contracts.mjs"
+  },
+  "author": "",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@types/node": "^22.9.0",
+    "@types/ws": "^8.18.0",
+    "copy-file": "^11.0.0",
+    "node-fetch": "^3.3.2",
+    "tar": "^7.4.3",
+    "typescript": "^5.6.3"
+  },
+  "dependencies": {
+    "ethers": "^6.13.4",
+    "uuid": "^11.0.2",
+    "ws": "^8.18.1"
+  },
+  "peerDependencies": {
+    "axios": "^1.7.7"
+  },
+  "repository": {
+    "url": "https://github.com/LFDT-Paladin/paladin"
+  }
+}

package/scripts/abi.mjs

@@ -0,0 +1,19 @@
+import { copyFile } from 'copy-file';
+import path from 'path';
+import { downloadZetoAbis } from './download.mjs';
+
+await copyFile('../../solidity/artifacts/contracts/domains/pente/PentePrivacyGroup.sol/PentePrivacyGroup.json', 'src/domains/abis/PentePrivacyGroup.json');
+
+await copyFile('../../solidity/artifacts/contracts/domains/interfaces/INoto.sol/INoto.json', 'src/domains/abis/INoto.json');
+
+await copyFile('../../solidity/artifacts/contracts/domains/interfaces/INotoPrivate.sol/INotoPrivate.json', 'src/domains/abis/INotoPrivate.json');
+
+await copyFile('../../solidity/artifacts/contracts/domains/interfaces/IZetoFungible.sol/IZetoFungible.json', 'src/domains/abis/IZetoFungible.json');
+
+// download the zeto anon contract ABI
+const tmpDir = await downloadZetoAbis();
+
+// copy the zeto anon contract ABI
+await copyFile(path.join(tmpDir, 'artifacts/contracts/zeto_anon.sol/Zeto_Anon.json'), 'src/domains/abis/Zeto_Anon.json');
+await copyFile(path.join(tmpDir, 'artifacts/contracts/lib/interfaces/izeto_kyc.sol/IZetoKyc.json'), 'src/domains/abis/IZetoKyc.json');
+await copyFile(path.join(tmpDir, 'artifacts/contracts/erc20.sol/SampleERC20.json'), 'src/domains/abis/SampleERC20.json');

package/scripts/contracts.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+import path from 'path';
+import { copyFile } from 'copy-file';
+import { downloadZetoAbis, downloadPaladinAbis } from './download.mjs';
+
+// download zeto and paladin abis and copy them to the contracts directory
+const zetoDir = await downloadZetoAbis();
+const paladinDir = await downloadPaladinAbis();
+
+// copy the zeto abis
+await copyFile(path.join(zetoDir, 'artifacts/contracts/zeto_anon.sol/Zeto_Anon.json'), 'src/domains/abis/Zeto_Anon.json');
+await copyFile(path.join(zetoDir, 'artifacts/contracts/lib/interfaces/izeto_kyc.sol/IZetoKyc.json'), 'src/domains/abis/IZetoKyc.json');
+await copyFile(path.join(zetoDir, 'artifacts/contracts/erc20.sol/SampleERC20.json'), 'src/domains/abis/SampleERC20.json');
+
+// copy the paladin abis
+await copyFile(path.join(paladinDir, 'abis/PentePrivacyGroup.json'), 'src/domains/abis/PentePrivacyGroup.json');
+await copyFile(path.join(paladinDir, 'abis/INoto.json'), 'src/domains/abis/INoto.json');
+await copyFile(path.join(paladinDir, 'abis/INotoPrivate.json'), 'src/domains/abis/INotoPrivate.json');
+await copyFile(path.join(paladinDir, 'abis/IZetoFungible.json'), 'src/domains/abis/IZetoFungible.json');

package/scripts/download.mjs

@@ -0,0 +1,27 @@
+// download the zeto contracts
+import { downloadFile, extractFile } from './util.mjs';
+
+export async function downloadZetoAbis(zetoVersion = 'v0.2.0') {
+
+    const zetoOrg = 'hyperledger-labs';
+    const filename = `zeto-contracts-${zetoVersion}.tar.gz`;
+    const url = `https://github.com/${zetoOrg}/zeto/releases/download/${zetoVersion}/${filename}`;
+    const tmpFilePath = await downloadFile(url, filename);
+    const tmpDir = await extractFile(tmpFilePath);
+    return tmpDir;
+}
+
+// download the paladin contracts
+export async function downloadPaladinAbis(paladinVersion = 'latest') {
+    const paladinOrg = 'LFDT-Paladin';
+    const filename = `abis.tar.gz`;
+    let url;
+    if (paladinVersion === "latest") {
+        url = `https://github.com/${paladinOrg}/paladin/releases/latest/download/${filename}`;
+    } else {
+        url = `https://github.com/${paladinOrg}/paladin/releases/download/${paladinVersion}/${filename}`;
+    }
+    const tmpFilePath = await downloadFile(url, filename);
+    const tmpDir = await extractFile(tmpFilePath, 'abis');
+    return tmpDir;
+}

package/scripts/util.mjs

@@ -0,0 +1,42 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import fetch from 'node-fetch';
+import * as tar from 'tar';
+
+export async function downloadFile(url, filename) {
+  try {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'paladin-sdk'));
+    const tmpFilePath = path.join(tmpDir, filename);
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const fileStream = fs.createWriteStream(tmpFilePath);
+    await new Promise((resolve, reject) => {
+      response.body.pipe(fileStream);
+      response.body.on('error', reject);
+      fileStream.on('finish', resolve);
+    });
+    console.log(`File downloaded successfully to: ${tmpFilePath}`);
+    return tmpFilePath;
+  } catch (error) {
+    console.error('Error downloading file:', error);
+  }
+}
+
+export async function extractFile(filePath, destinationDir) {
+  try {
+    let tmpDir = path.dirname(filePath); 
+    let fullPath = tmpDir;
+    if (destinationDir) {
+      fullPath = path.join(tmpDir, destinationDir);
+      fs.mkdirSync(fullPath, { recursive: true });
+    }
+    await tar.x({ file: filePath, C: fullPath });
+    console.log(`File extracted successfully to: ${fullPath}`);
+    return tmpDir;
+  } catch (error) {
+    console.error('Error extracting file:', error);
+  }
+}