@lfdecentralizedtrust/paladin-sdk 0.13.0-rc.1

package/build/domains/noto.d.ts

@@ -0,0 +1,117 @@
+import { ethers } from "ethers";
+import PaladinClient from "../paladin";
+import { TransactionFuture } from "../transaction";
+import { PaladinVerifier } from "../verifier";
+export declare const notoConstructorABI: (withHooks: boolean) => ethers.JsonFragment;
+export interface IGroupInfo {
+    salt: string;
+    members: string[];
+}
+export interface NotoConstructorParams {
+    name?: string;
+    symbol?: string;
+    notary: PaladinVerifier;
+    notaryMode: "basic" | "hooks";
+    options?: {
+        basic?: {
+            restrictMint: boolean;
+            allowBurn: boolean;
+            allowLock: boolean;
+        };
+        hooks?: {
+            publicAddress: string;
+            privateGroup?: IGroupInfo;
+            privateAddress?: string;
+        };
+    };
+}
+export interface NotoMintParams {
+    to: PaladinVerifier;
+    amount: string | number;
+    data: string;
+}
+export interface NotoBurnParams {
+    amount: string | number;
+    data: string;
+}
+export interface NotoBurnFromParams {
+    from: PaladinVerifier;
+    amount: string | number;
+    data: string;
+}
+export interface NotoTransferParams {
+    to: PaladinVerifier;
+    amount: string | number;
+    data: string;
+}
+export interface NotoTransferFromParams {
+    from: PaladinVerifier;
+    to: PaladinVerifier;
+    amount: string | number;
+    data: string;
+}
+export interface NotoLockParams {
+    amount: string | number;
+    data: string;
+}
+export interface NotoUnlockParams {
+    lockId: string;
+    from: PaladinVerifier;
+    recipients: UnlockRecipient[];
+    data: string;
+}
+export interface UnlockRecipient {
+    to: PaladinVerifier;
+    amount: string | number;
+}
+export interface NotoDelegateLockParams {
+    lockId: string;
+    unlock: NotoUnlockPublicParams;
+    delegate: string;
+    data: string;
+}
+export interface NotoUnlockPublicParams {
+    txId: string;
+    lockedInputs: string[];
+    lockedOutputs: string[];
+    outputs: string[];
+    signature: string;
+    data: string;
+}
+export interface NotoBalanceOfParams {
+    account: string;
+}
+export interface NotoBalanceOfResult {
+    totalBalance: string;
+    totalStates: string;
+    overflow: boolean;
+}
+export declare class NotoFuture extends TransactionFuture {
+    waitForDeploy(waitMs?: number): Promise<NotoInstance | undefined>;
+}
+export declare class NotoFactory {
+    private paladin;
+    readonly domain: string;
+    constructor(paladin: PaladinClient, domain: string);
+    using(paladin: PaladinClient): NotoFactory;
+    newNoto(from: PaladinVerifier, data: NotoConstructorParams): NotoFuture;
+}
+export declare class NotoInstance {
+    private paladin;
+    readonly address: string;
+    constructor(paladin: PaladinClient, address: string);
+    using(paladin: PaladinClient): NotoInstance;
+    mint(from: PaladinVerifier, data: NotoMintParams): TransactionFuture;
+    transfer(from: PaladinVerifier, data: NotoTransferParams): TransactionFuture;
+    transferFrom(from: PaladinVerifier, data: NotoTransferFromParams): TransactionFuture;
+    prepareTransfer(from: PaladinVerifier, data: NotoTransferParams): Promise<string>;
+    burn(from: PaladinVerifier, data: NotoBurnParams): TransactionFuture;
+    burnFrom(from: PaladinVerifier, data: NotoBurnFromParams): TransactionFuture;
+    lock(from: PaladinVerifier, data: NotoLockParams): TransactionFuture;
+    unlock(from: PaladinVerifier, data: NotoUnlockParams): TransactionFuture;
+    unlockAsDelegate(from: PaladinVerifier, data: NotoUnlockPublicParams): TransactionFuture;
+    prepareUnlock(from: PaladinVerifier, data: NotoUnlockParams): TransactionFuture;
+    delegateLock(from: PaladinVerifier, data: NotoDelegateLockParams): TransactionFuture;
+    encodeUnlock(data: NotoUnlockPublicParams): string;
+    balanceOf(from: PaladinVerifier, data: NotoBalanceOfParams): Promise<NotoBalanceOfResult>;
+}

package/build/domains/noto.js

@@ -0,0 +1,292 @@
+"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.NotoInstance = exports.NotoFactory = exports.NotoFuture = exports.notoConstructorABI = void 0;
+const ethers_1 = require("ethers");
+const interfaces_1 = require("../interfaces");
+const transaction_1 = require("../transaction");
+const notoJSON = __importStar(require("./abis/INoto.json"));
+const notoPrivateJSON = __importStar(require("./abis/INotoPrivate.json"));
+const notoConstructorABI = (withHooks) => ({
+    type: "constructor",
+    inputs: [
+        { name: "name", type: "string" },
+        { name: "symbol", type: "string" },
+        { name: "notary", type: "string" },
+        { name: "notaryMode", type: "string" },
+        {
+            name: "options",
+            type: "tuple",
+            components: [
+                ...(withHooks
+                    ? [
+                        {
+                            name: "hooks",
+                            type: "tuple",
+                            components: [
+                                {
+                                    name: "privateGroup",
+                                    type: "tuple",
+                                    components: [
+                                        { name: "salt", type: "bytes32" },
+                                        { name: "members", type: "string[]" },
+                                    ],
+                                },
+                                { name: "publicAddress", type: "address" },
+                                { name: "privateAddress", type: "address" },
+                            ],
+                        },
+                    ]
+                    : [
+                        {
+                            name: "basic",
+                            type: "tuple",
+                            components: [
+                                { name: "restrictMint", type: "bool" },
+                                { name: "allowBurn", type: "bool" },
+                                { name: "allowLock", type: "bool" },
+                            ],
+                        },
+                    ]),
+            ],
+        },
+    ],
+});
+exports.notoConstructorABI = notoConstructorABI;
+// Represents an in-flight Noto deployment
+class NotoFuture extends transaction_1.TransactionFuture {
+    async waitForDeploy(waitMs) {
+        const receipt = await this.waitForReceipt(waitMs);
+        return receipt?.contractAddress
+            ? new NotoInstance(this.paladin, receipt.contractAddress)
+            : undefined;
+    }
+}
+exports.NotoFuture = NotoFuture;
+class NotoFactory {
+    constructor(paladin, domain) {
+        this.paladin = paladin;
+        this.domain = domain;
+    }
+    using(paladin) {
+        return new NotoFactory(paladin, this.domain);
+    }
+    newNoto(from, data) {
+        return new NotoFuture(this.paladin, this.paladin.ptx.sendTransaction({
+            type: interfaces_1.TransactionType.PRIVATE,
+            domain: this.domain,
+            abi: [(0, exports.notoConstructorABI)(!!data.options?.hooks)],
+            function: "",
+            from: from.lookup,
+            data: {
+                ...data,
+                name: data.name ?? "",
+                symbol: data.symbol ?? "",
+                notary: data.notary.lookup,
+                options: {
+                    basic: {
+                        restrictMint: true,
+                        allowBurn: true,
+                        allowLock: true,
+                        ...data.options?.basic,
+                    },
+                    ...data.options,
+                },
+            },
+        }));
+    }
+}
+exports.NotoFactory = NotoFactory;
+class NotoInstance {
+    constructor(paladin, address) {
+        this.paladin = paladin;
+        this.address = address;
+    }
+    using(paladin) {
+        return new NotoInstance(paladin, this.address);
+    }
+    mint(from, data) {
+        return new transaction_1.TransactionFuture(this.paladin, this.paladin.sendTransaction({
+            type: interfaces_1.TransactionType.PRIVATE,
+            abi: notoPrivateJSON.abi,
+            function: "mint",
+            to: this.address,
+            from: from.lookup,
+            data: {
+                ...data,
+                to: data.to.lookup,
+            },
+        }));
+    }
+    transfer(from, data) {
+        return new transaction_1.TransactionFuture(this.paladin, this.paladin.sendTransaction({
+            type: interfaces_1.TransactionType.PRIVATE,
+            abi: notoPrivateJSON.abi,
+            function: "transfer",
+            to: this.address,
+            from: from.lookup,
+            data: {
+                ...data,
+                to: data.to.lookup,
+            },
+        }));
+    }
+    transferFrom(from, data) {
+        return new transaction_1.TransactionFuture(this.paladin, this.paladin.sendTransaction({
+            type: interfaces_1.TransactionType.PRIVATE,
+            abi: notoPrivateJSON.abi,
+            function: "transferFrom",
+            to: this.address,
+            from: from.lookup,
+            data: {
+                ...data,
+                from: data.from.lookup,
+                to: data.to.lookup,
+            },
+        }));
+    }
+    prepareTransfer(from, data) {
+        return this.paladin.prepareTransaction({
+            type: interfaces_1.TransactionType.PRIVATE,
+            abi: notoPrivateJSON.abi,
+            function: "transfer",
+            to: this.address,
+            from: from.lookup,
+            data: {
+                ...data,
+                to: data.to.lookup,
+            },
+        });
+    }
+    burn(from, data) {
+        return new transaction_1.TransactionFuture(this.paladin, this.paladin.sendTransaction({
+            type: interfaces_1.TransactionType.PRIVATE,
+            abi: notoPrivateJSON.abi,
+            function: "burn",
+            to: this.address,
+            from: from.lookup,
+            data,
+        }));
+    }
+    burnFrom(from, data) {
+        return new transaction_1.TransactionFuture(this.paladin, this.paladin.sendTransaction({
+            type: interfaces_1.TransactionType.PRIVATE,
+            abi: notoPrivateJSON.abi,
+            function: "burnFrom",
+            to: this.address,
+            from: from.lookup,
+            data: {
+                ...data,
+                from: data.from.lookup,
+            }
+        }));
+    }
+    lock(from, data) {
+        return new transaction_1.TransactionFuture(this.paladin, this.paladin.sendTransaction({
+            type: interfaces_1.TransactionType.PRIVATE,
+            abi: notoPrivateJSON.abi,
+            function: "lock",
+            to: this.address,
+            from: from.lookup,
+            data,
+        }));
+    }
+    unlock(from, data) {
+        return new transaction_1.TransactionFuture(this.paladin, this.paladin.sendTransaction({
+            type: interfaces_1.TransactionType.PRIVATE,
+            abi: notoPrivateJSON.abi,
+            function: "unlock",
+            to: this.address,
+            from: from.lookup,
+            data: {
+                ...data,
+                from: data.from.lookup,
+                recipients: data.recipients.map((recipient) => ({
+                    to: recipient.to.lookup,
+                    amount: recipient.amount,
+                })),
+            },
+        }));
+    }
+    unlockAsDelegate(from, data) {
+        return new transaction_1.TransactionFuture(this.paladin, this.paladin.sendTransaction({
+            type: interfaces_1.TransactionType.PUBLIC,
+            abi: notoJSON.abi,
+            function: "unlock",
+            to: this.address,
+            from: from.lookup,
+            data,
+        }));
+    }
+    prepareUnlock(from, data) {
+        return new transaction_1.TransactionFuture(this.paladin, this.paladin.sendTransaction({
+            type: interfaces_1.TransactionType.PRIVATE,
+            abi: notoPrivateJSON.abi,
+            function: "prepareUnlock",
+            to: this.address,
+            from: from.lookup,
+            data: {
+                ...data,
+                from: data.from.lookup,
+                recipients: data.recipients.map((recipient) => ({
+                    to: recipient.to.lookup,
+                    amount: recipient.amount,
+                })),
+            },
+        }));
+    }
+    delegateLock(from, data) {
+        return new transaction_1.TransactionFuture(this.paladin, this.paladin.sendTransaction({
+            type: interfaces_1.TransactionType.PRIVATE,
+            abi: notoPrivateJSON.abi,
+            function: "delegateLock",
+            to: this.address,
+            from: from.lookup,
+            data,
+        }));
+    }
+    encodeUnlock(data) {
+        return new ethers_1.ethers.Interface(notoJSON.abi).encodeFunctionData("unlock", [
+            data.txId,
+            data.lockedInputs,
+            data.lockedOutputs,
+            data.outputs,
+            data.signature,
+            data.data,
+        ]);
+    }
+    balanceOf(from, data) {
+        return this.paladin.call({
+            type: interfaces_1.TransactionType.PRIVATE,
+            domain: "noto",
+            abi: notoPrivateJSON.abi,
+            function: "balanceOf",
+            to: this.address,
+            from: from.lookup,
+            data,
+        });
+    }
+}
+exports.NotoInstance = NotoInstance;

package/build/domains/pente.d.ts

@@ -0,0 +1,84 @@
+import { ethers } from "ethers";
+import { IPrivacyGroup, IPrivacyGroupEVMCall, IPrivacyGroupEVMTXInput, IPrivacyGroupResume } from "../interfaces/privacygroups";
+import PaladinClient from "../paladin";
+import { TransactionFuture } from "../transaction";
+import { PaladinVerifier } from "../verifier";
+export interface PenteGroupTransactionInput {
+    from: string;
+    methodAbi: ethers.JsonFragment;
+    to: string;
+    data: {
+        [key: string]: any;
+    };
+}
+export interface PenteContractTransactionInput {
+    from: string;
+    function: string;
+    data?: {
+        [key: string]: any;
+    };
+}
+export interface PenteDeploy {
+    abi: ReadonlyArray<ethers.JsonFragment>;
+    bytecode: string;
+    from: string;
+    inputs?: any;
+}
+export interface PentePrivacyGroupParams {
+    name?: string;
+    members: (string | PaladinVerifier)[];
+    salt?: string;
+    evmVersion?: string;
+    endorsementType?: string;
+    externalCallsEnabled?: boolean;
+    additionalProperties?: {
+        [x: string]: unknown;
+    };
+}
+export interface PenteApproveTransitionParams {
+    txId: string;
+    delegate: string;
+    transitionHash: string;
+    signatures: string[];
+}
+export declare class PentePrivacyGroupFuture {
+    private paladin;
+    private group;
+    tx: Promise<TransactionFuture | undefined>;
+    constructor(paladin: PaladinClient, group: IPrivacyGroup | Promise<IPrivacyGroup>);
+    waitForReceipt(waitMs?: number, full?: boolean): Promise<import("../interfaces").ITransactionReceipt | undefined>;
+    waitForDeploy(waitMs?: number): Promise<PentePrivacyGroup | undefined>;
+}
+export declare class PenteFactory {
+    private paladin;
+    readonly domain: string;
+    constructor(paladin: PaladinClient, domain: string);
+    using(paladin: PaladinClient): PenteFactory;
+    newPrivacyGroup(input: PentePrivacyGroupParams): PentePrivacyGroupFuture;
+    resumePrivacyGroup(input: IPrivacyGroupResume): Promise<PentePrivacyGroup | undefined>;
+}
+export declare class PentePrivacyGroup {
+    private paladin;
+    readonly group: IPrivacyGroup;
+    readonly address: string;
+    readonly salt: string;
+    readonly members: string[];
+    constructor(paladin: PaladinClient, group: IPrivacyGroup);
+    using(paladin: PaladinClient): PentePrivacyGroup;
+    deploy(params: PenteDeploy, txOptions?: Partial<IPrivacyGroupEVMTXInput>): PentePrivateDeployFuture;
+    sendTransaction(transaction: PenteGroupTransactionInput, txOptions?: Partial<IPrivacyGroupEVMTXInput>): TransactionFuture;
+    call(transaction: PenteGroupTransactionInput, txOptions?: Partial<IPrivacyGroupEVMCall>): Promise<any>;
+    approveTransition(from: PaladinVerifier, data: PenteApproveTransitionParams): TransactionFuture;
+}
+export declare class PentePrivateDeployFuture extends TransactionFuture {
+    waitForDeploy(waitMs?: number): Promise<string | undefined>;
+}
+export declare abstract class PentePrivateContract<ConstructorParams> {
+    protected evm: PentePrivacyGroup;
+    protected abi: ReadonlyArray<ethers.JsonFragment>;
+    readonly address: string;
+    constructor(evm: PentePrivacyGroup, abi: ReadonlyArray<ethers.JsonFragment>, address: string);
+    abstract using(paladin: PaladinClient): PentePrivateContract<ConstructorParams>;
+    sendTransaction(transaction: PenteContractTransactionInput, txOptions?: Partial<IPrivacyGroupEVMTXInput>): TransactionFuture;
+    call(transaction: PenteContractTransactionInput, txOptions?: Partial<IPrivacyGroupEVMCall>): Promise<any>;
+}

package/build/domains/pente.js

@@ -0,0 +1,191 @@
+"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.PentePrivateContract = exports.PentePrivateDeployFuture = exports.PentePrivacyGroup = exports.PenteFactory = exports.PentePrivacyGroupFuture = void 0;
+const interfaces_1 = require("../interfaces");
+const transaction_1 = require("../transaction");
+const penteJSON = __importStar(require("./abis/PentePrivacyGroup.json"));
+// Represents an in-flight Pente privacy group deployment
+class PentePrivacyGroupFuture {
+    constructor(paladin, group) {
+        this.paladin = paladin;
+        this.group = group;
+        this.tx = Promise.resolve(group).then((group) => group.genesisTransaction
+            ? new transaction_1.TransactionFuture(paladin, group.genesisTransaction)
+            : undefined);
+    }
+    async waitForReceipt(waitMs, full = false) {
+        const tx = await this.tx;
+        return tx?.waitForReceipt(waitMs, full);
+    }
+    async waitForDeploy(waitMs) {
+        const group = await this.group;
+        const receipt = await this.waitForReceipt(waitMs);
+        group.contractAddress = receipt?.contractAddress;
+        return group.contractAddress
+            ? new PentePrivacyGroup(this.paladin, group)
+            : undefined;
+    }
+}
+exports.PentePrivacyGroupFuture = PentePrivacyGroupFuture;
+class PenteFactory {
+    constructor(paladin, domain) {
+        this.paladin = paladin;
+        this.domain = domain;
+    }
+    using(paladin) {
+        return new PenteFactory(paladin, this.domain);
+    }
+    newPrivacyGroup(input) {
+        return new PentePrivacyGroupFuture(this.paladin, this.paladin.pgroup.createGroup({
+            domain: this.domain,
+            name: input.name,
+            members: input.members.map((m) => m.toString()),
+            configuration: {
+                evmVersion: input.evmVersion,
+                endorsementType: input.endorsementType,
+                externalCallsEnabled: input.externalCallsEnabled === true
+                    ? "true"
+                    : input.externalCallsEnabled === false
+                        ? "false"
+                        : undefined,
+            },
+        }));
+    }
+    async resumePrivacyGroup(input) {
+        const existingGroup = await this.paladin.getPrivacyGroupById(this.domain, input.id);
+        return existingGroup?.contractAddress
+            ? new PentePrivacyGroup(this.paladin, existingGroup)
+            : undefined;
+    }
+}
+exports.PenteFactory = PenteFactory;
+class PentePrivacyGroup {
+    constructor(paladin, group) {
+        this.paladin = paladin;
+        this.group = group;
+        if (group.contractAddress === undefined) {
+            throw new Error(`Supplied group '${group.id}' is missing a contract address. Check transaction ${group.genesisTransaction}`);
+        }
+        this.address = group.contractAddress;
+        this.salt = group.id; // when bypassing privacy group helper functionality, and directly building Pente private transactions
+        this.members = group.members;
+    }
+    using(paladin) {
+        return new PentePrivacyGroup(paladin, this.group);
+    }
+    deploy(params, txOptions) {
+        // Find the constructor in the ABI
+        const constructor = params.abi.find((entry) => entry.type === "constructor") || { type: "constructor", inputs: [] };
+        const transaction = {
+            ...txOptions,
+            domain: this.group.domain,
+            group: this.group.id,
+            from: params.from,
+            input: params.inputs,
+            bytecode: params.bytecode,
+            function: constructor,
+        };
+        return new PentePrivateDeployFuture(this.paladin, this.paladin.sendPrivacyGroupTransaction(transaction));
+    }
+    // sendTransaction functions in the contract (write)
+    sendTransaction(transaction, txOptions) {
+        return new transaction_1.TransactionFuture(this.paladin, this.paladin.sendPrivacyGroupTransaction({
+            ...txOptions,
+            domain: this.group.domain,
+            group: this.group.id,
+            from: transaction.from,
+            to: transaction.to,
+            input: transaction.data,
+            function: transaction.methodAbi,
+        }));
+    }
+    // call functions in the contract (read-only)
+    async call(transaction, txOptions) {
+        return this.paladin.callPrivacyGroup({
+            ...txOptions,
+            domain: this.group.domain,
+            group: this.group.id,
+            from: transaction.from || "sdk.default",
+            to: transaction.to,
+            input: transaction.data,
+            function: transaction.methodAbi,
+        });
+    }
+    approveTransition(from, data) {
+        return new transaction_1.TransactionFuture(this.paladin, this.paladin.sendTransaction({
+            type: interfaces_1.TransactionType.PUBLIC,
+            abi: penteJSON.abi,
+            function: "approveTransition",
+            to: this.address,
+            from: from.lookup,
+            data,
+        }));
+    }
+}
+exports.PentePrivacyGroup = PentePrivacyGroup;
+// Represents an in-flight contract deployment within a privacy group
+class PentePrivateDeployFuture extends transaction_1.TransactionFuture {
+    async waitForDeploy(waitMs) {
+        const receipt = await this.waitForReceipt(waitMs, true);
+        return receipt?.domainReceipt !== undefined &&
+            "receipt" in receipt.domainReceipt
+            ? receipt.domainReceipt.receipt.contractAddress
+            : undefined;
+    }
+}
+exports.PentePrivateDeployFuture = PentePrivateDeployFuture;
+class PentePrivateContract {
+    constructor(evm, abi, address) {
+        this.evm = evm;
+        this.abi = abi;
+        this.address = address;
+    }
+    sendTransaction(transaction, txOptions) {
+        const method = this.abi.find((entry) => entry.name === transaction.function);
+        if (method === undefined) {
+            throw new Error(`Method '${transaction.function}' not found`);
+        }
+        return this.evm.sendTransaction({
+            from: transaction.from,
+            to: this.address,
+            methodAbi: method,
+            data: transaction.data ?? [],
+        }, txOptions);
+    }
+    call(transaction, txOptions) {
+        const method = this.abi.find((entry) => entry.name === transaction.function);
+        if (method === undefined) {
+            throw new Error(`Method '${transaction.function}' not found`);
+        }
+        return this.evm.call({
+            from: transaction.from,
+            to: this.address,
+            methodAbi: method,
+            data: transaction.data ?? [],
+        }, txOptions);
+    }
+}
+exports.PentePrivateContract = PentePrivateContract;