@reown/appkit-experimental 1.1.0

package/dist/types/exports/smart-session/index.d.ts

@@ -0,0 +1,2 @@
+export { grantPermissions, isSmartSessionSupported } from '../../src/smart-session/grantPermissions.js';
+export type { KeyType, SmartSessionGrantPermissionsRequest, SmartSessionGrantPermissionsResponse } from '../../src/smart-session/utils/TypeUtils.js';

package/dist/types/src/smart-session/grantPermissions.d.ts

@@ -0,0 +1,5 @@
+import type { SmartSessionGrantPermissionsRequest, SmartSessionGrantPermissionsResponse } from './utils/TypeUtils.js';
+import type { PermissionsCapability } from './utils/ERC5792Types.js';
+export declare function grantPermissions(request: SmartSessionGrantPermissionsRequest): Promise<SmartSessionGrantPermissionsResponse>;
+export declare function validateRequestForSupportedPermissionsCapability(request: SmartSessionGrantPermissionsRequest, capabilities: PermissionsCapability): void;
+export declare function isSmartSessionSupported(): boolean;

package/dist/types/src/smart-session/helper/index.d.ts

@@ -0,0 +1,61 @@
+import { type AddPermissionResponse, type KeyType, type SmartSessionGrantPermissionsRequest, type WalletGrantPermissionsResponse } from '../utils/TypeUtils.js';
+export declare function validateRequest(request: SmartSessionGrantPermissionsRequest): {
+    chainId: string;
+    expiry: number;
+    signer: {
+        type: "keys";
+        data: {
+            keys: {
+                type: "secp256r1" | "secp256k1";
+                publicKey: string;
+            }[];
+        };
+    };
+    permissions: [{
+        type: "contract-call";
+        data: {
+            address: string;
+            abi: Record<string, unknown>[];
+            functions: {
+                functionName: string;
+                args?: {
+                    value: string;
+                    operator: import("../utils/TypeUtils.js").ParamOperator;
+                }[] | undefined;
+                valueLimit?: string | undefined;
+                operation?: import("../utils/TypeUtils.js").Operation | undefined;
+            }[];
+        };
+    }, ...{
+        type: "contract-call";
+        data: {
+            address: string;
+            abi: Record<string, unknown>[];
+            functions: {
+                functionName: string;
+                args?: {
+                    value: string;
+                    operator: import("../utils/TypeUtils.js").ParamOperator;
+                }[] | undefined;
+                valueLimit?: string | undefined;
+                operation?: import("../utils/TypeUtils.js").Operation | undefined;
+            }[];
+        };
+    }[]];
+    policies: {
+        type: string;
+        data: Record<string, unknown>;
+    }[];
+    address?: string | undefined;
+};
+export declare function isValidSupportedCaipAddress(value: unknown): value is `eip155:${string}:${string}` | `eip155:${number}:${string}`;
+export declare function extractChainAndAddress(caipAddress: unknown): {
+    chain: string;
+    address: `0x${string}`;
+} | undefined;
+export declare function assertWalletGrantPermissionsResponse(response: unknown): WalletGrantPermissionsResponse;
+export declare function updateRequestSigner(request: SmartSessionGrantPermissionsRequest, cosignerKey: {
+    type: KeyType;
+    publicKey: `0x${string}`;
+}): void;
+export declare function assertAddPermissionResponse(response: unknown): asserts response is AddPermissionResponse;

package/dist/types/src/smart-session/schema/index.d.ts

@@ -0,0 +1,265 @@
+import { z } from 'zod';
+import { Operation, ParamOperator } from '../utils/TypeUtils.js';
+export declare const ERROR_MESSAGES: {
+    UNSUPPORTED_NAMESPACE: string;
+    NO_RESPONSE_RECEIVED: string;
+    INVALID_REQUEST: string;
+    INVALID_CHAIN_ID_FORMAT: string;
+    INVALID_CHAIN_ID_DATA: string;
+    INVALID_ADDRESS: string;
+    INVALID_EXPIRY: string;
+    INVALID_KEYS_SIGNER: string;
+    UNSUPPORTED_SIGNER_TYPE: string;
+    UNSUPPORTED_KEY_TYPE: string;
+    INVALID_PUBLIC_KEY_FORMAT: string;
+    INVALID_PERMISSIONS: string;
+    INVALID_PERMISSIONS_TYPE: string;
+    INVALID_PERMISSIONS_TYPE_LITERALS: string;
+    INVALID_POLICIES: string;
+    INVALID_POLICIES_TYPE: string;
+    INVALID_GRANT_PERMISSIONS_RESPONSE: string;
+};
+export declare const SmartSessionGrantPermissionsRequestSchema: z.ZodObject<{
+    chainId: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    address: z.ZodOptional<z.ZodString>;
+    expiry: z.ZodEffects<z.ZodNumber, number, number>;
+    signer: z.ZodObject<{
+        type: z.ZodLiteral<"keys">;
+        data: z.ZodObject<{
+            keys: z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<["secp256r1", "secp256k1"]>;
+                publicKey: z.ZodEffects<z.ZodString, string, string>;
+            }, "strip", z.ZodTypeAny, {
+                type: "secp256r1" | "secp256k1";
+                publicKey: string;
+            }, {
+                type: "secp256r1" | "secp256k1";
+                publicKey: string;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            keys: {
+                type: "secp256r1" | "secp256k1";
+                publicKey: string;
+            }[];
+        }, {
+            keys: {
+                type: "secp256r1" | "secp256k1";
+                publicKey: string;
+            }[];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        type: "keys";
+        data: {
+            keys: {
+                type: "secp256r1" | "secp256k1";
+                publicKey: string;
+            }[];
+        };
+    }, {
+        type: "keys";
+        data: {
+            keys: {
+                type: "secp256r1" | "secp256k1";
+                publicKey: string;
+            }[];
+        };
+    }>;
+    permissions: z.ZodArray<z.ZodObject<{
+        type: z.ZodEffects<z.ZodLiteral<"contract-call">, "contract-call", "contract-call">;
+        data: z.ZodObject<{
+            address: z.ZodString;
+            abi: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+            functions: z.ZodArray<z.ZodObject<{
+                functionName: z.ZodString;
+                args: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    operator: z.ZodNativeEnum<typeof ParamOperator>;
+                    value: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    value: string;
+                    operator: ParamOperator;
+                }, {
+                    value: string;
+                    operator: ParamOperator;
+                }>, "many">>;
+                valueLimit: z.ZodOptional<z.ZodString>;
+                operation: z.ZodOptional<z.ZodNativeEnum<typeof Operation>>;
+            }, "strip", z.ZodTypeAny, {
+                functionName: string;
+                args?: {
+                    value: string;
+                    operator: ParamOperator;
+                }[] | undefined;
+                valueLimit?: string | undefined;
+                operation?: Operation | undefined;
+            }, {
+                functionName: string;
+                args?: {
+                    value: string;
+                    operator: ParamOperator;
+                }[] | undefined;
+                valueLimit?: string | undefined;
+                operation?: Operation | undefined;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            address: string;
+            abi: Record<string, unknown>[];
+            functions: {
+                functionName: string;
+                args?: {
+                    value: string;
+                    operator: ParamOperator;
+                }[] | undefined;
+                valueLimit?: string | undefined;
+                operation?: Operation | undefined;
+            }[];
+        }, {
+            address: string;
+            abi: Record<string, unknown>[];
+            functions: {
+                functionName: string;
+                args?: {
+                    value: string;
+                    operator: ParamOperator;
+                }[] | undefined;
+                valueLimit?: string | undefined;
+                operation?: Operation | undefined;
+            }[];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        type: "contract-call";
+        data: {
+            address: string;
+            abi: Record<string, unknown>[];
+            functions: {
+                functionName: string;
+                args?: {
+                    value: string;
+                    operator: ParamOperator;
+                }[] | undefined;
+                valueLimit?: string | undefined;
+                operation?: Operation | undefined;
+            }[];
+        };
+    }, {
+        type: "contract-call";
+        data: {
+            address: string;
+            abi: Record<string, unknown>[];
+            functions: {
+                functionName: string;
+                args?: {
+                    value: string;
+                    operator: ParamOperator;
+                }[] | undefined;
+                valueLimit?: string | undefined;
+                operation?: Operation | undefined;
+            }[];
+        };
+    }>, "atleastone">;
+    policies: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        data: Record<string, unknown>;
+    }, {
+        type: string;
+        data: Record<string, unknown>;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    chainId: string;
+    expiry: number;
+    signer: {
+        type: "keys";
+        data: {
+            keys: {
+                type: "secp256r1" | "secp256k1";
+                publicKey: string;
+            }[];
+        };
+    };
+    permissions: [{
+        type: "contract-call";
+        data: {
+            address: string;
+            abi: Record<string, unknown>[];
+            functions: {
+                functionName: string;
+                args?: {
+                    value: string;
+                    operator: ParamOperator;
+                }[] | undefined;
+                valueLimit?: string | undefined;
+                operation?: Operation | undefined;
+            }[];
+        };
+    }, ...{
+        type: "contract-call";
+        data: {
+            address: string;
+            abi: Record<string, unknown>[];
+            functions: {
+                functionName: string;
+                args?: {
+                    value: string;
+                    operator: ParamOperator;
+                }[] | undefined;
+                valueLimit?: string | undefined;
+                operation?: Operation | undefined;
+            }[];
+        };
+    }[]];
+    policies: {
+        type: string;
+        data: Record<string, unknown>;
+    }[];
+    address?: string | undefined;
+}, {
+    chainId: string;
+    expiry: number;
+    signer: {
+        type: "keys";
+        data: {
+            keys: {
+                type: "secp256r1" | "secp256k1";
+                publicKey: string;
+            }[];
+        };
+    };
+    permissions: [{
+        type: "contract-call";
+        data: {
+            address: string;
+            abi: Record<string, unknown>[];
+            functions: {
+                functionName: string;
+                args?: {
+                    value: string;
+                    operator: ParamOperator;
+                }[] | undefined;
+                valueLimit?: string | undefined;
+                operation?: Operation | undefined;
+            }[];
+        };
+    }, ...{
+        type: "contract-call";
+        data: {
+            address: string;
+            abi: Record<string, unknown>[];
+            functions: {
+                functionName: string;
+                args?: {
+                    value: string;
+                    operator: ParamOperator;
+                }[] | undefined;
+                valueLimit?: string | undefined;
+                operation?: Operation | undefined;
+            }[];
+        };
+    }[]];
+    policies: {
+        type: string;
+        data: Record<string, unknown>;
+    }[];
+    address?: string | undefined;
+}>;

package/dist/types/src/smart-session/utils/ConstantUtils.d.ts

@@ -0,0 +1,4 @@
+export declare const ConstantsUtil: {
+    COSIGNER_BASE_URL: string;
+};
+export declare const ERC7715_METHOD = "wallet_grantPermissions";

package/dist/types/src/smart-session/utils/CosignerService.d.ts

@@ -0,0 +1,19 @@
+import type { ActivatePermissionsRequest, AddPermissionRequest, AddPermissionResponse } from './TypeUtils.js';
+export declare class CoSignerApiError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
+export declare function sendCoSignerRequest<TRequest, TResponse, TQueryParams extends Record<string, string>>({ url, request, queryParams, headers, transformRequest }: {
+    url: string;
+    request: TRequest;
+    queryParams?: TQueryParams;
+    headers: Record<string, string>;
+    transformRequest?: (data: TRequest) => unknown;
+}): Promise<TResponse>;
+export declare class CosignerService {
+    private baseUrl;
+    private projectId;
+    constructor(projectId: string);
+    addPermission(address: string, data: AddPermissionRequest): Promise<AddPermissionResponse>;
+    activatePermissions(address: string, updateData: ActivatePermissionsRequest): Promise<void>;
+}

package/dist/types/src/smart-session/utils/ERC5792Types.d.ts

@@ -0,0 +1,20 @@
+type BaseCapability = {
+    supported: boolean;
+};
+export type AtomicBatchCapability = BaseCapability;
+export type PaymasterServiceCapability = BaseCapability & {
+    url: string;
+    context: Record<string, unknown> | undefined;
+};
+export type PermissionsCapability = BaseCapability & {
+    signerTypes: string[];
+    permissionTypes: string[];
+    policyTypes: string[];
+};
+export type ChainCapabilities = {
+    atomicBatch?: AtomicBatchCapability;
+    paymasterService?: PaymasterServiceCapability;
+    permissions?: PermissionsCapability;
+};
+export type WalletCapabilities = Record<`0x${string}`, ChainCapabilities>;
+export {};

package/dist/types/src/smart-session/utils/TypeUtils.d.ts

@@ -0,0 +1,80 @@
+export type KeyType = 'secp256r1' | 'secp256k1';
+export type MultiKeySigner = {
+    type: 'keys';
+    data: {
+        keys: {
+            type: KeyType;
+            publicKey: `0x${string}`;
+        }[];
+    };
+};
+export type Signer = MultiKeySigner;
+export type SmartSessionGrantPermissionsRequest = {
+    chainId: `0x${string}`;
+    address?: `0x${string}`;
+    expiry: number;
+    signer: Signer;
+    permissions: Permission[];
+    policies: {
+        type: string;
+        data: Record<string, unknown>;
+    }[];
+};
+export type WalletGrantPermissionsResponse = SmartSessionGrantPermissionsRequest & {
+    context: `0x${string}`;
+    accountMeta?: {
+        factory: `0x${string}`;
+        factoryData: `0x${string}`;
+    };
+    signerMeta?: {
+        userOpBuilder?: `0x${string}`;
+        delegationManager?: `0x${string}`;
+    };
+};
+export type SmartSessionGrantPermissionsResponse = {
+    chainId: `0x${string}`;
+    address: `0x${string}`;
+    expiry: number;
+    permissions: Permission[];
+    context: string;
+};
+export declare enum ParamOperator {
+    EQUAL = "EQUAL",
+    GREATER_THAN = "GREATER_THAN",
+    LESS_THAN = "LESS_THAN"
+}
+export declare enum Operation {
+    Call = "Call",
+    DelegateCall = "DelegateCall"
+}
+export type ArgumentCondition = {
+    operator: ParamOperator;
+    value: `0x${string}`;
+};
+export type FunctionPermission = {
+    functionName: string;
+    args?: ArgumentCondition[];
+    valueLimit?: `0x${string}`;
+    operation?: Operation;
+};
+export type ContractCallPermission = {
+    type: 'contract-call';
+    data: {
+        address: `0x${string}`;
+        abi: Record<string, unknown>[];
+        functions: FunctionPermission[];
+    };
+};
+export type Permission = ContractCallPermission;
+export type AddPermissionRequest = SmartSessionGrantPermissionsRequest;
+export type AddPermissionResponse = {
+    pci: string;
+    key: {
+        type: KeyType;
+        publicKey: `0x${string}`;
+    };
+};
+export type ActivatePermissionsRequest = {
+    pci: string;
+    context: `0x${string}`;
+} & AddPermissionRequest;

package/dist/types/tests/data/abi.d.ts

@@ -0,0 +1,11 @@
+export declare const donutContractAbi: {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: never[];
+    stateMutability: string;
+    type: string;
+}[];

package/dist/types/tests/smart-session/CosignerService.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/smart-session/grantPermissions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/smart-session/requestValidation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@reown/appkit-experimental",
+  "version": "1.1.0",
+  "type": "module",
+  "main": "./dist/esm/exports/index.js",
+  "types": "./dist/types/exports/index.d.ts",
+  "files": [
+    "dist",
+    "!tsconfig.tsbuildinfo"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/types/exports/index.d.ts",
+      "import": "./dist/esm/exports/index.js",
+      "default": "./dist/esm/exports/index.js"
+    },
+    "./smart-session": {
+      "types": "./dist/types/exports/smart-session/index.d.ts",
+      "import": "./dist/esm/exports/smart-session/index.js",
+      "default": "./dist/esm/exports/smart-session/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "smart-session": [
+        "./dist/types/exports/smart-session/index.d.ts"
+      ]
+    }
+  },
+  "dependencies": {
+    "axios": "1.7.2",
+    "zod": "3.22.4",
+    "@reown/appkit": "1.1.0",
+    "@reown/appkit-core": "1.1.0",
+    "@reown/appkit-common": "1.1.0"
+  },
+  "devDependencies": {
+    "@types/axios-mock-adapter": "1.10.0",
+    "@vitest/coverage-v8": "2.0.5",
+    "axios-mock-adapter": "2.0.0",
+    "vitest": "2.0.5"
+  },
+  "keywords": [
+    "web3",
+    "crypto",
+    "ethereum",
+    "appkit",
+    "reown",
+    "lit",
+    "experimental"
+  ],
+  "author": "Reown <support@reown.com> (https://reown.com)",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/reown-com/appkit",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/reown-com/appkit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/reown-com/appkit/issues"
+  },
+  "scripts": {
+    "build:clean": "rm -rf dist",
+    "build": "tsc --build",
+    "watch": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --dir tests --coverage.enabled=true --coverage.reporter=json --coverage.reporter=json-summary --coverage.reportOnFailure=true",
+    "lint": "eslint . --ext .js,.jsx,.ts,.tsx"
+  }
+}

package/readme.md

@@ -0,0 +1,23 @@
+#### 📚 [Documentation](https://docs.reown.com/2.0/appkit/about)
+
+#### 🔗 [Website](https://reown.com/appkit)
+
+# AppKit Experimental (@reown/appkit-experimental)
+
+The @reown/appkit-experimental package provides a set of cutting-edge, experimental features for Web3 developers. This package serves as a testing ground for innovative concepts and implementations that are not yet widely adopted or standardized in the blockchain ecosystem.
+
+## Key Characteristics
+
+- **Experimental Nature**: Features in this package are considered experimental and may undergo significant changes.
+- **EIP Implementation**: Includes implementations of non-finalized Ethereum Improvement Proposals (EIPs).
+- **Ecosystem Exploration**: Offers functionalities that are not yet widely adopted in the broader Web3 ecosystem.
+
+## Installation
+
+```bash
+npm install @reown/appkit-experimental
+```
+
+## Smart Session
+
+The `@reown/appkit-experimental/smart-session` allows developers to easily integrate session-based permission handling within their dApps. Using the `grantPermissions` method, dApps can send permission requests to connected wallets.