@prktsol/prkt 1.0.0 → 1.0.1

package/dist/evm/adapters/UniswapV3Adapter.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UniswapV3Adapter = void 0;
+const ethers_1 = require("ethers");
+const PRKTError_1 = require("../../errors/PRKTError");
+const CHAINLINK_AGGREGATOR_ABI = [
+    "function decimals() view returns (uint8)",
+    "function latestRoundData() view returns (uint80,int256,uint256,uint256,uint80)"
+];
+const ERC20_ABI = [
+    "function approve(address spender, uint256 amount) returns (bool)",
+    "function decimals() view returns (uint8)",
+    "function transfer(address to, uint256 amount) returns (bool)"
+];
+const DEVNET_CHAINLINK_FEEDS = {
+    "sol-usd": "0xec852B2A009f49E4eE4ffEddeDcF81a1AD1bbD6d",
+    "usdc-usd": "0xedc0d80E85292fEf5B0946DEc957563Ceb7C8e6c"
+};
+const DEVNET_NEON_TOKENS = {
+    usdc: "0x512E48836Cd42F3eB6f50CEd9ffD81E0a7F15103",
+    wsol: "0xc7Fc9b46e479c5Cb42f6C458D1881e55E6B7986c"
+};
+class UniswapV3Adapter {
+    protocol = "uniswap-v3";
+    provider;
+    aggregatorInterface = new ethers_1.ethers.Interface(CHAINLINK_AGGREGATOR_ABI);
+    erc20Interface = new ethers_1.ethers.Interface(ERC20_ABI);
+    constructor(rpcEndpoint) {
+        this.provider = new ethers_1.ethers.JsonRpcProvider(rpcEndpoint);
+    }
+    async getQuote(tokenIn, tokenOut, amount) {
+        try {
+            const [tokenInDecimals, tokenOutDecimals] = await Promise.all([
+                this.readErc20Decimals(tokenIn),
+                this.readErc20Decimals(tokenOut)
+            ]);
+            const [priceIn, priceOut] = await Promise.all([
+                this.readPrice(this.resolveFeed(tokenIn)),
+                this.readPrice(this.resolveFeed(tokenOut))
+            ]);
+            return (amount *
+                priceIn.price *
+                10n ** BigInt(tokenOutDecimals)) / (10n ** BigInt(tokenInDecimals) *
+                priceOut.price);
+        }
+        catch (error) {
+            throw new PRKTError_1.EvmAdapterError(`Failed to get Uniswap V3 quote: ${error}`);
+        }
+    }
+    async simulate(transaction) {
+        return this.simulateTransaction(transaction);
+    }
+    async simulateSwap(params) {
+        const transaction = await this.buildSwapTransaction(params);
+        return this.simulateTransaction(transaction);
+    }
+    async swap(params) {
+        try {
+            const minAmountOut = await this.getQuote(params.tokenIn, params.tokenOut, params.amount);
+            const minimum = minAmountOut * BigInt(100 - params.slippage) / 100n;
+            const transaction = await this.buildSwapTransaction({
+                ...params,
+                amount: minimum
+            });
+            const simulation = await this.simulateTransaction(transaction);
+            if (!simulation.success) {
+                throw new PRKTError_1.EvmAdapterError(simulation.revertReason ?? "swap simulation failed");
+            }
+            return transaction;
+        }
+        catch (error) {
+            throw new PRKTError_1.EvmAdapterError(`Failed to build Uniswap V3 swap tx: ${error}`);
+        }
+    }
+    async buildSwapTransaction(params) {
+        const recipient = params.recipient ?? DEVNET_NEON_TOKENS.usdc;
+        const mode = params.simulationMode ?? "approval";
+        if (mode === "transfer") {
+            return {
+                data: this.erc20Interface.encodeFunctionData("transfer", [recipient, params.amount]),
+                from: params.from,
+                to: params.tokenIn,
+                value: 0n
+            };
+        }
+        return {
+            data: this.erc20Interface.encodeFunctionData("approve", [recipient, params.amount]),
+            from: params.from,
+            to: params.tokenIn,
+            value: 0n
+        };
+    }
+    async simulateTransaction(transaction) {
+        try {
+            await this.provider.call(transaction);
+            const gasEstimate = await this.provider.estimateGas(transaction);
+            return {
+                success: true,
+                gasEstimate
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                revertReason: error instanceof Error ? error.message : "eth_call reverted"
+            };
+        }
+    }
+    async readErc20Decimals(tokenAddress) {
+        const response = await this.provider.call({
+            data: this.erc20Interface.encodeFunctionData("decimals"),
+            to: tokenAddress
+        });
+        const [decimals] = this.erc20Interface.decodeFunctionResult("decimals", response);
+        return Number(decimals);
+    }
+    async readPrice(feedAddress) {
+        const [decimalsResponse, latestRoundDataResponse] = await Promise.all([
+            this.provider.call({
+                data: this.aggregatorInterface.encodeFunctionData("decimals"),
+                to: feedAddress
+            }),
+            this.provider.call({
+                data: this.aggregatorInterface.encodeFunctionData("latestRoundData"),
+                to: feedAddress
+            })
+        ]);
+        const [decimals] = this.aggregatorInterface.decodeFunctionResult("decimals", decimalsResponse);
+        const [, price] = this.aggregatorInterface.decodeFunctionResult("latestRoundData", latestRoundDataResponse);
+        return {
+            decimals: Number(decimals),
+            price: BigInt(price.toString())
+        };
+    }
+    resolveFeed(tokenAddress) {
+        const normalized = tokenAddress.toLowerCase();
+        if (normalized === DEVNET_NEON_TOKENS.wsol.toLowerCase()) {
+            return DEVNET_CHAINLINK_FEEDS["sol-usd"];
+        }
+        if (normalized === DEVNET_NEON_TOKENS.usdc.toLowerCase()) {
+            return DEVNET_CHAINLINK_FEEDS["usdc-usd"];
+        }
+        throw new PRKTError_1.EvmAdapterError(`No Neon devnet price feed configured for token ${tokenAddress}`);
+    }
+}
+exports.UniswapV3Adapter = UniswapV3Adapter;

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./core";
+export * from "./policy";
+export * from "./agent/new-index";
+export { SessionAnchor } from "./anchoring/SessionAnchor";
+export type { SessionCloseResult, SessionStartResult, SessionVerifyResult } from "./anchoring/SessionAnchor";
+export { PolicyAccountManager } from "./compression/PolicyAccountManager";
+export { AuditLogManager } from "./compression/AuditLogManager";
+export type { AuditEntry, CompressedPolicyState } from "./compression/types";
+export { defaultPRKTConfig } from "./config/PRKTConfig";
+export * from "./config/env";
+export * from "./onchain";
+export { UniversalDeFiOrchestrator } from "./defi/universal";
+export { PolicyCircuit, PolicyViolation } from "./zk/PolicyCircuit";
+export type { PolicyAttestation, PolicyProof } from "./zk/PolicyCircuit";
+export { ProofAnchor } from "./zk/ProofAnchor";

package/dist/index.js

@@ -1,22 +1,37 @@
 "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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const web3_js_1 = require("@solana/web3.js");
-const env_1 = require("./config/env");
-const WalletManager_1 = require("./wallet/WalletManager");
-async function main() {
-    const rpcUrl = (0, env_1.getRpcUrl)();
-    const connection = new web3_js_1.Connection(rpcUrl, "confirmed");
-    const walletManager = WalletManager_1.WalletManager.loadOrGenerate();
-    const { publicKey, source } = walletManager.toSafeSummary();
-    console.log("PRKT wallet ready.");
-    console.log(`RPC: ${rpcUrl}`);
-    console.log(`Wallet source: ${source}`);
-    console.log(`Devnet public key: ${publicKey}`);
-    const balanceLamports = await connection.getBalance(walletManager.publicKey);
-    console.log(`Devnet balance (lamports): ${balanceLamports}`);
-}
-main().catch((error) => {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    console.error(`Startup failed: ${message}`);
-    process.exitCode = 1;
-});
+exports.ProofAnchor = exports.PolicyViolation = exports.PolicyCircuit = exports.UniversalDeFiOrchestrator = exports.defaultPRKTConfig = exports.AuditLogManager = exports.PolicyAccountManager = exports.SessionAnchor = void 0;
+__exportStar(require("./core"), exports);
+__exportStar(require("./policy"), exports);
+__exportStar(require("./agent/new-index"), exports);
+var SessionAnchor_1 = require("./anchoring/SessionAnchor");
+Object.defineProperty(exports, "SessionAnchor", { enumerable: true, get: function () { return SessionAnchor_1.SessionAnchor; } });
+var PolicyAccountManager_1 = require("./compression/PolicyAccountManager");
+Object.defineProperty(exports, "PolicyAccountManager", { enumerable: true, get: function () { return PolicyAccountManager_1.PolicyAccountManager; } });
+var AuditLogManager_1 = require("./compression/AuditLogManager");
+Object.defineProperty(exports, "AuditLogManager", { enumerable: true, get: function () { return AuditLogManager_1.AuditLogManager; } });
+var PRKTConfig_1 = require("./config/PRKTConfig");
+Object.defineProperty(exports, "defaultPRKTConfig", { enumerable: true, get: function () { return PRKTConfig_1.defaultPRKTConfig; } });
+__exportStar(require("./config/env"), exports);
+__exportStar(require("./onchain"), exports);
+var universal_1 = require("./defi/universal");
+Object.defineProperty(exports, "UniversalDeFiOrchestrator", { enumerable: true, get: function () { return universal_1.UniversalDeFiOrchestrator; } });
+var PolicyCircuit_1 = require("./zk/PolicyCircuit");
+Object.defineProperty(exports, "PolicyCircuit", { enumerable: true, get: function () { return PolicyCircuit_1.PolicyCircuit; } });
+Object.defineProperty(exports, "PolicyViolation", { enumerable: true, get: function () { return PolicyCircuit_1.PolicyViolation; } });
+var ProofAnchor_1 = require("./zk/ProofAnchor");
+Object.defineProperty(exports, "ProofAnchor", { enumerable: true, get: function () { return ProofAnchor_1.ProofAnchor; } });

package/dist/kora/KoraRpcClient.d.ts

@@ -0,0 +1,14 @@
+export declare class KoraRpcError extends Error {
+    constructor(message: string);
+}
+export declare class KoraRpcClient {
+    private readonly endpoint;
+    private readonly fetchImpl;
+    constructor(endpoint: string, fetchImpl?: typeof fetch);
+    get rpcUrl(): string;
+    getBlockhash(): Promise<string>;
+    signAndSendTransaction(transaction: string): Promise<{
+        signature: string;
+    }>;
+    private call;
+}

package/dist/kora/KoraSigner.d.ts

@@ -0,0 +1,22 @@
+import { VersionedTransaction } from "@solana/web3.js";
+import { WalletManager } from "../wallet/WalletManager";
+import { KoraRpcClient } from "./KoraRpcClient";
+export type GaslessExecutionResult = {
+    endpoint: string;
+    fallbackReason?: string;
+    memo: string;
+    mock: boolean;
+    signature: string;
+};
+export declare class KoraSigner {
+    private readonly client;
+    private readonly options;
+    constructor(client: KoraRpcClient, options: {
+        fallbackToMockOnError?: boolean;
+        mockMode: boolean;
+    });
+    buildMemoTransaction(walletManager: WalletManager, memo: string): Promise<VersionedTransaction>;
+    signAndSendGasless(transaction: VersionedTransaction, memo: string): Promise<GaslessExecutionResult>;
+    submitGaslessMemo(walletManager: WalletManager, memo: string): Promise<GaslessExecutionResult>;
+    private createMockSignature;
+}

package/dist/kora/KoraSigner.js

@@ -12,9 +12,17 @@ class KoraSigner {
         this.options = options;
     }
     async buildMemoTransaction(walletManager, memo) {
-        const recentBlockhash = this.options.mockMode
-            ? programs_1.MOCK_BLOCKHASH
-            : await this.client.getBlockhash();
+        let recentBlockhash = programs_1.MOCK_BLOCKHASH;
+        if (!this.options.mockMode) {
+            try {
+                recentBlockhash = await this.client.getBlockhash();
+            }
+            catch (error) {
+                if (!this.options.fallbackToMockOnError) {
+                    throw error;
+                }
+            }
+        }
         const memoInstruction = new web3_js_1.TransactionInstruction({
             programId: programs_1.MEMO_PROGRAM_ID,
             keys: [],
@@ -38,13 +46,28 @@ class KoraSigner {
                 signature: this.createMockSignature(serializedTransaction)
             };
         }
-        const { signature } = await this.client.signAndSendTransaction(serializedTransaction);
-        return {
-            endpoint: this.client.rpcUrl,
-            memo,
-            mock: false,
-            signature
-        };
+        try {
+            const { signature } = await this.client.signAndSendTransaction(serializedTransaction);
+            return {
+                endpoint: this.client.rpcUrl,
+                memo,
+                mock: false,
+                signature
+            };
+        }
+        catch (error) {
+            if (!this.options.fallbackToMockOnError) {
+                throw error;
+            }
+            const fallbackReason = error instanceof Error ? error.message : "unknown Kora RPC error";
+            return {
+                endpoint: this.client.rpcUrl,
+                fallbackReason,
+                memo,
+                mock: true,
+                signature: this.createMockSignature(serializedTransaction)
+            };
+        }
     }
     async submitGaslessMemo(walletManager, memo) {
         const transaction = await this.buildMemoTransaction(walletManager, memo);

package/dist/kora/gaslessDemo.d.ts

@@ -0,0 +1,9 @@
+export declare function assertGaslessDemoReadiness(input: {
+    solLamports: number;
+    usdcBalance: number;
+}): void;
+export declare function parseUiAmount(input: {
+    amount: string;
+    decimals: number;
+    uiAmount: number | null;
+}): number;

package/dist/onchain/index.d.ts

@@ -0,0 +1,2 @@
+export { buildCloseSessionInstruction, buildInitializePolicyInstruction, buildManagedTransferInstructions, buildOpenSessionInstruction, buildSetKillSwitchInstruction, createSessionId, deriveTransferIntentHash, encodeManagedTransferPayload, findPolicyPda, findSessionPda, findVaultPda, getPolicyStateSpace, resolvePolicyGuardProgramId } from "./policyGuardProgram";
+export type { InitializePolicyInput, ManagedTransferInput, ManagedTransferPayload, SessionInstructionInput } from "./policyGuardProgram";

package/dist/onchain/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePolicyGuardProgramId = exports.getPolicyStateSpace = exports.findVaultPda = exports.findSessionPda = exports.findPolicyPda = exports.encodeManagedTransferPayload = exports.deriveTransferIntentHash = exports.createSessionId = exports.buildSetKillSwitchInstruction = exports.buildOpenSessionInstruction = exports.buildManagedTransferInstructions = exports.buildInitializePolicyInstruction = exports.buildCloseSessionInstruction = void 0;
+var policyGuardProgram_1 = require("./policyGuardProgram");
+Object.defineProperty(exports, "buildCloseSessionInstruction", { enumerable: true, get: function () { return policyGuardProgram_1.buildCloseSessionInstruction; } });
+Object.defineProperty(exports, "buildInitializePolicyInstruction", { enumerable: true, get: function () { return policyGuardProgram_1.buildInitializePolicyInstruction; } });
+Object.defineProperty(exports, "buildManagedTransferInstructions", { enumerable: true, get: function () { return policyGuardProgram_1.buildManagedTransferInstructions; } });
+Object.defineProperty(exports, "buildOpenSessionInstruction", { enumerable: true, get: function () { return policyGuardProgram_1.buildOpenSessionInstruction; } });
+Object.defineProperty(exports, "buildSetKillSwitchInstruction", { enumerable: true, get: function () { return policyGuardProgram_1.buildSetKillSwitchInstruction; } });
+Object.defineProperty(exports, "createSessionId", { enumerable: true, get: function () { return policyGuardProgram_1.createSessionId; } });
+Object.defineProperty(exports, "deriveTransferIntentHash", { enumerable: true, get: function () { return policyGuardProgram_1.deriveTransferIntentHash; } });
+Object.defineProperty(exports, "encodeManagedTransferPayload", { enumerable: true, get: function () { return policyGuardProgram_1.encodeManagedTransferPayload; } });
+Object.defineProperty(exports, "findPolicyPda", { enumerable: true, get: function () { return policyGuardProgram_1.findPolicyPda; } });
+Object.defineProperty(exports, "findSessionPda", { enumerable: true, get: function () { return policyGuardProgram_1.findSessionPda; } });
+Object.defineProperty(exports, "findVaultPda", { enumerable: true, get: function () { return policyGuardProgram_1.findVaultPda; } });
+Object.defineProperty(exports, "getPolicyStateSpace", { enumerable: true, get: function () { return policyGuardProgram_1.getPolicyStateSpace; } });
+Object.defineProperty(exports, "resolvePolicyGuardProgramId", { enumerable: true, get: function () { return policyGuardProgram_1.resolvePolicyGuardProgramId; } });

package/dist/onchain/policyGuardProgram.d.ts

@@ -0,0 +1,86 @@
+import { Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
+export type InitializePolicyInput = {
+    owner: PublicKey;
+    verifier: PublicKey;
+    dailySpendLimitLamports: bigint;
+    sessionTtlMinutes: number;
+    allowedPrograms?: PublicKey[];
+    allowedRecipients?: PublicKey[];
+    programId?: PublicKey;
+};
+export type SessionInstructionInput = {
+    owner: PublicKey;
+    sessionId: Uint8Array;
+    programId?: PublicKey;
+};
+export type ManagedTransferInput = {
+    amountLamports: bigint;
+    nonce: bigint;
+    policyOwner: PublicKey;
+    recipient: PublicKey;
+    sessionId: Uint8Array;
+    signer: Keypair | Uint8Array;
+    expiresAtUnix: number;
+    timestampUnix?: number;
+    targetProgram?: PublicKey;
+    intentHash?: Uint8Array;
+    programId?: PublicKey;
+};
+export type ManagedTransferPayload = {
+    amountLamports: bigint;
+    expiresAtUnix: number;
+    intentHash: Buffer;
+    nonce: bigint;
+    recipient: PublicKey;
+    sessionId: Buffer;
+    targetProgram: PublicKey;
+    timestampUnix: number;
+};
+export declare function resolvePolicyGuardProgramId(programId?: PublicKey): PublicKey;
+export declare function createSessionId(seed?: string | Uint8Array): Buffer;
+export declare function getPolicyStateSpace(input: {
+    allowedPrograms?: PublicKey[];
+    allowedRecipients?: PublicKey[];
+}): number;
+export declare function findPolicyPda(owner: PublicKey, programId?: PublicKey): [PublicKey, number];
+export declare function findVaultPda(policyPda: PublicKey, programId?: PublicKey): [PublicKey, number];
+export declare function findSessionPda(policyPda: PublicKey, sessionId: Uint8Array, programId?: PublicKey): [PublicKey, number];
+export declare function buildInitializePolicyInstruction(input: InitializePolicyInput): {
+    instruction: TransactionInstruction;
+    policyPda: PublicKey;
+    vaultPda: PublicKey;
+};
+export declare function buildSetKillSwitchInstruction(input: {
+    active: boolean;
+    owner: PublicKey;
+    programId?: PublicKey;
+}): {
+    instruction: TransactionInstruction;
+    policyPda: PublicKey;
+};
+export declare function buildOpenSessionInstruction(input: SessionInstructionInput): {
+    instruction: TransactionInstruction;
+    policyPda: PublicKey;
+    sessionPda: PublicKey;
+};
+export declare function buildCloseSessionInstruction(input: SessionInstructionInput): {
+    instruction: TransactionInstruction;
+    policyPda: PublicKey;
+    sessionPda: PublicKey;
+};
+export declare function buildManagedTransferInstructions(input: ManagedTransferInput): {
+    ed25519Instruction: TransactionInstruction;
+    payload: Buffer;
+    policyPda: PublicKey;
+    programInstruction: TransactionInstruction;
+    sessionPda: PublicKey;
+    vaultPda: PublicKey;
+};
+export declare function encodeManagedTransferPayload(input: ManagedTransferPayload): Buffer;
+export declare function deriveTransferIntentHash(input: {
+    amountLamports: bigint;
+    nonce: bigint;
+    recipient: PublicKey;
+    sessionId: Uint8Array;
+    targetProgram?: PublicKey;
+}): Buffer;