@zodiaceco/sdk 1.13.2 → 2.1.0

package/README.md

@@ -1,4 +1,4 @@
-# Zodiac OS SDK
+# Zodiac SDK
 
 Programmatically manage [Zodiac](https://www.zodiac.eco) account constellations.
 
@@ -137,6 +137,90 @@ References are resolved by label at `push()` time, so both sides of the cycle mu
 const aliceAddress = eth.user['Alice Sample']
 ```
 
+### Describing what a role may do
+
+A Roles mod carries roles, and every role lists `permissions` — entries that
+describe what the role is allowed to do. Entries carry parameters and a label,
+never compiled permissions: they are compiled when the constellation is
+deployed, so a stored revision always goes through the current compilers
+instead of replaying a copy made when it was pushed.
+
+```ts
+import { swap, transfer, custom, defikit } from '@zodiaceco/sdk/actions'
+// `allow` is your project's generated permission kit — a global in template
+// projects, created by `zodiac pull-contracts`.
+
+const treasuryRoles = eth.roles['GG Treasury Roles']({
+  nonce: 0n,
+  target: ggTreasury,
+  allowances: { usdc_payouts },
+  roles: {
+    treasury_ops: {
+      members: [eth.user['Alice Sample']],
+      permissions: [
+        swap({ label: 'Rebalance stables', sell: [USDC, DAI], buy: [WETH] }),
+
+        transfer({
+          label: 'Grant payouts',
+          tokens: [USDC],
+          to: [eth.safe['Grants Safe']],
+          bridge: [{ to: [gno.safe['Ops Safe']], receive: [GNO_USDC] }],
+          allowance: usdc_payouts,
+        }),
+
+        defikit.aave_v3.deposit({
+          label: 'Aave deposits',
+          market: 'Core',
+          targets: ['WETH'],
+        }),
+
+        custom({
+          label: 'Bot ops',
+          permissions: [
+            allow.eth.weth.deposit({ send: true }),
+            allow.eth.weth.withdraw(),
+          ],
+        }),
+      ],
+    },
+  },
+})
+```
+
+Each helper covers a different kind of action:
+
+- `swap()` allows signing CoW orders between the tokens it names.
+- `transfer()` allows sending tokens to the addresses it names, optionally
+  capped by an allowance declared on the same Roles mod. Pass the zero address
+  to allow sending the native token. `bridge` names destinations on other
+  chains, sent over Across: each target pins both the recipients and the tokens
+  they may receive there. A target takes its chain from its recipient nodes, or
+  name one with `chain` when the recipients are plain addresses. Tokens without
+  an Across route to a target are skipped, the same way the app skips them —
+  routes change between writing a spec and deploying it — but a target nothing
+  can reach at all is refused at deploy rather than deployed half-working.
+- `defikit` mirrors the DeFi Kit allow kit — same protocols, verbs and
+  parameters, plus a `label`. A DeFi Kit entry is nothing but its annotation;
+  the permissions behind it are fetched from the annotation's uri at deploy, so
+  `push()` fetches nothing. Protocols and parameters are typed against the
+  Ethereum kit, the widest of the chains DeFi Kit serves.
+- `custom()` labels a bag of plain `allow`-kit permissions — everything the
+  other helpers don't cover. It takes permissions, not other actions.
+
+Every helper takes a `label`. The label names the action in Zodiac and never
+reaches the chain. A bare permission with no enclosing helper stays valid, but
+it has nowhere to appear in the app beyond the targets it allows.
+
+Allowance keys are plain labels — `key: 'usdc_payouts'` on the declaration, and
+`allowance: usdc_payouts` on the transfer, which reads the key off it. They are
+encoded to bytes32 when the constellation is deployed, so nothing calls
+`encodeKey` by hand. A label has to fit in 32 bytes.
+
+Tokens are named by address, not by symbol. A `transfer()` recipient may also
+be a node — an account from your codegen, or one bound by address — which
+stands for the address it lives at. A node whose address is only known once the
+constellation is deployed is rejected at compile time.
+
 ### Pushing the constellation
 
 The `push()` function takes all nodes and sends them to the Zodiac OS API. Pass either a named object (keys become refs) or an array:

package/dist/actions-Dn5NC3oq.d.mts

@@ -0,0 +1,352 @@
+import { Permission } from "zodiac-roles-sdk";
+import { Address, ApplyConstellationPayload, ChainId } from "@zodiaceco/api-types";
+import { allow } from "defi-kit/eth";
+import { UUID } from "crypto";
+
+//#region src/types.d.ts
+type ApiNewRolesSpec = Extract<ApplyConstellationPayload['specification'][number], {
+  type: 'ROLES';
+  nonce: string;
+}>;
+/** A role definition in the API's serialized format (bigints as template literal strings). */
+/** An allowance definition in the API's serialized format (bigints as template literal strings). */
+type ApiAllowanceSpec = Extract<NonNullable<ApiNewRolesSpec['allowances']>, readonly any[]>[number];
+/** Recursively converts `${bigint}` template literal strings to `bigint`. */
+type RealBigints<T> = T extends `${bigint}` ? bigint : T extends readonly (infer U)[] ? RealBigints<U>[] : T extends Record<string, any> ? { [K in keyof T]: RealBigints<T[K]> } : T;
+/** A role definition with bigint fields as actual bigints. */
+/** An allowance definition with bigint fields as actual bigints. */
+type AllowanceSpec = RealBigints<ApiAllowanceSpec>;
+//#endregion
+//#region src/constellation.d.ts
+/**
+ * A role definition keyed by role name. Entries describe what the role may do —
+ * parameters and labels, never compiled permissions. They are expanded into
+ * `{ targets, annotations }` when the constellation is deployed, so that a
+ * stored revision always compiles through the current compilers.
+ */
+type RoleDef = {
+  members: readonly AddressOrRef[];
+  permissions: readonly PermissionEntry[];
+};
+type User = {
+  id: UUID;
+  fullName: string;
+  personalSafes: Record<number, {
+    address: Lowercase<Address>;
+    active: boolean;
+  }>;
+};
+type Account = {
+  id: UUID;
+  label: string;
+  address: Lowercase<Address>;
+  chain: ChainId; /** True for accounts promoted to a workspace vault. */
+  vault: boolean;
+};
+/**
+ * Accounts grouped by node type within a workspace. Per-type maps keep
+ * bracket-accessor namespaces separate: a SAFE and a ROLES mod sharing a
+ * label don't collide, and `eth.safe[...]` IntelliSense doesn't suggest
+ * ROLES mod labels (and vice versa).
+ */
+type WorkspaceAccounts = {
+  workspaceId: UUID;
+  workspaceName: string;
+  safes: Readonly<Record<string, Account>>;
+  rolesMods: Readonly<Record<string, Account>>;
+  delays: Readonly<Record<string, Account>>;
+};
+/** Shape of the codegen data produced by `zodiac pull-org`. */
+type CodegenData = {
+  users: Readonly<Record<string, User>>;
+  accounts: Readonly<Record<string, WorkspaceAccounts>>;
+};
+type GeneratedCodegen = ZodiacGeneratedCodegen extends CodegenData ? ZodiacGeneratedCodegen : CodegenData;
+type ConstellationOpts<C extends CodegenData> = {
+  /** Workspace to scope accounts and roles to. */workspace: keyof C['accounts'] & string; /** Human-readable label for this constellation. */
+  label: string; /** Target chain for all nodes in this constellation. */
+  chain: ChainId;
+};
+type ConstellationInternalOpts<C extends CodegenData> = {
+  /** Injected codegen data (used for testing). */codegen?: C;
+};
+type Prettify<T> = { readonly [K in keyof T]: T[K] } & {};
+type SafeEntries<C extends CodegenData, W extends keyof C['accounts']> = C['accounts'][W]['safes'];
+type RolesEntries<C extends CodegenData, W extends keyof C['accounts']> = C['accounts'][W]['rolesMods'];
+type NodeType = 'SAFE' | 'ROLES' | 'DELAY';
+/** A reference to a node used in `owners`, `modules`, `target`, etc. */
+type NodeRef = Readonly<{
+  type: NodeType;
+  label: string;
+  chain: ChainId;
+}>;
+/** A blockchain address (checksummed or lowercase) or a reference to another
+ * node in the constellation. Values are normalized to lowercase before being
+ * sent to the API. */
+type AddressOrRef = Address | NodeRef;
+type NodeBase = Readonly<{
+  /** Human-readable identifier, unique within the constellation. */label: string; /** Chain the node is deployed on. */
+  chain: ChainId;
+  /** Set for existing nodes (from codegen or bound by address), absent for new
+   * nodes. Accepts checksummed or lowercase; normalized to lowercase on push. */
+  address?: Address; /** Deployment nonce — required for new nodes, optional for existing. */
+  nonce?: bigint;
+}>;
+/** A safe node spec — existing vault ref or new safe with required config. */
+type SafeNode = NodeBase & Readonly<{
+  /** Discriminator identifying this node as a Safe. */type: 'SAFE'; /** Number of owner signatures required to execute a transaction. */
+  threshold: number; /** Safe owner addresses or node references. */
+  owners: readonly (string | NodeRef)[]; /** Module addresses or node references enabled on the safe. */
+  modules?: readonly (string | NodeRef)[]; /** Whether this safe shall appear as a vault in the workspace. @default false */
+  vault?: boolean;
+}>;
+/** A roles modifier node spec — existing vault ref or new roles with modifier config. */
+type RolesNode = NodeBase & Readonly<{
+  /** Discriminator identifying this node as a Roles modifier. */type: 'ROLES'; /** The safe that this roles modifier controls. */
+  target?: AddressOrRef; /** The account that is allowed to update the configuration of the Roles mod. */
+  owner?: AddressOrRef; /** The account that calls will be executed from. */
+  avatar?: AddressOrRef; /** MultiSend contract addresses for batched transactions. */
+  multisend?: readonly Address[];
+  /** Role definitions configured on this modifier. Pass `null` for a key to
+   * clear that role; unmentioned roles are left untouched. */
+  roles?: Record<string, RoleDef | null>;
+  /** Spending allowances configured on this modifier, keyed by name. Pass
+   * `null` for a key to clear that allowance; unmentioned allowances are
+   * left untouched. */
+  allowances?: Record<string, AllowanceSpec | null>;
+}>;
+/** Any complete node that can be passed to `push()`. */
+type ConstellationNode = SafeNode | RolesNode;
+type NewSafeProps = {
+  /** Deployment nonce for CREATE2 address derivation. */nonce: bigint; /** Number of owner signatures required to execute a transaction. */
+  threshold: number; /** Safe owner addresses or node references. */
+  owners: readonly AddressOrRef[]; /** Module addresses or node references to enable on the safe. */
+  modules?: readonly AddressOrRef[]; /** Whether this safe is a workspace vault. @default false */
+  vault?: boolean;
+};
+/** Configuration shared by both ways of declaring a roles modifier. */
+type RolesConfig = {
+  /** The safe that this roles modifier controls. Defaults to the new safe with the same label, when one exists. */target?: AddressOrRef; /** The account that calls will be executed from. Defaults to `target` value */
+  avatar?: AddressOrRef; /** The account that is allowed to update the configuration of the Roles Mod. Defaults to `target` value */
+  owner?: AddressOrRef; /** MultiSend contract addresses for batched transactions. Defaults to `['0x38869bf66a61cf6bdb996a6ae40d5853fd43b526', '0x9641d764fc13c8b624c04430c7356c1c7c8102e2']` */
+  multisend?: readonly Address[];
+  /** Role definitions to configure on this modifier. Pass `null` for a key to
+   * clear that role; unmentioned roles are left untouched. */
+  roles?: Record<string, RoleDef | null>;
+  /** Spending allowances to configure on this modifier, keyed by name. Pass
+   * `null` for a key to clear that allowance; unmentioned allowances are
+   * left untouched. */
+  allowances?: Record<string, AllowanceSpec | null>;
+};
+/** Declare a brand-new roles modifier (address derived via CREATE2 from `nonce`). */
+type NewRolesByNonce = RolesConfig & {
+  /** Deployment nonce for CREATE2 address derivation. */nonce: bigint;
+};
+/** Bind to a roles modifier already deployed on-chain at a known address, to
+ * reconfigure its roles/allowances. Use this for mods not (yet) imported into
+ * the workspace — pass the address instead of a deployment `nonce`. */
+type ExistingRolesByAddress = RolesConfig & {
+  /** Address of the existing Roles mod to bind to and reconfigure. */address: Address;
+};
+type NewRolesProps = NewRolesByNonce | ExistingRolesByAddress;
+type ExistingNodeAccessor<Type extends string, K extends string, E, Ch extends ChainId, NP extends Record<string, any>> = Readonly<Prettify<E & {
+  type: Type;
+  label: K;
+  chain: Ch;
+}>> & (<O extends { [P in Exclude<keyof E & string, 'id' | 'label'>]?: any } & Partial<NP> = {}>(overrides?: { [P in Exclude<keyof E & string, 'id' | 'label'>]?: any } & Partial<NP> & O) => Readonly<Prettify<Omit<E, keyof O> & O & Partial<NP> & {
+  type: Type;
+  label: K;
+  chain: Ch;
+}>>);
+type NewNodeAccessor<Type extends string, Ch extends ChainId, NP extends Record<string, any>> = Readonly<Prettify<{
+  type: Type;
+  label: string;
+  chain: Ch;
+}>> & (<P extends NP>(props: P) => Readonly<Prettify<P & {
+  type: Type;
+  label: string;
+  chain: Ch;
+}>>);
+type EntityAccessor<Type extends string, Entries extends Record<string, any>, Ch extends ChainId = ChainId, NP extends Record<string, any> = Record<string, any>> = { readonly [K in keyof Entries & string]: ExistingNodeAccessor<Type, K, Entries[K], Ch, NP> } & {
+  readonly [key: string]: NewNodeAccessor<Type, Ch, NP>;
+};
+type UserAccessor<C extends CodegenData, Ch extends number> = { readonly [K in keyof C['users'] & string]: C['users'][K]['personalSafes'][Ch]['address'] };
+type ConstellationResult<C extends CodegenData, W extends keyof C['accounts'] = keyof C['accounts'], Ch extends ChainId = ChainId> = {
+  /** Access existing safes by label or create new ones with a new label.
+   * Only SAFE-typed accounts are suggested in IntelliSense. */
+  safe: EntityAccessor<'SAFE', SafeEntries<C, W>, Ch, NewSafeProps>;
+  /** Access existing roles modifiers by label or create new ones with a
+   * new label. Only ROLES-typed accounts are suggested in IntelliSense. */
+  roles: EntityAccessor<'ROLES', RolesEntries<C, W>, Ch, NewRolesProps>; /** Resolve a user's personal safe address on the constellation's chain. */
+  user: UserAccessor<C, Ch>;
+};
+/** @internal */
+/**
+ * Creates a constellation scoped to a workspace and chain.
+ *
+ * Use bracket access to reference existing accounts (vaults and other
+ * applied constellation nodes) or define new ones:
+ * ```ts
+ * const eth = constellation({ workspace: 'GG', label: 'my constellation', chain: 1 })
+ *
+ * const dao = eth.safe['GG DAO']              // existing account ref
+ * const roles = eth.roles['GG DAO']           // existing roles ref
+ * const newSafe = eth.safe['New Safe']({ nonce: 0n, threshold: 2, owners: [...], modules: [...] })
+ * ```
+ */
+declare function constellation<const C extends CodegenData = GeneratedCodegen, const W extends keyof C['accounts'] & string = keyof C['accounts'] & string, const Ch extends ChainId = ChainId>(opts: ConstellationOpts<C> & {
+  workspace: W;
+  chain: Ch;
+}, internal?: ConstellationInternalOpts<C>): ConstellationResult<C, W, Ch>;
+//#endregion
+//#region src/permissionEntries.d.ts
+/**
+ * An allowance key. Authored as a plain label, the way a role key is, and
+ * encoded to bytes32 when the constellation is deployed. An already-encoded
+ * key still works — `encodeKey` passes 32-byte hex through unchanged.
+ */
+type AllowanceKey = string;
+type SwapEntry = {
+  label: string;
+  action: {
+    type: 'swap';
+    sell: Address[];
+    buy: Address[];
+  };
+};
+type TransferEntry = {
+  label: string;
+  action: {
+    type: 'transfer';
+    tokens: Address[];
+    to: Address[];
+    bridge?: {
+      chain: ChainId;
+      to: Address[];
+      receive: Address[];
+    }[];
+    allowance?: AllowanceKey;
+  };
+};
+/**
+ * A permission's target, written either as an address or as another node in the
+ * same constellation.
+ *
+ * A policy is usually pushed alongside the accounts it governs, so the address
+ * a permission points at often does not exist yet. Naming the node instead
+ * sends a reference, and the address is substituted once it is derived at
+ * deploy — the same way a node is named as an owner, a module or an avatar.
+ */
+type PermissionTarget = `0x${string}` | ConstellationNode;
+type WithNodeTarget<P> = P extends {
+  targetAddress: `0x${string}`;
+} ? Omit<P, 'targetAddress'> & {
+  targetAddress: PermissionTarget;
+} : P;
+/** A `zodiac-roles-sdk` permission that may name a node as its target. */
+type ConstellationPermission = WithNodeTarget<Permission>;
+type LabelledPermissions = {
+  label: string;
+  permissions: ConstellationPermission[];
+};
+type DeFiKitEntry = {
+  label: string;
+  defiKit: {
+    protocol: string;
+    verb: string;
+    params: Record<string, DeFiKitParamValue>;
+  };
+};
+type DeFiKitParamValue = string | number | boolean | readonly (string | number | boolean)[] | null | undefined;
+/**
+ * One entry of a role's `permissions`. A bare permission stays valid, but every
+ * labelled form names something the app can show as a single card.
+ */
+type PermissionEntry = ConstellationPermission | LabelledPermissions | SwapEntry | TransferEntry | DeFiKitEntry;
+/** A role's full permission list — the type `permissions.ts` files satisfy. */
+type Permissions = readonly PermissionEntry[];
+//#endregion
+//#region src/actions.d.ts
+/**
+ * Allows signing CoW orders selling any of `sell` for any of `buy`. The
+ * parameters are compiled into permissions when the constellation is deployed,
+ * never here — a stored revision that carried its own copy would go stale as
+ * soon as the compiler changed.
+ */
+declare const swap: ({
+  label,
+  sell,
+  buy
+}: SwapParams) => SwapEntry;
+/**
+ * Allows transferring any of `tokens` to any of `to` on the role's own chain,
+ * and — through `bridge` — to recipients on other chains over Across. Both are
+ * optional on their own; a transfer names at least one recipient somewhere.
+ */
+declare const transfer: ({
+  label,
+  tokens,
+  to,
+  bridge,
+  allowance
+}: TransferParams) => TransferEntry;
+/**
+ * A labelled bag of `allow`-kit permissions — the code-side counterpart of the
+ * app's Custom action, for everything the other action types don't cover. It
+ * takes plain permissions, not other actions.
+ */
+declare const custom: ({
+  label,
+  permissions
+}: CustomParams) => LabelledPermissions;
+/**
+ * The DeFi Kit allow kit — same protocol, verb and parameter surface, plus a
+ * `label`. A DeFi Kit entry is nothing but its annotation: the permissions are
+ * fetched from the annotation's uri at deploy, so nothing is fetched here.
+ *
+ * Protocols and parameters are typed against the Ethereum kit, the widest of
+ * the chains DeFi Kit serves. Values that only exist on another chain still
+ * type-check; the API validates them when the annotation is resolved.
+ */
+declare const defikit: DeFiKit;
+type SwapParams = {
+  /** Names the action in the app. Never reaches the chain. */label: string; /** Tokens the role may sell. */
+  sell: readonly Address[]; /** Tokens the role may buy. */
+  buy: readonly Address[];
+};
+type TransferParams = {
+  /** Names the action in the app. Never reaches the chain. */label: string; /** Tokens the role may transfer. Use the zero address for the native token. */
+  tokens: readonly Address[];
+  /** Addresses the role may transfer to on the role's own chain. A node stands
+   * for its address, so only nodes that already have one — an account from your
+   * codegen, or one bound by address — can be named here. */
+  to?: readonly Recipient[]; /** Destinations on other chains, bridged over Across. */
+  bridge?: readonly BridgeTarget[];
+  /** Allowance capping what may be sent. Pass the allowance declared on the
+   * roles modifier, or its key. */
+  allowance?: AllowanceSpec | AllowanceKey;
+};
+type CustomParams = {
+  /** Names the action in the app. Never reaches the chain. */label: string;
+  permissions: readonly ConstellationPermission[];
+};
+/** An address, or a node that already knows the address it lives at. */
+type Recipient = Address | {
+  readonly address: Address;
+  readonly chain?: ChainId;
+};
+type BridgeTarget = {
+  /** The destination chain. Inferred from the recipients when they are nodes. */chain?: ChainId; /** Addresses the role may bridge to on the destination chain. */
+  to: readonly Recipient[]; /** Tokens the role may receive on the destination chain. */
+  receive: readonly Address[];
+};
+type EthereumKit = typeof allow;
+type DeFiKit = { readonly [Protocol in keyof EthereumKit]: { readonly [Verb in keyof EthereumKit[Protocol]]: DeFiKitVerb<EthereumKit[Protocol][Verb]> } };
+type DeFiKitVerb<Verb> = Verb extends ((params: infer Params) => unknown) ? (params: Params & {
+  label: string;
+}) => DeFiKitEntry : (params: {
+  label: string;
+}) => DeFiKitEntry;
+//#endregion
+export { PermissionEntry as a, ConstellationNode as c, transfer as i, constellation as l, defikit as n, PermissionTarget as o, swap as r, Permissions as s, custom as t };
+//# sourceMappingURL=actions-Dn5NC3oq.d.mts.map

package/dist/actions.d.mts

@@ -0,0 +1,2 @@
+import { a as PermissionEntry, i as transfer, n as defikit, o as PermissionTarget, r as swap, s as Permissions, t as custom } from "./actions-Dn5NC3oq.mjs";
+export { PermissionEntry, PermissionTarget, Permissions, custom, defikit, swap, transfer };

package/dist/actions.mjs

@@ -0,0 +1,92 @@
+import { r as recipientChains } from "./permissionEntries-D3fSVhwO.mjs";
+//#region src/actions.ts
+/**
+* Allows signing CoW orders selling any of `sell` for any of `buy`. The
+* parameters are compiled into permissions when the constellation is deployed,
+* never here — a stored revision that carried its own copy would go stale as
+* soon as the compiler changed.
+*/
+const swap = ({ label, sell, buy }) => ({
+	label,
+	action: {
+		type: "swap",
+		sell: [...sell],
+		buy: [...buy]
+	}
+});
+/**
+* Allows transferring any of `tokens` to any of `to` on the role's own chain,
+* and — through `bridge` — to recipients on other chains over Across. Both are
+* optional on their own; a transfer names at least one recipient somewhere.
+*/
+const transfer = ({ label, tokens, to = [], bridge = [], allowance }) => {
+	const entry = {
+		label,
+		action: {
+			type: "transfer",
+			tokens: [...tokens],
+			to: to.map(toAddress),
+			...bridge.length > 0 && { bridge: bridge.map(toBridgeTarget) },
+			...allowance != null && { allowance: allowanceKey(allowance) }
+		}
+	};
+	const chains = to.flatMap((recipient) => typeof recipient === "string" || recipient.chain == null ? [] : [recipient.chain]);
+	if (chains.length > 0) Object.defineProperty(entry, recipientChains, {
+		value: chains,
+		enumerable: false
+	});
+	return entry;
+};
+/**
+* A labelled bag of `allow`-kit permissions — the code-side counterpart of the
+* app's Custom action, for everything the other action types don't cover. It
+* takes plain permissions, not other actions.
+*/
+const custom = ({ label, permissions }) => ({
+	label,
+	permissions: [...permissions]
+});
+/**
+* The DeFi Kit allow kit — same protocol, verb and parameter surface, plus a
+* `label`. A DeFi Kit entry is nothing but its annotation: the permissions are
+* fetched from the annotation's uri at deploy, so nothing is fetched here.
+*
+* Protocols and parameters are typed against the Ethereum kit, the widest of
+* the chains DeFi Kit serves. Values that only exist on another chain still
+* type-check; the API validates them when the annotation is resolved.
+*/
+const defikit = new Proxy({}, { get: (_, protocol) => new Proxy({}, { get: (_, verb) => ({ label, ...params }) => ({
+	label,
+	defiKit: {
+		protocol,
+		verb,
+		params
+	}
+}) }) });
+const allowanceKey = (allowance) => typeof allowance === "string" ? allowance : allowance.key;
+const toAddress = (recipient) => typeof recipient === "string" ? recipient : recipient.address;
+/**
+* A node knows the chain it lives on, so a bridge target written with nodes
+* needs no `chain` of its own. Naming one anyway is allowed — a plain address
+* carries no chain — but a node that disagrees with it is a mistake worth
+* catching here rather than at deploy.
+*/
+const toBridgeTarget = ({ chain, to, receive }) => ({
+	chain: destinationChain(chain, to),
+	to: to.map(toAddress),
+	receive: [...receive]
+});
+const destinationChain = (chain, recipients) => {
+	let destination = chain;
+	for (const recipient of recipients) {
+		if (typeof recipient === "string" || recipient.chain == null) continue;
+		if (destination != null && destination !== recipient.chain) throw new Error(`A bridge target has one destination, but this one spans chains "${destination}" and "${recipient.chain}"`);
+		destination = recipient.chain;
+	}
+	if (destination == null) throw new Error("A bridge target needs a `chain` unless its recipients are nodes that know one");
+	return destination;
+};
+//#endregion
+export { custom, defikit, swap, transfer };
+
+//# sourceMappingURL=actions.mjs.map

package/dist/actions.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.mjs","names":[],"sources":["../src/actions.ts"],"sourcesContent":["import type { Address, ChainId } from '@zodiaceco/api-types'\nimport type { allow as ethereumKit } from 'defi-kit/eth'\nimport { recipientChains } from './permissionEntries'\nimport type {\n  AllowanceKey,\n  ConstellationPermission,\n  DeFiKitEntry,\n  LabelledPermissions,\n  PermissionEntry,\n  PermissionTarget,\n  SwapEntry,\n  TransferEntry,\n} from './permissionEntries'\nimport type { AllowanceSpec } from './types'\n\nexport type { PermissionEntry, PermissionTarget }\nexport type { Permissions } from './permissionEntries'\n\n/**\n * Allows signing CoW orders selling any of `sell` for any of `buy`. The\n * parameters are compiled into permissions when the constellation is deployed,\n * never here — a stored revision that carried its own copy would go stale as\n * soon as the compiler changed.\n */\nexport const swap = ({ label, sell, buy }: SwapParams): SwapEntry => ({\n  label,\n  action: { type: 'swap', sell: [...sell], buy: [...buy] },\n})\n\n/**\n * Allows transferring any of `tokens` to any of `to` on the role's own chain,\n * and — through `bridge` — to recipients on other chains over Across. Both are\n * optional on their own; a transfer names at least one recipient somewhere.\n */\nexport const transfer = ({\n  label,\n  tokens,\n  to = [],\n  bridge = [],\n  allowance,\n}: TransferParams): TransferEntry => {\n  const entry: TransferEntry = {\n    label,\n    action: {\n      type: 'transfer',\n      tokens: [...tokens],\n      to: to.map(toAddress),\n      ...(bridge.length > 0 && { bridge: bridge.map(toBridgeTarget) }),\n      ...(allowance != null && { allowance: allowanceKey(allowance) }),\n    },\n  }\n\n  // Remember which chains the `to` nodes live on so push() can refuse a\n  // recipient from another chain. Symbol-keyed: never serialized.\n  const chains = to.flatMap((recipient) =>\n    typeof recipient === 'string' || recipient.chain == null\n      ? []\n      : [recipient.chain]\n  )\n\n  if (chains.length > 0) {\n    Object.defineProperty(entry, recipientChains, {\n      value: chains,\n      enumerable: false,\n    })\n  }\n\n  return entry\n}\n\n/**\n * A labelled bag of `allow`-kit permissions — the code-side counterpart of the\n * app's Custom action, for everything the other action types don't cover. It\n * takes plain permissions, not other actions.\n */\nexport const custom = ({\n  label,\n  permissions,\n}: CustomParams): LabelledPermissions => ({\n  label,\n  permissions: [...permissions],\n})\n\n/**\n * The DeFi Kit allow kit — same protocol, verb and parameter surface, plus a\n * `label`. A DeFi Kit entry is nothing but its annotation: the permissions are\n * fetched from the annotation's uri at deploy, so nothing is fetched here.\n *\n * Protocols and parameters are typed against the Ethereum kit, the widest of\n * the chains DeFi Kit serves. Values that only exist on another chain still\n * type-check; the API validates them when the annotation is resolved.\n */\nexport const defikit: DeFiKit = new Proxy({} as DeFiKit, {\n  get: (_, protocol: string) =>\n    new Proxy(\n      {},\n      {\n        get:\n          (_, verb: string) =>\n          ({ label, ...params }: { label: string }) => ({\n            label,\n            defiKit: { protocol, verb, params },\n          }),\n      }\n    ),\n})\n\nconst allowanceKey = (allowance: AllowanceSpec | AllowanceKey) =>\n  typeof allowance === 'string' ? allowance : allowance.key\n\nconst toAddress = (recipient: Recipient): Address =>\n  typeof recipient === 'string' ? recipient : recipient.address\n\n/**\n * A node knows the chain it lives on, so a bridge target written with nodes\n * needs no `chain` of its own. Naming one anyway is allowed — a plain address\n * carries no chain — but a node that disagrees with it is a mistake worth\n * catching here rather than at deploy.\n */\nconst toBridgeTarget = ({ chain, to, receive }: BridgeTarget) => ({\n  chain: destinationChain(chain, to),\n  to: to.map(toAddress),\n  receive: [...receive],\n})\n\nconst destinationChain = (\n  chain: ChainId | undefined,\n  recipients: readonly Recipient[]\n): ChainId => {\n  let destination = chain\n\n  for (const recipient of recipients) {\n    if (typeof recipient === 'string' || recipient.chain == null) {\n      continue\n    }\n\n    if (destination != null && destination !== recipient.chain) {\n      throw new Error(\n        `A bridge target has one destination, but this one spans chains \"${destination}\" and \"${recipient.chain}\"`\n      )\n    }\n\n    destination = recipient.chain\n  }\n\n  if (destination == null) {\n    throw new Error(\n      'A bridge target needs a `chain` unless its recipients are nodes that know one'\n    )\n  }\n\n  return destination\n}\n\ntype SwapParams = {\n  /** Names the action in the app. Never reaches the chain. */\n  label: string\n  /** Tokens the role may sell. */\n  sell: readonly Address[]\n  /** Tokens the role may buy. */\n  buy: readonly Address[]\n}\n\ntype TransferParams = {\n  /** Names the action in the app. Never reaches the chain. */\n  label: string\n  /** Tokens the role may transfer. Use the zero address for the native token. */\n  tokens: readonly Address[]\n  /** Addresses the role may transfer to on the role's own chain. A node stands\n   * for its address, so only nodes that already have one — an account from your\n   * codegen, or one bound by address — can be named here. */\n  to?: readonly Recipient[]\n  /** Destinations on other chains, bridged over Across. */\n  bridge?: readonly BridgeTarget[]\n  /** Allowance capping what may be sent. Pass the allowance declared on the\n   * roles modifier, or its key. */\n  allowance?: AllowanceSpec | AllowanceKey\n}\n\ntype CustomParams = {\n  /** Names the action in the app. Never reaches the chain. */\n  label: string\n  permissions: readonly ConstellationPermission[]\n}\n\n/** An address, or a node that already knows the address it lives at. */\ntype Recipient =\n  | Address\n  | { readonly address: Address; readonly chain?: ChainId }\n\ntype BridgeTarget = {\n  /** The destination chain. Inferred from the recipients when they are nodes. */\n  chain?: ChainId\n  /** Addresses the role may bridge to on the destination chain. */\n  to: readonly Recipient[]\n  /** Tokens the role may receive on the destination chain. */\n  receive: readonly Address[]\n}\n\ntype EthereumKit = typeof ethereumKit\n\ntype DeFiKit = {\n  readonly [Protocol in keyof EthereumKit]: {\n    readonly [Verb in keyof EthereumKit[Protocol]]: DeFiKitVerb<\n      EthereumKit[Protocol][Verb]\n    >\n  }\n}\n\ntype DeFiKitVerb<Verb> = Verb extends (params: infer Params) => unknown\n  ? (params: Params & { label: string }) => DeFiKitEntry\n  : (params: { label: string }) => DeFiKitEntry\n"],"mappings":";;;;;;;;AAwBA,MAAa,QAAQ,EAAE,OAAO,MAAM,WAAkC;CACpE;CACA,QAAQ;EAAE,MAAM;EAAQ,MAAM,CAAC,GAAG,KAAK;EAAE,KAAK,CAAC,GAAG,IAAI;EAAE;CACzD;;;;;;AAOD,MAAa,YAAY,EACvB,OACA,QACA,KAAK,EAAE,EACP,SAAS,EAAE,EACX,gBACmC;CACnC,MAAM,QAAuB;EAC3B;EACA,QAAQ;GACN,MAAM;GACN,QAAQ,CAAC,GAAG,OAAO;GACnB,IAAI,GAAG,IAAI,UAAU;GACrB,GAAI,OAAO,SAAS,KAAK,EAAE,QAAQ,OAAO,IAAI,eAAe,EAAE;GAC/D,GAAI,aAAa,QAAQ,EAAE,WAAW,aAAa,UAAU,EAAE;GAChE;EACF;CAID,MAAM,SAAS,GAAG,SAAS,cACzB,OAAO,cAAc,YAAY,UAAU,SAAS,OAChD,EAAE,GACF,CAAC,UAAU,MAAM,CACtB;AAED,KAAI,OAAO,SAAS,EAClB,QAAO,eAAe,OAAO,iBAAiB;EAC5C,OAAO;EACP,YAAY;EACb,CAAC;AAGJ,QAAO;;;;;;;AAQT,MAAa,UAAU,EACrB,OACA,mBACwC;CACxC;CACA,aAAa,CAAC,GAAG,YAAY;CAC9B;;;;;;;;;;AAWD,MAAa,UAAmB,IAAI,MAAM,EAAE,EAAa,EACvD,MAAM,GAAG,aACP,IAAI,MACF,EAAE,EACF,EACE,MACG,GAAG,UACH,EAAE,OAAO,GAAG,cAAiC;CAC5C;CACA,SAAS;EAAE;EAAU;EAAM;EAAQ;CACpC,GACJ,CACF,EACJ,CAAC;AAEF,MAAM,gBAAgB,cACpB,OAAO,cAAc,WAAW,YAAY,UAAU;AAExD,MAAM,aAAa,cACjB,OAAO,cAAc,WAAW,YAAY,UAAU;;;;;;;AAQxD,MAAM,kBAAkB,EAAE,OAAO,IAAI,eAA6B;CAChE,OAAO,iBAAiB,OAAO,GAAG;CAClC,IAAI,GAAG,IAAI,UAAU;CACrB,SAAS,CAAC,GAAG,QAAQ;CACtB;AAED,MAAM,oBACJ,OACA,eACY;CACZ,IAAI,cAAc;AAElB,MAAK,MAAM,aAAa,YAAY;AAClC,MAAI,OAAO,cAAc,YAAY,UAAU,SAAS,KACtD;AAGF,MAAI,eAAe,QAAQ,gBAAgB,UAAU,MACnD,OAAM,IAAI,MACR,mEAAmE,YAAY,SAAS,UAAU,MAAM,GACzG;AAGH,gBAAc,UAAU;;AAG1B,KAAI,eAAe,KACjB,OAAM,IAAI,MACR,gFACD;AAGH,QAAO"}

package/dist/allow/index.d.mts

@@ -1,2 +1,2 @@
-import { a as EVERYTHING, c as Scoping, i as ConditionFunction, l as TargetPermission, n as ChainPrefix, o as FunctionPermission, r as chainIdFor, s as Options, t as CHAIN_IDS, u as buildAllowKit } from "../index-DoZbhpS6.mjs";
+import { a as EVERYTHING, c as Scoping, i as ConditionFunction, l as TargetPermission, n as ChainPrefix, o as FunctionPermission, r as chainIdFor, s as Options, t as CHAIN_IDS, u as buildAllowKit } from "../index-CnH26Z_A.mjs";
 export { CHAIN_IDS, ChainPrefix, ConditionFunction, EVERYTHING, FunctionPermission, Options, Scoping, TargetPermission, buildAllowKit, chainIdFor };

package/dist/allow/index.mjs

@@ -1,3 +1,3 @@
-import { n as chainIdFor, t as CHAIN_IDS } from "../networks-BTW1qAAa.mjs";
-import { n as EVERYTHING, t as buildAllowKit } from "../allow-CzPpzclq.mjs";
+import { n as chainIdFor, t as CHAIN_IDS } from "../networks-B0H4Uoyh.mjs";
+import { n as EVERYTHING, t as buildAllowKit } from "../allow-CrDzDtxx.mjs";
 export { CHAIN_IDS, EVERYTHING, buildAllowKit, chainIdFor };

package/dist/{allow-CzPpzclq.mjs → allow-CrDzDtxx.mjs}

@@ -1,4 +1,4 @@
-import { a as walkContracts, i as readAbi } from "./networks-BTW1qAAa.mjs";
+import { a as walkContracts, i as readAbi } from "./networks-B0H4Uoyh.mjs";
 import { Operator, ParameterType, c, coercePermission } from "zodiac-roles-sdk";
 import { Interface, isError } from "ethers";
 //#region src/allow/types.ts
@@ -13,7 +13,7 @@ function buildAllowKit(abisDir, contractsConfig) {
 			attachAt(kit, [node.chain, ...node.segments], missingAbiProxy(node));
 			continue;
 		}
-		attachAt(kit, [node.chain, ...node.segments], makeAllowContract(node.address, abi));
+		attachAt(kit, [node.chain, ...node.segments], makeAllowContract(node.address, abi, [node.chain, ...node.segments].join(".")));
 	}
 	return kit;
 }
@@ -35,9 +35,19 @@ function missingAbiProxy(node) {
 		has: explain
 	});
 }
-function makeAllowContract(address, abi) {
+function makeAllowContract(address, abi, path) {
 	const iface = Interface.from(abi);
 	const lowerAddr = address.toLowerCase();
+	const overloads = /* @__PURE__ */ new Map();
+	iface.forEachFunction((fn) => {
+		if (fn.stateMutability === "view" || fn.stateMutability === "pure") return;
+		overloads.set(fn.name, [...overloads.get(fn.name) ?? [], fn]);
+	});
+	const ambiguous = (prop) => (overloads.get(prop)?.length ?? 0) > 1;
+	const explainAmbiguity = (prop) => {
+		const signatures = overloads.get(prop).map((fn) => fn.format("sighash"));
+		throw new Error(`\`allow.${path}.${prop}\` is ambiguous: ${address} has ${signatures.length} functions named "${prop}". Name the overload you mean by its full signature — ` + signatures.map((sig) => `allow.${path}[${JSON.stringify(sig)}]`).join(" or ") + `.`);
+	};
 	const allowEverything = (options) => ({
 		targetAddress: lowerAddr,
 		send: options?.send,
@@ -57,12 +67,13 @@ function makeAllowContract(address, abi) {
 		get: (_target, prop) => {
 			if (prop === EVERYTHING) return allowEverything;
 			if (typeof prop !== "string") return void 0;
+			if (ambiguous(prop)) explainAmbiguity(prop);
 			if (!has(prop)) return void 0;
 			return makeAllowFunction(iface.getFunction(prop), lowerAddr);
 		},
 		has: (_target, prop) => {
 			if (prop === EVERYTHING) return true;
-			return typeof prop === "string" && has(prop);
+			return typeof prop === "string" && !ambiguous(prop) && has(prop);
 		}
 	});
 }
@@ -118,4 +129,4 @@ const applyOptions = (permission, options) => {
 //#endregion
 export { EVERYTHING as n, buildAllowKit as t };
 
-//# sourceMappingURL=allow-CzPpzclq.mjs.map
+//# sourceMappingURL=allow-CrDzDtxx.mjs.map

package/dist/allow-CrDzDtxx.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"allow-CrDzDtxx.mjs","names":[],"sources":["../src/allow/types.ts","../src/allow/runtime.ts"],"sourcesContent":["import type { BigNumberish, BytesLike, ParamType } from 'ethers'\nimport type {\n  Condition,\n  FunctionPermission,\n  TargetPermission,\n} from 'zodiac-roles-sdk'\n\nexport type Options = {\n  send?: boolean\n  delegatecall?: boolean\n  etherWithinAllowance?: `0x${string}`\n  callWithinAllowance?: `0x${string}`\n}\n\nexport type PrimitiveValue = BigNumberish | BytesLike | string | boolean\n\n// Signature matches `zodiac-roles-sdk` so values from `c.*` are assignable.\nexport type ConditionFunction<T = unknown> = (\n  abiType: ParamType,\n  _?: T\n) => Condition\n\ntype RequireAtLeastOne<T> = {\n  [K in keyof T]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<keyof T, K>>>\n}[keyof T]\n\ntype ArrayElement<T extends readonly unknown[]> = T extends readonly (infer U)[]\n  ? U\n  : never\n\nexport type PrimitiveScoping<T extends PrimitiveValue> =\n  | T\n  | ConditionFunction<T>\n\nexport type ArrayScoping<T extends readonly any[]> =\n  | readonly Scoping<ArrayElement<T>>[]\n  | ConditionFunction<T>\n\nexport type StructScoping<T extends { [key: string]: any }> =\n  | RequireAtLeastOne<{ [K in keyof T]?: Scoping<T[K]> }>\n  | ConditionFunction<T>\n\nexport type Scoping<T> = T extends PrimitiveValue\n  ? PrimitiveScoping<T>\n  : T extends readonly any[]\n    ? ArrayScoping<T>\n    : T extends { [key: string]: any }\n      ? StructScoping<T>\n      : unknown\n\nexport type { FunctionPermission, TargetPermission }\n\nexport const EVERYTHING = Symbol.for('@zodiaceco/allow-kit/EVERYTHING')\nexport type EVERYTHING = typeof EVERYTHING\n","import { Interface, FunctionFragment, isError, type InterfaceAbi } from 'ethers'\nimport { c, coercePermission, ParameterType, Operator } from 'zodiac-roles-sdk'\nimport type {\n  Condition,\n  FunctionPermission,\n  TargetPermission,\n} from 'zodiac-roles-sdk'\nimport { readAbi, walkContracts, type ContractNode } from './abi'\nimport { EVERYTHING, type Options } from './types'\n\nexport function buildAllowKit(\n  abisDir: string,\n  contractsConfig: Record<string, any>\n): Record<string, any> {\n  const kit: Record<string, any> = {}\n  for (const node of walkContracts(contractsConfig)) {\n    const abi = readAbi(abisDir, node)\n    if (!abi) {\n      // Defer the error until the user touches this contract — otherwise an\n      // ABI missing for one chain crashes all unrelated role definitions.\n      attachAt(kit, [node.chain, ...node.segments], missingAbiProxy(node))\n      continue\n    }\n    attachAt(\n      kit,\n      [node.chain, ...node.segments],\n      makeAllowContract(\n        node.address,\n        abi as InterfaceAbi,\n        [node.chain, ...node.segments].join('.')\n      )\n    )\n  }\n  return kit\n}\n\nfunction attachAt(root: Record<string, any>, segments: string[], value: any) {\n  let cursor = root\n  for (let i = 0; i < segments.length - 1; i++) {\n    const seg = segments[i]!\n    if (!(seg in cursor)) cursor[seg] = {}\n    cursor = cursor[seg]\n  }\n  cursor[segments[segments.length - 1]!] = value\n}\n\nfunction missingAbiProxy(node: ContractNode) {\n  const explain = () => {\n    throw new Error(\n      `ABI missing for ${node.chain}.${node.segments.join('.')} ` +\n        `(${node.address}). Run \\`zodiac pull-contracts\\` to fetch it, or ` +\n        `paste the ABI JSON manually at <abisDir>/${node.chain}/${node.segments.join('/')}.json`\n    )\n  }\n  return new Proxy(\n    {},\n    {\n      get: explain,\n      has: explain,\n    }\n  )\n}\n\nfunction makeAllowContract(\n  address: `0x${string}`,\n  abi: InterfaceAbi,\n  path: string\n): Record<string | symbol, any> {\n  const iface = Interface.from(abi)\n  const lowerAddr = address.toLowerCase() as `0x${string}`\n\n  // Permissionable functions grouped by bare name, so an ambiguous one can be\n  // told apart from an unknown one. `Interface.getFunction` reports both as\n  // INVALID_ARGUMENT, and the two want opposite answers: an unknown name is\n  // simply not a member, an ambiguous one is a member the caller has not\n  // finished naming.\n  const overloads = new Map<string, FunctionFragment[]>()\n  iface.forEachFunction((fn) => {\n    if (fn.stateMutability === 'view' || fn.stateMutability === 'pure') return\n    overloads.set(fn.name, [...(overloads.get(fn.name) ?? []), fn])\n  })\n\n  const ambiguous = (prop: string) => (overloads.get(prop)?.length ?? 0) > 1\n\n  const explainAmbiguity = (prop: string): never => {\n    const signatures = overloads.get(prop)!.map((fn) => fn.format('sighash'))\n    throw new Error(\n      `\\`allow.${path}.${prop}\\` is ambiguous: ${address} has ` +\n        `${signatures.length} functions named \"${prop}\". Name the overload ` +\n        `you mean by its full signature — ` +\n        signatures\n          .map((sig) => `allow.${path}[${JSON.stringify(sig)}]`)\n          .join(' or ') +\n        `.`\n    )\n  }\n\n  const allowEverything = (options?: Options): TargetPermission => ({\n    targetAddress: lowerAddr,\n    send: options?.send,\n    delegatecall: options?.delegatecall,\n  })\n\n  const has = (name: string) => {\n    try {\n      const fn = iface.getFunction(name)\n      if (!fn) return false\n      return fn.stateMutability !== 'view' && fn.stateMutability !== 'pure'\n    } catch (error) {\n      if (!isError(error as any, 'INVALID_ARGUMENT')) throw error\n      return false\n    }\n  }\n\n  return new Proxy(\n    {},\n    {\n      get: (_target, prop) => {\n        if (prop === EVERYTHING) return allowEverything\n        if (typeof prop !== 'string') return undefined\n        if (ambiguous(prop)) explainAmbiguity(prop)\n        if (!has(prop)) return undefined\n        const fn = iface.getFunction(prop)!\n        return makeAllowFunction(fn, lowerAddr)\n      },\n      // An ambiguous bare name is not a member — only the full signatures are.\n      // `in` answers that question; reaching for the property explains it.\n      has: (_target, prop) => {\n        if (prop === EVERYTHING) return true\n        return typeof prop === 'string' && !ambiguous(prop) && has(prop)\n      },\n    }\n  )\n}\n\nfunction makeAllowFunction(\n  fn: FunctionFragment,\n  targetAddress: `0x${string}`\n): (...args: any[]) => FunctionPermission {\n  const inputs = fn.inputs\n  return (...args: any[]) => {\n    const scopings = args.slice(0, inputs.length)\n    const hasScopings = scopings.some((s) => s !== undefined && s !== null)\n    const options: Options = args[inputs.length] ?? {}\n    const condition = hasScopings\n      ? c.calldataMatches(scopings, inputs)()\n      : undefined\n    const preset = {\n      targetAddress,\n      signature: fn.format('sighash'),\n      condition,\n    }\n    return applyOptions(coercePermission(preset as any) as any, options)\n  }\n}\n\nconst emptyCalldataMatches: Condition = {\n  paramType: ParameterType.Calldata,\n  operator: Operator.Matches,\n  children: [],\n}\n\nconst applyGlobalAllowance = (\n  condition: Condition | undefined,\n  allowanceCondition: Condition\n): Condition => {\n  const base = condition ?? emptyCalldataMatches\n  if (\n    base.paramType !== ParameterType.Calldata ||\n    base.operator !== Operator.Matches\n  ) {\n    throw new Error(\n      'Global allowance can only be applied to calldata matches nodes'\n    )\n  }\n  return {\n    ...base,\n    children: [...(base.children ?? []), allowanceCondition],\n  }\n}\n\nconst applyOptions = (\n  permission: FunctionPermission & { condition?: Condition },\n  options: Options\n): FunctionPermission => {\n  let condition = permission.condition\n  if (options.etherWithinAllowance) {\n    if (!options.send) {\n      throw new Error(\n        '`etherWithinAllowance` can only be used if `send` is allowed'\n      )\n    }\n    condition = applyGlobalAllowance(condition, {\n      paramType: ParameterType.None,\n      operator: Operator.EtherWithinAllowance,\n      compValue: options.etherWithinAllowance,\n    })\n  }\n  if (options.callWithinAllowance) {\n    condition = applyGlobalAllowance(condition, {\n      paramType: ParameterType.None,\n      operator: Operator.CallWithinAllowance,\n      compValue: options.callWithinAllowance,\n    })\n  }\n  return {\n    ...permission,\n    send: options.send,\n    delegatecall: options.delegatecall,\n    condition,\n  }\n}\n"],"mappings":"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"}