Plat 6356 refined type support (#510)

Co-authored-by: Eric Lau <[email protected]>
Co-authored-by: Copilot <[email protected]>

Author: 3 people

.gitignore

@@ -5,5 +5,3 @@ node_modules
 .env
 .env.local
 .vscode/settings.json
-
-*deno.lock

.vscode/example.settings.json

@@ -6,5 +6,5 @@
     "packages/ui/scripts/development-server.ts"
   ],
   "deno.enable": true,
-  "deno.path": "/opt/homebrew/bin/deno" // Update this to your Deno path
+  "deno.path": "/opt/homebrew/bin/deno" // Update this to your Deno path	
 }

netlify.toml

@@ -4,6 +4,9 @@ publish = "packages/ui/public"
 
 edge_functions = "packages/ui/api"
 
+[functions]
+  deno_import_map = "packages/ui/import_map.json"
+
 [[edge_functions]]
   path = "/ai"
   function = "ai"

packages/ui/api/ai-assistant/function-definitions/shared.ts

@@ -1,3 +1,5 @@
+import type { AiFunctionPropertyDefinition } from '../types/function-definition.ts';
+
 const sharedFunctionDescription = {
   name: { type: 'string', description: 'The name of the contract' },
 
@@ -18,12 +20,19 @@ const sharedFunctionDescription = {
     type: 'boolean',
     description: 'Whether privileged accounts will be able to create more supply or emit more tokens',
   },
-} as const;
+} as const satisfies AiFunctionPropertyDefinition<{
+  name: string;
+  symbol: string;
+  burnable: boolean;
+  pausable: boolean;
+  mintable: boolean;
+}>['properties'];
 
 export const addFunctionPropertiesFrom = <
-  TCommonOptions extends Record<string, unknown>,
-  TCommonOptionName extends keyof (typeof sharedFunctionDescription &
-    TCommonOptions) = keyof (typeof sharedFunctionDescription & TCommonOptions),
+  TContract,
+  TCommonOptions extends Record<string, unknown> = Record<string, unknown>,
+  TCommonOptionName extends keyof (typeof sharedFunctionDescription & TCommonOptions) &
+    keyof TContract = keyof (typeof sharedFunctionDescription & TCommonOptions) & keyof TContract,
 >(
   commonOptions: TCommonOptions,
   commonOptionNames: TCommonOptionName[],

packages/ui/api/ai-assistant/function-definitions/solidity-shared.ts

@@ -0,0 +1,38 @@
+import type { AiFunctionPropertyDefinition } from '../types/function-definition.ts';
+import type { SolidityCommonOptions } from '../types/languages.ts';
+
+export const commonFunctionDescription = {
+  access: {
+    anyOf: [
+      { type: 'string', enum: ['ownable', 'roles', 'managed'] },
+      { type: 'boolean', enum: [false] },
+    ],
+    description:
+      'The type of access control to provision. Ownable is a simple mechanism with a single account authorized for all privileged actions. Roles is a flexible mechanism with a separate role for each privileged action. A role can have many authorized accounts. Managed enables a central contract to define a policy that allows certain callers to access certain functions.',
+  },
+
+  upgradeable: {
+    anyOf: [
+      { type: 'string', enum: ['transparent', 'uups'] },
+      { type: 'boolean', enum: [false] },
+    ],
+    description:
+      'Whether the smart contract is upgradeable. Transparent uses more complex proxy with higher overhead, requires less changes in your contract.Can also be used with beacons. UUPS uses simpler proxy with less overhead, requires including extra code in your contract. Allows flexibility for authorizing upgrades.',
+  },
+
+  info: {
+    type: 'object',
+    description: 'Metadata about the contract and author',
+    properties: {
+      securityContact: {
+        type: 'string',
+        description:
+          'Email where people can contact you to report security issues. Will only be visible if contract metadata is verified.',
+      },
+      license: {
+        type: 'string',
+        description: 'The license used by the contract, default is "MIT"',
+      },
+    },
+  },
+} as const satisfies AiFunctionPropertyDefinition<SolidityCommonOptions>['properties'];

packages/ui/api/ai-assistant/function-definitions/solidity.ts

@@ -1,42 +1,6 @@
-import type { AiFunctionDefinition, AiFunctionPropertyDefinition } from '../types/function-definition.ts';
+import type { AiFunctionDefinition } from '../types/function-definition.ts';
 import { addFunctionPropertiesFrom } from './shared.ts';
-import type { SolidityCommonOptions } from '../types/languages.ts';
-
-const commonFunctionDescription = {
-  access: {
-    anyOf: [
-      { type: 'boolean', enum: [false] },
-      { type: 'string', enum: ['ownable', 'roles', 'managed'] },
-    ],
-    description:
-      'The type of access control to provision. Ownable is a simple mechanism with a single account authorized for all privileged actions. Roles is a flexible mechanism with a separate role for each privileged action. A role can have many authorized accounts. Managed enables a central contract to define a policy that allows certain callers to access certain functions.',
-  },
-
-  upgradeable: {
-    anyOf: [
-      { type: 'boolean', enum: [false] },
-      { type: 'string', enum: ['transparent', 'uups'] },
-    ],
-    description:
-      'Whether the smart contract is upgradeable. Transparent uses more complex proxy with higher overhead, requires less changes in your contract.Can also be used with beacons. UUPS uses simpler proxy with less overhead, requires including extra code in your contract. Allows flexibility for authorizing upgrades.',
-  },
-
-  info: {
-    type: 'object',
-    description: 'Metadata about the contract and author',
-    properties: {
-      securityContact: {
-        type: 'string',
-        description:
-          'Email where people can contact you to report security issues. Will only be visible if contract metadata is verified.',
-      },
-      license: {
-        type: 'string',
-        description: 'The license used by the contract, default is "MIT"',
-      },
-    },
-  },
-} as const satisfies AiFunctionPropertyDefinition<SolidityCommonOptions>['properties'];
+import { commonFunctionDescription } from './solidity-shared.ts';
 
 export const erc20Function = {
   name: 'ERC20',
@@ -65,7 +29,7 @@ export const erc20Function = {
       },
       votes: {
         anyOf: [
-          { type: 'boolean', enum: [false] },
+          { type: 'boolean', enum: [false, true] },
           { type: 'string', enum: ['blocknumber', 'timestamp'] },
         ],
         description:
@@ -135,7 +99,7 @@ export const erc721Function = {
           { type: 'string', enum: ['blocknumber', 'timestamp'] },
         ],
         description:
-          'Whether to keep track of individual units for voting in on-chain governance. Voting durations can be expressed as block numbers or timestamps.',
+          'Whether to keep track of individual units for voting in on-chain governance. Voting durations can be expressed as block numbers or timestamps (defaulting to block number if not specified).',
       },
     },
     required: ['name', 'symbol'],
@@ -199,7 +163,7 @@ export const stablecoinFunction = {
           'Whether to restrict certain users from transferring tokens, either via allowing or blocking them. This feature is experimental, not audited and is subject to change.',
       },
       upgradeable: {
-        type: 'string',
+        type: 'boolean',
         enum: [false],
         description: 'Upgradeability is not yet available for features that use @openzeppelin/community-contracts',
       },
@@ -270,8 +234,8 @@ export const governorFunction = {
       },
       timelock: {
         anyOf: [
-          { type: 'boolean', enum: [false] },
           { type: 'string', enum: ['openzeppelin', 'compound'] },
+          { type: 'boolean', enum: [false] },
         ],
         description: 'The type of timelock to use',
       },

packages/ui/api/ai-assistant/types/function-definition.ts

@@ -1,48 +1,28 @@
 import type {
-  AllLanguagesContractsOptions,
-  LanguageContractsOptions,
-  SupportedLanguage,
-  AllLanguageContractsNames,
-} from './languages.ts';
-
-type IsPrimitiveUnion<T, U = T> = [T] extends [never]
-  ? false // Edge case for `never`
-  : [T] extends [boolean]
-    ? false
-    : T extends U
-      ? [U] extends [T]
-        ? false
-        : true
-      : false;
-
-type AiFunctionCallPrimaryType<TType> = TType extends string
-  ? 'string'
-  : TType extends number
-    ? 'number'
-    : TType extends boolean
-      ? 'boolean'
-      : TType extends unknown[]
-        ? 'array'
-        : TType extends object
-          ? 'object'
-          : never;
+  AiFunctionCallAnyOf,
+  StringifyPrimaryType,
+  ExactRequiredKeys,
+  IsPrimitiveUnion,
+  Permutation,
+} from './helpers.ts';
+import type { AllLanguagesContractsOptions, LanguageContractsOptions, SupportedLanguage } from './languages.ts';
 
 type AiFunctionType<TType> = {
-  type?: AiFunctionCallPrimaryType<TType>;
-  enum?: TType[];
+  type?: StringifyPrimaryType<TType>;
+  enum?: Permutation<TType>;
   description: string;
 };
 
 type AiFunctionCallOneOfType<TType> =
   | Required<AiFunctionType<TType>>
   | {
-      anyOf: Omit<AiFunctionCallType<TType>, 'description'>[];
+      anyOf: AiFunctionCallAnyOf<TType>;
       description: string;
     };
 
 export type AiFunctionCallType<TType> = AiFunctionType<TType> | AiFunctionCallOneOfType<TType>;
 
-type AiFunctionProperties<TProperties extends object> = Required<{
+export type AiFunctionProperties<TProperties extends object> = Required<{
   [K in keyof TProperties]: TProperties[K] extends object
     ? AiFunctionPropertyDefinition<TProperties[K]>
     : IsPrimitiveUnion<TProperties[K]> extends true
@@ -71,7 +51,7 @@ export type AiFunctionDefinition<
   name: TContractName;
   description: string;
   parameters: AiFunctionPropertyDefinition<Required<LanguageContractsOptions<TLanguage>[TContractName]>, TOmit> & {
-    required?: (keyof LanguageContractsOptions<TLanguage>[TContractName])[];
+    required?: ExactRequiredKeys<Omit<LanguageContractsOptions<TLanguage>[TContractName], 'kind' | TOmit>>;
     additionalProperties: false;
   };
 };

packages/ui/api/ai-assistant/types/helpers.ts

@@ -0,0 +1,59 @@
+export type IsPrimitiveUnion<T, U = T> = [T] extends [never]
+  ? false
+  : [T] extends [boolean]
+    ? false
+    : T extends U
+      ? [U] extends [T]
+        ? false
+        : true
+      : false;
+
+export type Permutation<T, K = T> = [T] extends [never] ? [] : K extends K ? [K, ...Permutation<Exclude<T, K>>] : never;
+
+type RequiredKeys<T, K = keyof T> = K extends keyof T ? (T extends Required<Pick<T, K>> ? K : never) : never;
+
+export type ExactRequiredKeys<T extends object> = Permutation<RequiredKeys<T>>;
+
+export type StringifyPrimaryType<TType> = TType extends string
+  ? 'string'
+  : TType extends number
+    ? 'number'
+    : TType extends boolean
+      ? 'boolean'
+      : TType extends unknown[]
+        ? 'array'
+        : TType extends object
+          ? 'object'
+          : never;
+
+type MembersOf<U, K extends string> = K extends 'boolean'
+  ? Extract<U, boolean>
+  : K extends 'string'
+    ? Extract<U, string>
+    : K extends 'number'
+      ? Extract<U, number>
+      : never;
+
+type BooleanEnum = [false] | [true] | [false, true] | [true, false];
+
+type EnumFor<K extends string, U> = K extends 'boolean' ? BooleanEnum : Permutation<MembersOf<U, K>>;
+
+type TypeFor<K extends string, U> = {
+  type: K;
+  enum: EnumFor<K, U>;
+};
+
+type Wrap<T> = { __wrapped: T };
+
+type WrappedTypeFor<K extends string, U> = Wrap<TypeFor<K, U>>;
+
+export type TypeGroup<U> = {
+  [K in StringifyPrimaryType<U>]: WrappedTypeFor<K, U>;
+}[StringifyPrimaryType<U>];
+
+export type AiFunctionCallAnyOf<U> =
+  Permutation<TypeGroup<U>> extends infer P
+    ? P extends readonly unknown[]
+      ? { [I in keyof P]: P[I] extends Wrap<infer X> ? X : never }
+      : never
+    : never;

packages/ui/api/ai-assistant/types/languages.ts

@@ -1,44 +1,19 @@
-// Solidity
-import type { ERC20Options as SolidityERC20Options } from '@openzeppelin/wizard/src/erc20';
-import type { ERC721Options as SolidityERC721Options } from '@openzeppelin/wizard/src/erc721';
-import type { ERC1155Options as SolidityERC1155Options } from '@openzeppelin/wizard/src/erc1155';
-import type { StablecoinOptions as SolidityStablecoinOptions } from '@openzeppelin/wizard/src/stablecoin';
-import type { GovernorOptions as SolidityGovernorOptions } from '@openzeppelin/wizard/src/governor';
-import type { CustomOptions as SolidityCustomOptions } from '@openzeppelin/wizard/src/custom';
-import type { Access as SolidityAccesss } from '@openzeppelin/wizard/src/set-access-control';
-import type { Upgradeable as SolidityUpgradeable } from '@openzeppelin/wizard/src/set-upgradeable';
-import type { Info as SolidityInfo } from '@openzeppelin/wizard/src/set-info';
+import type { KindedOptions as SolidityKindedOptions } from '@openzeppelin/wizard';
+export type { CommonOptions as SolidityCommonOptions } from '@openzeppelin/wizard/src/common-options.ts';
 
-// Solidity
-
-export interface SolidityCommonOptions {
-  access?: SolidityAccesss;
-  upgradeable?: SolidityUpgradeable;
-  info?: SolidityInfo;
-}
-
-export interface SolidityKindedOptions {
-  ERC20: { kind: 'ERC20' } & SolidityCommonOptions & SolidityERC20Options;
-  ERC721: { kind: 'ERC721' } & SolidityCommonOptions & SolidityERC721Options;
-  ERC1155: { kind: 'ERC1155' } & SolidityCommonOptions & SolidityERC1155Options;
-  Stablecoin: { kind: 'Stablecoin' } & SolidityCommonOptions & SolidityERC20Options & SolidityStablecoinOptions;
-  RealWorldAsset: { kind: 'RealWorldAsset' } & SolidityCommonOptions & SolidityERC20Options & SolidityStablecoinOptions;
-  Governor: { kind: 'Governor' } & SolidityCommonOptions & SolidityGovernorOptions;
-  Custom: { kind: 'Custom' } & SolidityCommonOptions & SolidityCustomOptions;
-}
-
-// After importing and building KindedOptions add supported language here
+// Add supported language here
 export type LanguagesContractsOptions = {
-  solidity: SolidityKindedOptions;
+  solidity: Omit<SolidityKindedOptions, 'Stablecoin' | 'RealWorldAsset'> & {
+    Stablecoin: Omit<SolidityKindedOptions['Stablecoin'], 'upgradeable'> & { upgradeable?: false };
+    RealWorldAsset: Omit<SolidityKindedOptions['RealWorldAsset'], 'upgradeable'> & { upgradeable?: false };
+  };
 };
 
 export type AllLanguagesContractsOptions = LanguagesContractsOptions['solidity'];
-
 //
 
 export type SupportedLanguage = keyof LanguagesContractsOptions;
 
-// Utils
 export type LanguageContractsOptions<TLanguage extends SupportedLanguage> = LanguagesContractsOptions[TLanguage];
 
 export type AllLanguageContractsNames = AllLanguagesContractsOptions[keyof AllLanguagesContractsOptions]['kind'];

packages/ui/deno.json

@@ -9,13 +9,7 @@
       "dist"
     ]
   },
-  "imports": {
-    "@openzeppelin/wizard": "./packages/wizard-solidity",
-    "@openzeppelin/wizard-cairo": "./packages/wizard-cairo",
-    "@openzeppelin/wizard-cairo-alpha": "./packages/wizard-cairo_alpha",
-    "@openzeppelin/wizard-stellar": "./packages/wizard-stellar",
-    "@openzeppelin/wizard-stylus": "./packages/wizard-stylus"
-  },
+  "importMap": "./import_map.json",
   "tasks": {
     "dev": "deno run --allow-all --env-file --watch --no-clear-screen scripts/development-server.ts"
   }