@sun-protocol/sun-sdk-runtime 0.1.0-beta.0

package/dist/types-CZnHFnQK.d.ts

@@ -0,0 +1,212 @@
+import { ChainConfig } from '@sun-protocol/sun-sdk-chains';
+import { TronAddress, ContractParameter, ContractCallAction, TransactionIntent, Network, TransactionReceiptFinality } from '@sun-protocol/sun-sdk-core';
+
+interface AbiParameter {
+    readonly name?: string;
+    readonly type: string;
+    readonly components?: readonly AbiParameter[];
+    readonly [key: string]: unknown;
+}
+interface AbiItem {
+    readonly type: string;
+    readonly name?: string;
+    readonly inputs?: readonly AbiParameter[];
+    readonly outputs?: readonly AbiParameter[];
+    readonly [key: string]: unknown;
+}
+interface AbiFunction extends AbiItem {
+    readonly type: 'function';
+    readonly name: string;
+}
+interface UnsignedTronTransaction {
+    readonly raw_data?: unknown;
+    readonly raw_data_hex?: string;
+    readonly txID?: string;
+}
+interface SignedTronTransaction extends UnsignedTronTransaction {
+    readonly signature?: readonly string[];
+}
+interface TxResult {
+    readonly txid: string;
+    readonly raw: unknown;
+}
+interface TransactionReceipt {
+    readonly txid: string;
+    readonly result: string;
+    readonly success: boolean;
+    readonly raw: unknown;
+}
+interface WaitForTransactionReceiptOptions {
+    /**
+     * `included` queries the FullNode latest head and returns after the transaction
+     * has been included and executed, but before it is irreversible.
+     *
+     * `solidified` queries the SolidityNode and returns only after the transaction
+     * is part of the irreversible solidified state. It is safer but slower.
+     *
+     * Defaults to `solidified` for direct callers. Protocol execution always
+     * passes the action's explicit `waitForReceipt` policy.
+     */
+    readonly finality?: TransactionReceiptFinality;
+    readonly timeoutMs?: number;
+    readonly pollIntervalMs?: number;
+}
+interface TypedDataPayload {
+    readonly primaryType: string;
+    readonly domain: unknown;
+    readonly types: unknown;
+    readonly message: unknown;
+}
+interface WalletCapabilities {
+    readonly signTransaction: boolean;
+    readonly signAndSendTransaction: boolean;
+    readonly signTypedData: boolean;
+    readonly userInteractive: boolean;
+}
+type WalletSendStrategy = 'sign-then-broadcast' | 'sign-and-send';
+interface WalletAdapter {
+    readonly kind: 'privateKey' | 'injected' | 'tronWalletAdapter' | 'custom' | 'mock';
+    readonly capabilities: WalletCapabilities;
+    readonly sendStrategy?: WalletSendStrategy;
+    getAddress(): Promise<TronAddress | string>;
+    signTransaction?(tx: UnsignedTronTransaction): Promise<SignedTronTransaction>;
+    signAndSendTransaction?(tx: UnsignedTronTransaction): Promise<TxResult | unknown>;
+    signTypedData?(payload: TypedDataPayload): Promise<string>;
+    signMessage?(message: string): Promise<string>;
+}
+type GetWallet = () => WalletAdapter | undefined | Promise<WalletAdapter | undefined>;
+interface ContractRead {
+    readonly target: TronAddress;
+    readonly functionSelector: string;
+    readonly parameters?: readonly ContractParameter[];
+    readonly abiFunction?: unknown;
+    readonly outputs?: readonly ContractOutputParameter[];
+    readonly from?: TronAddress;
+    readonly rawParameter?: string;
+    /** Return the raw triggerConstantContract response without ABI lookup or decoding. */
+    readonly rawResult?: boolean;
+}
+interface ContractOutputParameter {
+    readonly type: string;
+    readonly name?: string;
+}
+interface ContractCall extends ContractRead {
+    readonly callValue?: ContractCallAction['callValue'];
+    readonly feeLimit?: ContractCallAction['feeLimit'];
+    readonly tokenId?: string;
+    readonly tokenValue?: number;
+    readonly permissionId?: number;
+}
+interface ContractAddressInput {
+    readonly address: TronAddress | string;
+}
+interface ContractAbiInput extends ContractAddressInput {
+    readonly abi: readonly AbiItem[];
+    readonly functionName: string;
+    readonly args?: readonly unknown[];
+    readonly functionSelector?: never;
+    readonly parameters?: never;
+    readonly rawParameter?: never;
+}
+type SelectorParameters = {
+    readonly parameters?: readonly ContractParameter[];
+    readonly rawParameter?: never;
+} | {
+    readonly parameters?: never;
+    readonly rawParameter: string;
+};
+type ContractSelectorInput = ContractAddressInput & SelectorParameters & {
+    readonly functionSelector: string;
+    readonly abi?: never;
+    readonly functionName?: never;
+    readonly args?: never;
+};
+type ContractReadInput = (ContractAbiInput & {
+    readonly from?: TronAddress | string;
+    readonly outputs?: never;
+}) | (ContractSelectorInput & {
+    readonly from?: TronAddress | string;
+    /** Decode supported static outputs. Omit to receive the raw provider response. */
+    readonly outputs?: readonly ContractOutputParameter[];
+});
+interface ContractWriteFields {
+    readonly callValue?: bigint;
+    readonly feeLimit?: number;
+    readonly tokenId?: string;
+    readonly tokenValue?: number;
+    readonly permissionId?: number;
+}
+type ContractWriteInput = (ContractAbiInput & ContractWriteFields) | (ContractSelectorInput & ContractWriteFields);
+interface SubmittedEvent {
+    readonly txid: string;
+    readonly network: Network;
+    readonly ownerAddress: TronAddress;
+    readonly walletKind: WalletAdapter['kind'];
+    readonly source: 'contract-write' | 'runtime-action';
+    readonly actionId?: string;
+    readonly intent?: TransactionIntent;
+}
+type SubmittedCallback = (event: SubmittedEvent) => void;
+interface RuntimeWalletExecutionOptions {
+    readonly wallet?: WalletAdapter;
+}
+interface ContractWriteExecutionOptions extends RuntimeWalletExecutionOptions {
+    /** Required for semantic submission handling when bypassing a transaction plan. */
+    readonly intent?: TransactionIntent;
+}
+interface RuntimeBuildTransactionOptions extends RuntimeWalletExecutionOptions {
+    readonly ownerAddress?: TronAddress;
+}
+interface ContractClient {
+    read<T = unknown>(input: ContractReadInput): Promise<T>;
+    write(input: ContractWriteInput, options?: ContractWriteExecutionOptions): Promise<TxResult>;
+}
+interface BuildTransactionOptions {
+    readonly ownerAddress?: TronAddress;
+}
+interface MulticallResult<T = unknown> {
+    readonly success: boolean;
+    readonly value?: T;
+    readonly error?: unknown;
+}
+interface AggregateMulticallCall {
+    readonly target: TronAddress;
+    readonly callData: string;
+}
+interface AggregateMulticallInput {
+    readonly requireSuccess: boolean;
+    readonly calls: readonly AggregateMulticallCall[];
+}
+interface AggregateMulticallResult {
+    readonly success: boolean;
+    readonly returnData: string;
+}
+interface TronClient {
+    readonly kind: 'tronweb' | 'custom' | 'mock';
+    readonly network: Network;
+    getNativeBalance?(owner: TronAddress | string): Promise<string>;
+    readContract<T = unknown>(call: ContractRead): Promise<T>;
+    buildTransaction(call: ContractCall, options?: BuildTransactionOptions): Promise<UnsignedTronTransaction>;
+    broadcastTransaction(tx: SignedTronTransaction): Promise<TxResult>;
+    waitForTransactionReceipt?(txid: string, options?: WaitForTransactionReceiptOptions): Promise<TransactionReceipt>;
+}
+interface Runtime {
+    readonly network: Network;
+    readonly chain: ChainConfig;
+    readonly tronClient: TronClient;
+    readonly contract: ContractClient;
+    /** The fixed wallet supplied at construction time. Dynamic wallets are resolved by getWallet(). */
+    readonly wallet?: WalletAdapter;
+    getWallet(): Promise<WalletAdapter | undefined>;
+    requireWallet(operation: string): Promise<WalletAdapter>;
+    getAddress(): Promise<TronAddress | undefined>;
+    readContract<T = unknown>(call: ContractRead): Promise<T>;
+    buildTransaction(action: ContractCallAction, options?: RuntimeBuildTransactionOptions): Promise<UnsignedTronTransaction>;
+    sendAction(action: ContractCallAction, options?: RuntimeWalletExecutionOptions): Promise<TxResult>;
+    waitForTransactionReceipt?(txid: string, options?: WaitForTransactionReceiptOptions): Promise<TransactionReceipt>;
+    signTypedData(payload: TypedDataPayload, options?: RuntimeWalletExecutionOptions): Promise<string>;
+    multicall<T = unknown>(calls: readonly ContractRead[]): Promise<readonly MulticallResult<T>[]>;
+    aggregateMulticall(input: AggregateMulticallInput): Promise<readonly AggregateMulticallResult[]>;
+}
+
+export type { AggregateMulticallInput as A, BuildTransactionOptions as B, ContractCall as C, GetWallet as G, MulticallResult as M, Runtime as R, SignedTronTransaction as S, TxResult as T, UnsignedTronTransaction as U, WalletSendStrategy as W, TypedDataPayload as a, WalletAdapter as b, WalletCapabilities as c, TronClient as d, SubmittedCallback as e, AggregateMulticallResult as f, AbiFunction as g, AbiItem as h, AbiParameter as i, AggregateMulticallCall as j, ContractClient as k, ContractOutputParameter as l, ContractRead as m, ContractReadInput as n, ContractWriteExecutionOptions as o, ContractWriteInput as p, RuntimeBuildTransactionOptions as q, RuntimeWalletExecutionOptions as r, SubmittedEvent as s, TransactionReceipt as t, WaitForTransactionReceiptOptions as u };

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@sun-protocol/sun-sdk-runtime",
+  "version": "0.1.0-beta.0",
+  "description": "TRON chain clients, wallet adapters, contract access, signing, and transaction broadcasting for SUN SDK.",
+  "keywords": [
+    "sun",
+    "tron",
+    "tronweb",
+    "wallet",
+    "typescript"
+  ],
+  "homepage": "https://github.com/sun-protocol/sun-sdk#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sun-protocol/sun-sdk.git",
+    "directory": "packages/runtime"
+  },
+  "private": false,
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "browser": [
+        "./dist/browser.d.ts"
+      ],
+      "tronweb": [
+        "./dist/tronweb.d.ts"
+      ],
+      "node": [
+        "./dist/node.d.ts"
+      ],
+      "mock": [
+        "./dist/mock.d.ts"
+      ],
+      "*": [
+        "./dist/index.d.ts"
+      ]
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js",
+      "require": "./dist/browser.cjs"
+    },
+    "./tronweb": {
+      "types": "./dist/tronweb.d.ts",
+      "import": "./dist/tronweb.js",
+      "require": "./dist/tronweb.cjs"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js",
+      "require": "./dist/node.cjs"
+    },
+    "./mock": {
+      "types": "./dist/mock.d.ts",
+      "import": "./dist/mock.js",
+      "require": "./dist/mock.cjs"
+    }
+  },
+  "dependencies": {
+    "@sun-protocol/sun-sdk-chains": "0.1.0-beta.0",
+    "@sun-protocol/sun-sdk-core": "0.1.0-beta.0"
+  },
+  "peerDependencies": {
+    "tronweb": "*"
+  },
+  "peerDependenciesMeta": {
+    "tronweb": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/browser.ts src/tronweb.ts src/node.ts src/mock.ts --format esm,cjs --dts --sourcemap --clean --tsconfig ../../tsconfig.base.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
+}