@sage-protocol/sdk 0.1.10 → 0.1.13

package/README.md

@@ -621,7 +621,7 @@ const totalByTag = await sdk.prompt.getByTagCount({ provider, registry, tagHash
 const page = await sdk.prompt.listByTagPage({ provider, registry, tagHash, offset: 0, limit: 25 });
 ```
 
-Operator SubDAO helpers
+Team SubDAO helpers
 ```js
 // One-click create + operatorize
 const res = await sdk.subdao.createOperatorSubDAO({
@@ -629,7 +629,7 @@ const res = await sdk.subdao.createOperatorSubDAO({
   factoryAddress: FACTORY,
   operator: '0xSafeOrEOA',
   name: 'My SubDAO',
-  description: 'Operator controlled',
+  description: 'Team controlled (Timelock + Safe/EOA executor)',
   accessModel: 0,
   minStakeAmount: 0n,
   burnAmount: 1500n * 10n**18n,

package/dist/browser/index.mjs

@@ -14,7 +14,7 @@ var require_package = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@sage-protocol/sdk",
-      version: "0.1.10",
+      version: "0.1.12",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -154,6 +154,11 @@ var require_abi = __commonJS({
     var FactoryWrite = [
       "function createSubDAO(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount) returns (address subDAO, address registry)",
       "function createSubDAOWithStable(string name, string description, uint8 accessModel, uint256 minStakeAmount, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
+      "function createSubDAOWithParams(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, uint256 votingDelay, uint256 votingPeriod, uint256 proposalThreshold, uint256 quorumPercentage, uint8 initialForkPolicy, uint8 initialMembershipPolicy, string profileCID) returns (address subDAO, address registry)",
+      "function createSubDAOOperatorWithStable(string name, string description, uint8 accessModel, uint256 minStakeAmount, address operatorExecutor, address operatorAdmin, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
+      "function createSubDAOOperatorWithStableAdvanced(string name, string description, uint8 accessModel, uint256 minStakeAmount, address operatorExecutor, address operatorAdmin, bool anyoneExec, bool governorProposer, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
+      "function createSubDAOOperator(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, address operatorExecutor, address operatorAdmin) returns (address subDAO, address registry)",
+      "function createSubDAOOperatorAdvanced(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, address operatorExecutor, address operatorAdmin, bool anyoneExec, bool governorProposer) returns (address subDAO, address registry)",
       "function createForkedSubDAO(string newName, string newDescription, string originalName, address originalSubDAO, address forker) returns (address subDAO, address registry)",
       "function createForkedSubDAOWithStable(string newName, string newDescription, string originalName, address originalSubDAO, address forker, uint64 authorizationNonce, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)"
     ];

package/dist/index.cjs

@@ -14,7 +14,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@sage-protocol/sdk",
-      version: "0.1.10",
+      version: "0.1.12",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -154,6 +154,11 @@ var require_abi = __commonJS({
     var FactoryWrite = [
       "function createSubDAO(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount) returns (address subDAO, address registry)",
       "function createSubDAOWithStable(string name, string description, uint8 accessModel, uint256 minStakeAmount, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
+      "function createSubDAOWithParams(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, uint256 votingDelay, uint256 votingPeriod, uint256 proposalThreshold, uint256 quorumPercentage, uint8 initialForkPolicy, uint8 initialMembershipPolicy, string profileCID) returns (address subDAO, address registry)",
+      "function createSubDAOOperatorWithStable(string name, string description, uint8 accessModel, uint256 minStakeAmount, address operatorExecutor, address operatorAdmin, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
+      "function createSubDAOOperatorWithStableAdvanced(string name, string description, uint8 accessModel, uint256 minStakeAmount, address operatorExecutor, address operatorAdmin, bool anyoneExec, bool governorProposer, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
+      "function createSubDAOOperator(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, address operatorExecutor, address operatorAdmin) returns (address subDAO, address registry)",
+      "function createSubDAOOperatorAdvanced(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, address operatorExecutor, address operatorAdmin, bool anyoneExec, bool governorProposer) returns (address subDAO, address registry)",
       "function createForkedSubDAO(string newName, string newDescription, string originalName, address originalSubDAO, address forker) returns (address subDAO, address registry)",
       "function createForkedSubDAOWithStable(string newName, string newDescription, string originalName, address originalSubDAO, address forker, uint64 authorizationNonce, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)"
     ];
@@ -2516,7 +2521,7 @@ var require_governance = __commonJS({
       /**
        * Detect governance mode and operator status.
        * Heuristics mirror CLI detectGovMode.
-       * Returns { operator: boolean, governance: 'Bootstrap'|'Token'|'Unknown', governor, timelock, subdao, stakeRequired, depositWei }
+       * Returns { operator: boolean, governance: 'Personal'|'Community'|'Unknown', governor, timelock, subdao, stakeRequired, depositWei }
        */
       detectMode: async function detectMode({ provider, governor, timelock: timelock2, subdao: subdao2 }) {
         const out = {
@@ -2536,7 +2541,7 @@ var require_governance = __commonJS({
             if (!timelock2) out.timelock = await sub.timelock();
             try {
               const mode = await sub.getGovernanceMode();
-              out.governance = Number(mode) === 0 ? "Bootstrap" : "Token";
+              out.governance = Number(mode) === 0 ? "Personal" : "Community";
             } catch (_) {
             }
           }
@@ -3981,7 +3986,17 @@ var require_factory = __commonJS({
       ] = await Promise.all([
         contract.stableFeeToken().catch(() => null),
         contract.stableCreationFee().catch(() => null),
-        contract.feeReceiver().catch(() => null),
+        (async () => {
+          try {
+            return await contract.stableFeeReceiver();
+          } catch (_) {
+            try {
+              return await contract.feeReceiver();
+            } catch {
+              return null;
+            }
+          }
+        })(),
         contract.allowStableFee().catch(() => null),
         contract.stablePromptForkFee().catch(() => null),
         contract.allowStablePromptForkFee().catch(() => null),
@@ -4148,6 +4163,102 @@ var require_factory = __commonJS({
       ]);
       return { to: addr, data: payload, value: 0n };
     }
+    function buildCreateSubDAOWithParamsTx({
+      factory: factory2,
+      name,
+      description,
+      accessModel,
+      minStakeAmount,
+      burnAmount,
+      votingDelay,
+      votingPeriod,
+      proposalThreshold,
+      quorumPercentage,
+      initialForkPolicy,
+      initialMembershipPolicy,
+      profileCID
+    }) {
+      const addr = normalise(factory2, "factory");
+      const payload = FactoryWriteInterface.encodeFunctionData("createSubDAOWithParams", [
+        String(name),
+        String(description),
+        Number(accessModel),
+        BigInt(minStakeAmount),
+        BigInt(burnAmount),
+        BigInt(votingDelay),
+        BigInt(votingPeriod),
+        BigInt(proposalThreshold),
+        BigInt(quorumPercentage),
+        Number(initialForkPolicy),
+        Number(initialMembershipPolicy),
+        String(profileCID ?? "")
+      ]);
+      return { to: addr, data: payload, value: 0n };
+    }
+    function buildCreateOperatorSubDAOWithStableTx({
+      factory: factory2,
+      name,
+      description,
+      accessModel,
+      minStakeAmount,
+      operatorExecutor,
+      operatorAdmin,
+      permit
+    }) {
+      const addr = normalise(factory2, "factory");
+      if (!permit) throw new SageSDKError(CODES.INVALID_ARGS, "permit required for operator stable creation");
+      const tuple = [
+        BigInt(permit.value ?? 0n),
+        BigInt(permit.deadline ?? 0n),
+        Number(permit.v ?? 0),
+        permit.r ?? "0x0000000000000000000000000000000000000000000000000000000000000000",
+        permit.s ?? "0x0000000000000000000000000000000000000000000000000000000000000000"
+      ];
+      const payload = FactoryWriteInterface.encodeFunctionData("createSubDAOOperatorWithStable", [
+        String(name),
+        String(description),
+        Number(accessModel),
+        BigInt(minStakeAmount),
+        normalise(operatorExecutor, "operatorExecutor"),
+        normalise(operatorAdmin, "operatorAdmin"),
+        tuple
+      ]);
+      return { to: addr, data: payload, value: 0n };
+    }
+    function buildCreateOperatorSubDAOWithStableAdvancedTx({
+      factory: factory2,
+      name,
+      description,
+      accessModel,
+      minStakeAmount,
+      operatorExecutor,
+      operatorAdmin,
+      anyoneExec = false,
+      governorProposer = false,
+      permit
+    }) {
+      const addr = normalise(factory2, "factory");
+      if (!permit) throw new SageSDKError(CODES.INVALID_ARGS, "permit required for operator stable creation");
+      const tuple = [
+        BigInt(permit.value ?? 0n),
+        BigInt(permit.deadline ?? 0n),
+        Number(permit.v ?? 0),
+        permit.r ?? "0x0000000000000000000000000000000000000000000000000000000000000000",
+        permit.s ?? "0x0000000000000000000000000000000000000000000000000000000000000000"
+      ];
+      const payload = FactoryWriteInterface.encodeFunctionData("createSubDAOOperatorWithStableAdvanced", [
+        String(name),
+        String(description),
+        Number(accessModel),
+        BigInt(minStakeAmount),
+        normalise(operatorExecutor, "operatorExecutor"),
+        normalise(operatorAdmin, "operatorAdmin"),
+        Boolean(anyoneExec),
+        Boolean(governorProposer),
+        tuple
+      ]);
+      return { to: addr, data: payload, value: 0n };
+    }
     async function listSubDAOs({ provider, factory: factory2 }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(factory2, "factory");
@@ -4228,6 +4339,9 @@ var require_factory = __commonJS({
       getTemplateDetails,
       buildCreateSubDAOTx,
       buildCreateSubDAOWithStableTx,
+      buildCreateSubDAOWithParamsTx,
+      buildCreateOperatorSubDAOWithStableTx,
+      buildCreateOperatorSubDAOWithStableAdvancedTx,
       buildCreateForkedSubDAOTx,
       buildCreateForkedSubDAOWithStableTx
     };

package/dist/index.mjs

@@ -20,7 +20,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@sage-protocol/sdk",
-      version: "0.1.10",
+      version: "0.1.12",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -160,6 +160,11 @@ var require_abi = __commonJS({
     var FactoryWrite = [
       "function createSubDAO(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount) returns (address subDAO, address registry)",
       "function createSubDAOWithStable(string name, string description, uint8 accessModel, uint256 minStakeAmount, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
+      "function createSubDAOWithParams(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, uint256 votingDelay, uint256 votingPeriod, uint256 proposalThreshold, uint256 quorumPercentage, uint8 initialForkPolicy, uint8 initialMembershipPolicy, string profileCID) returns (address subDAO, address registry)",
+      "function createSubDAOOperatorWithStable(string name, string description, uint8 accessModel, uint256 minStakeAmount, address operatorExecutor, address operatorAdmin, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
+      "function createSubDAOOperatorWithStableAdvanced(string name, string description, uint8 accessModel, uint256 minStakeAmount, address operatorExecutor, address operatorAdmin, bool anyoneExec, bool governorProposer, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
+      "function createSubDAOOperator(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, address operatorExecutor, address operatorAdmin) returns (address subDAO, address registry)",
+      "function createSubDAOOperatorAdvanced(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, address operatorExecutor, address operatorAdmin, bool anyoneExec, bool governorProposer) returns (address subDAO, address registry)",
       "function createForkedSubDAO(string newName, string newDescription, string originalName, address originalSubDAO, address forker) returns (address subDAO, address registry)",
       "function createForkedSubDAOWithStable(string newName, string newDescription, string originalName, address originalSubDAO, address forker, uint64 authorizationNonce, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)"
     ];
@@ -2522,7 +2527,7 @@ var require_governance = __commonJS({
       /**
        * Detect governance mode and operator status.
        * Heuristics mirror CLI detectGovMode.
-       * Returns { operator: boolean, governance: 'Bootstrap'|'Token'|'Unknown', governor, timelock, subdao, stakeRequired, depositWei }
+       * Returns { operator: boolean, governance: 'Personal'|'Community'|'Unknown', governor, timelock, subdao, stakeRequired, depositWei }
        */
       detectMode: async function detectMode({ provider, governor, timelock, subdao }) {
         const out = {
@@ -2542,7 +2547,7 @@ var require_governance = __commonJS({
             if (!timelock) out.timelock = await sub.timelock();
             try {
               const mode = await sub.getGovernanceMode();
-              out.governance = Number(mode) === 0 ? "Bootstrap" : "Token";
+              out.governance = Number(mode) === 0 ? "Personal" : "Community";
             } catch (_) {
             }
           }
@@ -3987,7 +3992,17 @@ var require_factory = __commonJS({
       ] = await Promise.all([
         contract.stableFeeToken().catch(() => null),
         contract.stableCreationFee().catch(() => null),
-        contract.feeReceiver().catch(() => null),
+        (async () => {
+          try {
+            return await contract.stableFeeReceiver();
+          } catch (_) {
+            try {
+              return await contract.feeReceiver();
+            } catch {
+              return null;
+            }
+          }
+        })(),
         contract.allowStableFee().catch(() => null),
         contract.stablePromptForkFee().catch(() => null),
         contract.allowStablePromptForkFee().catch(() => null),
@@ -4154,6 +4169,102 @@ var require_factory = __commonJS({
       ]);
       return { to: addr, data: payload, value: 0n };
     }
+    function buildCreateSubDAOWithParamsTx({
+      factory,
+      name,
+      description,
+      accessModel,
+      minStakeAmount,
+      burnAmount,
+      votingDelay,
+      votingPeriod,
+      proposalThreshold,
+      quorumPercentage,
+      initialForkPolicy,
+      initialMembershipPolicy,
+      profileCID
+    }) {
+      const addr = normalise(factory, "factory");
+      const payload = FactoryWriteInterface.encodeFunctionData("createSubDAOWithParams", [
+        String(name),
+        String(description),
+        Number(accessModel),
+        BigInt(minStakeAmount),
+        BigInt(burnAmount),
+        BigInt(votingDelay),
+        BigInt(votingPeriod),
+        BigInt(proposalThreshold),
+        BigInt(quorumPercentage),
+        Number(initialForkPolicy),
+        Number(initialMembershipPolicy),
+        String(profileCID ?? "")
+      ]);
+      return { to: addr, data: payload, value: 0n };
+    }
+    function buildCreateOperatorSubDAOWithStableTx({
+      factory,
+      name,
+      description,
+      accessModel,
+      minStakeAmount,
+      operatorExecutor,
+      operatorAdmin,
+      permit
+    }) {
+      const addr = normalise(factory, "factory");
+      if (!permit) throw new SageSDKError(CODES.INVALID_ARGS, "permit required for operator stable creation");
+      const tuple = [
+        BigInt(permit.value ?? 0n),
+        BigInt(permit.deadline ?? 0n),
+        Number(permit.v ?? 0),
+        permit.r ?? "0x0000000000000000000000000000000000000000000000000000000000000000",
+        permit.s ?? "0x0000000000000000000000000000000000000000000000000000000000000000"
+      ];
+      const payload = FactoryWriteInterface.encodeFunctionData("createSubDAOOperatorWithStable", [
+        String(name),
+        String(description),
+        Number(accessModel),
+        BigInt(minStakeAmount),
+        normalise(operatorExecutor, "operatorExecutor"),
+        normalise(operatorAdmin, "operatorAdmin"),
+        tuple
+      ]);
+      return { to: addr, data: payload, value: 0n };
+    }
+    function buildCreateOperatorSubDAOWithStableAdvancedTx({
+      factory,
+      name,
+      description,
+      accessModel,
+      minStakeAmount,
+      operatorExecutor,
+      operatorAdmin,
+      anyoneExec = false,
+      governorProposer = false,
+      permit
+    }) {
+      const addr = normalise(factory, "factory");
+      if (!permit) throw new SageSDKError(CODES.INVALID_ARGS, "permit required for operator stable creation");
+      const tuple = [
+        BigInt(permit.value ?? 0n),
+        BigInt(permit.deadline ?? 0n),
+        Number(permit.v ?? 0),
+        permit.r ?? "0x0000000000000000000000000000000000000000000000000000000000000000",
+        permit.s ?? "0x0000000000000000000000000000000000000000000000000000000000000000"
+      ];
+      const payload = FactoryWriteInterface.encodeFunctionData("createSubDAOOperatorWithStableAdvanced", [
+        String(name),
+        String(description),
+        Number(accessModel),
+        BigInt(minStakeAmount),
+        normalise(operatorExecutor, "operatorExecutor"),
+        normalise(operatorAdmin, "operatorAdmin"),
+        Boolean(anyoneExec),
+        Boolean(governorProposer),
+        tuple
+      ]);
+      return { to: addr, data: payload, value: 0n };
+    }
     async function listSubDAOs({ provider, factory }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(factory, "factory");
@@ -4234,6 +4345,9 @@ var require_factory = __commonJS({
       getTemplateDetails,
       buildCreateSubDAOTx,
       buildCreateSubDAOWithStableTx,
+      buildCreateSubDAOWithParamsTx,
+      buildCreateOperatorSubDAOWithStableTx,
+      buildCreateOperatorSubDAOWithStableAdvancedTx,
       buildCreateForkedSubDAOTx,
       buildCreateForkedSubDAOWithStableTx
     };

package/dist/node/index.cjs

@@ -14,7 +14,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@sage-protocol/sdk",
-      version: "0.1.10",
+      version: "0.1.12",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -154,6 +154,11 @@ var require_abi = __commonJS({
     var FactoryWrite = [
       "function createSubDAO(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount) returns (address subDAO, address registry)",
       "function createSubDAOWithStable(string name, string description, uint8 accessModel, uint256 minStakeAmount, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
+      "function createSubDAOWithParams(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, uint256 votingDelay, uint256 votingPeriod, uint256 proposalThreshold, uint256 quorumPercentage, uint8 initialForkPolicy, uint8 initialMembershipPolicy, string profileCID) returns (address subDAO, address registry)",
+      "function createSubDAOOperatorWithStable(string name, string description, uint8 accessModel, uint256 minStakeAmount, address operatorExecutor, address operatorAdmin, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
+      "function createSubDAOOperatorWithStableAdvanced(string name, string description, uint8 accessModel, uint256 minStakeAmount, address operatorExecutor, address operatorAdmin, bool anyoneExec, bool governorProposer, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
+      "function createSubDAOOperator(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, address operatorExecutor, address operatorAdmin) returns (address subDAO, address registry)",
+      "function createSubDAOOperatorAdvanced(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, address operatorExecutor, address operatorAdmin, bool anyoneExec, bool governorProposer) returns (address subDAO, address registry)",
       "function createForkedSubDAO(string newName, string newDescription, string originalName, address originalSubDAO, address forker) returns (address subDAO, address registry)",
       "function createForkedSubDAOWithStable(string newName, string newDescription, string originalName, address originalSubDAO, address forker, uint64 authorizationNonce, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)"
     ];
@@ -2516,7 +2521,7 @@ var require_governance = __commonJS({
       /**
        * Detect governance mode and operator status.
        * Heuristics mirror CLI detectGovMode.
-       * Returns { operator: boolean, governance: 'Bootstrap'|'Token'|'Unknown', governor, timelock, subdao, stakeRequired, depositWei }
+       * Returns { operator: boolean, governance: 'Personal'|'Community'|'Unknown', governor, timelock, subdao, stakeRequired, depositWei }
        */
       detectMode: async function detectMode({ provider, governor, timelock, subdao }) {
         const out = {
@@ -2536,7 +2541,7 @@ var require_governance = __commonJS({
             if (!timelock) out.timelock = await sub.timelock();
             try {
               const mode = await sub.getGovernanceMode();
-              out.governance = Number(mode) === 0 ? "Bootstrap" : "Token";
+              out.governance = Number(mode) === 0 ? "Personal" : "Community";
             } catch (_) {
             }
           }
@@ -3981,7 +3986,17 @@ var require_factory = __commonJS({
       ] = await Promise.all([
         contract.stableFeeToken().catch(() => null),
         contract.stableCreationFee().catch(() => null),
-        contract.feeReceiver().catch(() => null),
+        (async () => {
+          try {
+            return await contract.stableFeeReceiver();
+          } catch (_) {
+            try {
+              return await contract.feeReceiver();
+            } catch {
+              return null;
+            }
+          }
+        })(),
         contract.allowStableFee().catch(() => null),
         contract.stablePromptForkFee().catch(() => null),
         contract.allowStablePromptForkFee().catch(() => null),
@@ -4148,6 +4163,102 @@ var require_factory = __commonJS({
       ]);
       return { to: addr, data: payload, value: 0n };
     }
+    function buildCreateSubDAOWithParamsTx({
+      factory,
+      name,
+      description,
+      accessModel,
+      minStakeAmount,
+      burnAmount,
+      votingDelay,
+      votingPeriod,
+      proposalThreshold,
+      quorumPercentage,
+      initialForkPolicy,
+      initialMembershipPolicy,
+      profileCID
+    }) {
+      const addr = normalise(factory, "factory");
+      const payload = FactoryWriteInterface.encodeFunctionData("createSubDAOWithParams", [
+        String(name),
+        String(description),
+        Number(accessModel),
+        BigInt(minStakeAmount),
+        BigInt(burnAmount),
+        BigInt(votingDelay),
+        BigInt(votingPeriod),
+        BigInt(proposalThreshold),
+        BigInt(quorumPercentage),
+        Number(initialForkPolicy),
+        Number(initialMembershipPolicy),
+        String(profileCID ?? "")
+      ]);
+      return { to: addr, data: payload, value: 0n };
+    }
+    function buildCreateOperatorSubDAOWithStableTx({
+      factory,
+      name,
+      description,
+      accessModel,
+      minStakeAmount,
+      operatorExecutor,
+      operatorAdmin,
+      permit
+    }) {
+      const addr = normalise(factory, "factory");
+      if (!permit) throw new SageSDKError(CODES.INVALID_ARGS, "permit required for operator stable creation");
+      const tuple = [
+        BigInt(permit.value ?? 0n),
+        BigInt(permit.deadline ?? 0n),
+        Number(permit.v ?? 0),
+        permit.r ?? "0x0000000000000000000000000000000000000000000000000000000000000000",
+        permit.s ?? "0x0000000000000000000000000000000000000000000000000000000000000000"
+      ];
+      const payload = FactoryWriteInterface.encodeFunctionData("createSubDAOOperatorWithStable", [
+        String(name),
+        String(description),
+        Number(accessModel),
+        BigInt(minStakeAmount),
+        normalise(operatorExecutor, "operatorExecutor"),
+        normalise(operatorAdmin, "operatorAdmin"),
+        tuple
+      ]);
+      return { to: addr, data: payload, value: 0n };
+    }
+    function buildCreateOperatorSubDAOWithStableAdvancedTx({
+      factory,
+      name,
+      description,
+      accessModel,
+      minStakeAmount,
+      operatorExecutor,
+      operatorAdmin,
+      anyoneExec = false,
+      governorProposer = false,
+      permit
+    }) {
+      const addr = normalise(factory, "factory");
+      if (!permit) throw new SageSDKError(CODES.INVALID_ARGS, "permit required for operator stable creation");
+      const tuple = [
+        BigInt(permit.value ?? 0n),
+        BigInt(permit.deadline ?? 0n),
+        Number(permit.v ?? 0),
+        permit.r ?? "0x0000000000000000000000000000000000000000000000000000000000000000",
+        permit.s ?? "0x0000000000000000000000000000000000000000000000000000000000000000"
+      ];
+      const payload = FactoryWriteInterface.encodeFunctionData("createSubDAOOperatorWithStableAdvanced", [
+        String(name),
+        String(description),
+        Number(accessModel),
+        BigInt(minStakeAmount),
+        normalise(operatorExecutor, "operatorExecutor"),
+        normalise(operatorAdmin, "operatorAdmin"),
+        Boolean(anyoneExec),
+        Boolean(governorProposer),
+        tuple
+      ]);
+      return { to: addr, data: payload, value: 0n };
+    }
     async function listSubDAOs({ provider, factory }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(factory, "factory");
@@ -4228,6 +4339,9 @@ var require_factory = __commonJS({
       getTemplateDetails,
       buildCreateSubDAOTx,
       buildCreateSubDAOWithStableTx,
+      buildCreateSubDAOWithParamsTx,
+      buildCreateOperatorSubDAOWithStableTx,
+      buildCreateOperatorSubDAOWithStableAdvancedTx,
       buildCreateForkedSubDAOTx,
       buildCreateForkedSubDAOWithStableTx
     };

package/dist/node/index.mjs

@@ -20,7 +20,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@sage-protocol/sdk",
-      version: "0.1.10",
+      version: "0.1.12",
       description: "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
       main: "dist/index.cjs",
       module: "dist/index.mjs",
@@ -160,6 +160,11 @@ var require_abi = __commonJS({
     var FactoryWrite = [
       "function createSubDAO(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount) returns (address subDAO, address registry)",
       "function createSubDAOWithStable(string name, string description, uint8 accessModel, uint256 minStakeAmount, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
+      "function createSubDAOWithParams(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, uint256 votingDelay, uint256 votingPeriod, uint256 proposalThreshold, uint256 quorumPercentage, uint8 initialForkPolicy, uint8 initialMembershipPolicy, string profileCID) returns (address subDAO, address registry)",
+      "function createSubDAOOperatorWithStable(string name, string description, uint8 accessModel, uint256 minStakeAmount, address operatorExecutor, address operatorAdmin, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
+      "function createSubDAOOperatorWithStableAdvanced(string name, string description, uint8 accessModel, uint256 minStakeAmount, address operatorExecutor, address operatorAdmin, bool anyoneExec, bool governorProposer, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)",
+      "function createSubDAOOperator(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, address operatorExecutor, address operatorAdmin) returns (address subDAO, address registry)",
+      "function createSubDAOOperatorAdvanced(string name, string description, uint8 accessModel, uint256 minStakeAmount, uint256 burnAmount, address operatorExecutor, address operatorAdmin, bool anyoneExec, bool governorProposer) returns (address subDAO, address registry)",
       "function createForkedSubDAO(string newName, string newDescription, string originalName, address originalSubDAO, address forker) returns (address subDAO, address registry)",
       "function createForkedSubDAOWithStable(string newName, string newDescription, string originalName, address originalSubDAO, address forker, uint64 authorizationNonce, (uint256 value,uint256 deadline,uint8 v,bytes32 r,bytes32 s) permit) returns (address subDAO, address registry)"
     ];
@@ -2522,7 +2527,7 @@ var require_governance = __commonJS({
       /**
        * Detect governance mode and operator status.
        * Heuristics mirror CLI detectGovMode.
-       * Returns { operator: boolean, governance: 'Bootstrap'|'Token'|'Unknown', governor, timelock, subdao, stakeRequired, depositWei }
+       * Returns { operator: boolean, governance: 'Personal'|'Community'|'Unknown', governor, timelock, subdao, stakeRequired, depositWei }
        */
       detectMode: async function detectMode({ provider, governor, timelock, subdao }) {
         const out = {
@@ -2542,7 +2547,7 @@ var require_governance = __commonJS({
             if (!timelock) out.timelock = await sub.timelock();
             try {
               const mode = await sub.getGovernanceMode();
-              out.governance = Number(mode) === 0 ? "Bootstrap" : "Token";
+              out.governance = Number(mode) === 0 ? "Personal" : "Community";
             } catch (_) {
             }
           }
@@ -3987,7 +3992,17 @@ var require_factory = __commonJS({
       ] = await Promise.all([
         contract.stableFeeToken().catch(() => null),
         contract.stableCreationFee().catch(() => null),
-        contract.feeReceiver().catch(() => null),
+        (async () => {
+          try {
+            return await contract.stableFeeReceiver();
+          } catch (_) {
+            try {
+              return await contract.feeReceiver();
+            } catch {
+              return null;
+            }
+          }
+        })(),
         contract.allowStableFee().catch(() => null),
         contract.stablePromptForkFee().catch(() => null),
         contract.allowStablePromptForkFee().catch(() => null),
@@ -4154,6 +4169,102 @@ var require_factory = __commonJS({
       ]);
       return { to: addr, data: payload, value: 0n };
     }
+    function buildCreateSubDAOWithParamsTx({
+      factory,
+      name,
+      description,
+      accessModel,
+      minStakeAmount,
+      burnAmount,
+      votingDelay,
+      votingPeriod,
+      proposalThreshold,
+      quorumPercentage,
+      initialForkPolicy,
+      initialMembershipPolicy,
+      profileCID
+    }) {
+      const addr = normalise(factory, "factory");
+      const payload = FactoryWriteInterface.encodeFunctionData("createSubDAOWithParams", [
+        String(name),
+        String(description),
+        Number(accessModel),
+        BigInt(minStakeAmount),
+        BigInt(burnAmount),
+        BigInt(votingDelay),
+        BigInt(votingPeriod),
+        BigInt(proposalThreshold),
+        BigInt(quorumPercentage),
+        Number(initialForkPolicy),
+        Number(initialMembershipPolicy),
+        String(profileCID ?? "")
+      ]);
+      return { to: addr, data: payload, value: 0n };
+    }
+    function buildCreateOperatorSubDAOWithStableTx({
+      factory,
+      name,
+      description,
+      accessModel,
+      minStakeAmount,
+      operatorExecutor,
+      operatorAdmin,
+      permit
+    }) {
+      const addr = normalise(factory, "factory");
+      if (!permit) throw new SageSDKError(CODES.INVALID_ARGS, "permit required for operator stable creation");
+      const tuple = [
+        BigInt(permit.value ?? 0n),
+        BigInt(permit.deadline ?? 0n),
+        Number(permit.v ?? 0),
+        permit.r ?? "0x0000000000000000000000000000000000000000000000000000000000000000",
+        permit.s ?? "0x0000000000000000000000000000000000000000000000000000000000000000"
+      ];
+      const payload = FactoryWriteInterface.encodeFunctionData("createSubDAOOperatorWithStable", [
+        String(name),
+        String(description),
+        Number(accessModel),
+        BigInt(minStakeAmount),
+        normalise(operatorExecutor, "operatorExecutor"),
+        normalise(operatorAdmin, "operatorAdmin"),
+        tuple
+      ]);
+      return { to: addr, data: payload, value: 0n };
+    }
+    function buildCreateOperatorSubDAOWithStableAdvancedTx({
+      factory,
+      name,
+      description,
+      accessModel,
+      minStakeAmount,
+      operatorExecutor,
+      operatorAdmin,
+      anyoneExec = false,
+      governorProposer = false,
+      permit
+    }) {
+      const addr = normalise(factory, "factory");
+      if (!permit) throw new SageSDKError(CODES.INVALID_ARGS, "permit required for operator stable creation");
+      const tuple = [
+        BigInt(permit.value ?? 0n),
+        BigInt(permit.deadline ?? 0n),
+        Number(permit.v ?? 0),
+        permit.r ?? "0x0000000000000000000000000000000000000000000000000000000000000000",
+        permit.s ?? "0x0000000000000000000000000000000000000000000000000000000000000000"
+      ];
+      const payload = FactoryWriteInterface.encodeFunctionData("createSubDAOOperatorWithStableAdvanced", [
+        String(name),
+        String(description),
+        Number(accessModel),
+        BigInt(minStakeAmount),
+        normalise(operatorExecutor, "operatorExecutor"),
+        normalise(operatorAdmin, "operatorAdmin"),
+        Boolean(anyoneExec),
+        Boolean(governorProposer),
+        tuple
+      ]);
+      return { to: addr, data: payload, value: 0n };
+    }
     async function listSubDAOs({ provider, factory }) {
       if (!provider) throw new SageSDKError(CODES.INVALID_ARGS, "provider required");
       const addr = normalise(factory, "factory");
@@ -4234,6 +4345,9 @@ var require_factory = __commonJS({
       getTemplateDetails,
       buildCreateSubDAOTx,
       buildCreateSubDAOWithStableTx,
+      buildCreateSubDAOWithParamsTx,
+      buildCreateOperatorSubDAOWithStableTx,
+      buildCreateOperatorSubDAOWithStableAdvancedTx,
       buildCreateForkedSubDAOTx,
       buildCreateForkedSubDAOWithStableTx
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sage-protocol/sdk",
-  "version": "0.1.10",
+  "version": "0.1.13",
   "description": "Backend-agnostic SDK for interacting with the Sage Protocol (governance, SubDAOs, tokens).",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",