@zodiaceco/sdk 1.13.2 → 2.0.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-DS5XoMiq.d.mts

@@ -0,0 +1,152 @@
+import { Permission } from "zodiac-roles-sdk";
+import { Address, ApplyConstellationPayload, ChainId } from "@zodiaceco/api-types";
+import { allow } from "defi-kit/eth";
+
+//#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;
+  };
+};
+type LabelledPermissions = {
+  label: string;
+  permissions: Permission[];
+};
+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 = Permission | LabelledPermissions | SwapEntry | TransferEntry | DeFiKitEntry;
+/** A role's full permission list — the type `permissions.ts` files satisfy. */
+type Permissions = readonly PermissionEntry[];
+//#endregion
+//#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/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 Permission[];
+};
+/** 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 { AllowanceSpec as a, transfer as i, defikit as n, PermissionEntry as o, swap as r, Permissions as s, custom as t };
+//# sourceMappingURL=actions-DS5XoMiq.d.mts.map

package/dist/actions.d.mts

@@ -0,0 +1,2 @@
+import { i as transfer, n as defikit, o as PermissionEntry, r as swap, s as Permissions, t as custom } from "./actions-DS5XoMiq.mjs";
+export { PermissionEntry, 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 type { Permission } from 'zodiac-roles-sdk'\nimport { recipientChains } from './permissionEntries'\nimport type {\n  AllowanceKey,\n  DeFiKitEntry,\n  LabelledPermissions,\n  PermissionEntry,\n  SwapEntry,\n  TransferEntry,\n} from './permissionEntries'\nimport type { AllowanceSpec } from './types'\n\nexport type { PermissionEntry }\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 Permission[]\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":";;;;;;;;AAuBA,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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"}

package/dist/cli/config.mjs

@@ -1,2 +1,2 @@
-import { a as resolveAbisDir, i as loadConfig, n as defineConfig, r as ensureConfigStub, t as DEFAULT_ABIS_DIR } from "../config-D5ArAp07.mjs";
+import { a as resolveAbisDir, i as loadConfig, n as defineConfig, r as ensureConfigStub, t as DEFAULT_ABIS_DIR } from "../config-D0FqysME.mjs";
 export { DEFAULT_ABIS_DIR, defineConfig, ensureConfigStub, loadConfig, resolveAbisDir };

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { n as resolveZodiacDir, t as ApiClient } from "./api-C49DoaPC.mjs";
-import { a as walkContracts, i as readAbi, n as chainIdFor, o as writeAbi, r as abiFilePath } from "./networks-BTW1qAAa.mjs";
-import { a as resolveAbisDir, i as loadConfig, o as findProjectRoot, r as ensureConfigStub } from "./config-D5ArAp07.mjs";
+import { a as walkContracts, i as readAbi, n as chainIdFor, o as writeAbi, r as abiFilePath } from "./networks-B0H4Uoyh.mjs";
+import { a as resolveAbisDir, i as loadConfig, o as findProjectRoot, r as ensureConfigStub } from "./config-D0FqysME.mjs";
 import fs, { existsSync, readFileSync, writeFileSync } from "node:fs";
 import path, { basename, join, resolve } from "node:path";
 import { invariant } from "@epic-web/invariant";
@@ -381,15 +381,13 @@ function renderPropKey(name) {
 }
 function renderContractType(node, abi, indent) {
 	const members = [];
-	const seen = /* @__PURE__ */ new Set();
 	members.push(`${indent}  [EVERYTHING]: (options?: Options) => TargetPermission;`);
-	for (const fragment of abi) {
-		if (fragment.type !== "function") continue;
-		if (fragment.stateMutability === "view" || fragment.stateMutability === "pure") continue;
-		const name = fragment.name;
-		if (!name || seen.has(name)) continue;
-		seen.add(name);
-		members.push(renderFunctionSignature(fragment, indent + "  "));
+	for (const overloads of groupByName(abi).values()) {
+		const overloaded = overloads.length > 1;
+		for (const fragment of overloads) {
+			const key = overloaded ? signatureFor(fragment) : fragment.name;
+			members.push(renderFunctionSignature(fragment, key, indent + "  "));
+		}
 	}
 	return [
 		"{",
@@ -397,8 +395,42 @@ function renderContractType(node, abi, indent) {
 		`${indent}}`
 	].join("\n");
 }
-function renderFunctionSignature(fragment, indent) {
-	const name = renderPropKey(fragment.name);
+/**
+* Permissionable fragments grouped by function name, in ABI order. Two
+* fragments that render the same signature are the same function listed twice,
+* so they collapse — emitting the key twice would not compile.
+*/
+function groupByName(abi) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const fragment of abi) {
+		if (fragment.type !== "function") continue;
+		if (fragment.stateMutability === "view" || fragment.stateMutability === "pure") continue;
+		const name = fragment.name;
+		if (!name) continue;
+		const overloads = byName.get(name) ?? [];
+		if (overloads.some((f) => signatureFor(f) === signatureFor(fragment))) continue;
+		byName.set(name, [...overloads, fragment]);
+	}
+	return byName;
+}
+/** The canonical `name(type,…)` form, which is how `Interface.getFunction`
+* addresses one overload of a name. */
+function signatureFor(fragment) {
+	const inputs = fragment.inputs ?? [];
+	return `${fragment.name}(${inputs.map(canonicalTypeFor).join(",")})`;
+}
+function canonicalTypeFor(fragment) {
+	const type = fragment.type;
+	const arrayMatch = /^(.*)\[(\d*)\]$/.exec(type);
+	if (arrayMatch) return `${canonicalTypeFor({
+		...fragment,
+		type: arrayMatch[1]
+	})}[${arrayMatch[2]}]`;
+	if (type === "tuple") return `(${(fragment.components ?? []).map(canonicalTypeFor).join(",")})`;
+	return type;
+}
+function renderFunctionSignature(fragment, key, indent) {
+	const name = renderPropKey(key);
 	const params = [];
 	for (const input of fragment.inputs ?? []) {
 		const paramName = sanitizeParamName(input.name || `arg${params.length}`, params.length);