@chipi-stack/chipi-react 14.7.0 → 14.8.0

package/dist/multisig.d.ts

@@ -0,0 +1,350 @@
+import * as _tanstack_react_query from '@tanstack/react-query';
+
+/**
+ * Framework-agnostic action-template engine for SHHH multisig governance.
+ *
+ * An {@link ActionTemplate} maps friendly, typed form fields → an
+ * OutsideExecution call list + a human-readable title. It's the seam that
+ * turns "call any contract" (powerful, scary) into "fill in this form"
+ * (founder-grade) — and the whitelabel seam: every integrator registers
+ * its own templates (Roca: create_pool / borrow / repay), while `Vote`
+ * ships built-in. The raw-call escape hatch lives in the UI layer, not
+ * here, because its arguments are open-ended.
+ *
+ * Pure: no React, no network — so the same template renders the proposer's
+ * form, every approver's inbox, and the notification, from one source of
+ * truth, and `toCalls` is deterministic (proposer and executor build the
+ * identical OE → the hash matches).
+ */
+type FeltLike = string | number | bigint;
+/** One call in an action — the shape the OE builder consumes. */
+interface CallSpec {
+    to: string;
+    entrypoint: string;
+    /** Flat 0x-hex felts. */
+    calldata: string[];
+}
+/** A typed input in an action template. */
+type FieldSpec = {
+    name: string;
+    label: string;
+    type: "amount";
+    decimals: number;
+    help?: string;
+} | {
+    name: string;
+    label: string;
+    type: "address";
+    help?: string;
+} | {
+    name: string;
+    label: string;
+    type: "number" | "bps" | "days" | "felt";
+    help?: string;
+} | {
+    name: string;
+    label: string;
+    type: "select";
+    options: {
+        label: string;
+        value: string;
+    }[];
+    help?: string;
+} | {
+    name: string;
+    label: string;
+    type: "text";
+    help?: string;
+};
+interface ActionTemplate<V = Record<string, unknown>> {
+    /** Stable id, persisted on the proposal. */
+    key: string;
+    /** Display label ("Create pool"). */
+    label: string;
+    description?: string;
+    /** Typed inputs rendered by `<ProposeAction>`. */
+    fields: FieldSpec[];
+    /** Pure: validated field values → the OE call list. */
+    toCalls: (v: V) => CallSpec[];
+    /** Pure: the plain-language title shown in the preview, inbox, and email. */
+    title: (v: V) => string;
+    /** Optional metadata persisted with the proposal so the approver's app
+     *  can render business context (e.g. `{ poolId }`). */
+    meta?: (v: V) => Record<string, string | number>;
+}
+/** Starknet felt252 field prime — args must be a non-negative felt below it. */
+declare const FELT_PRIME: bigint;
+/** Parse a decimal or 0x-hex value to a canonical `0x` felt. Throws on a
+ *  non-numeric or out-of-range value. */
+declare function toFelt(v: FeltLike): string;
+/** Split a u256 value into its `[low, high]` felts (Cairo calling convention). */
+declare function u256(v: FeltLike): [string, string];
+/** Convert a human amount ("10.5") to base units given a token's decimals. */
+declare function amountToBase(amount: string, decimals: number): bigint;
+/**
+ * Identity + light validation for a template registry: keys are present
+ * and unique. Returns the same array (typed) so call sites keep inference.
+ */
+declare function defineActions<T extends ActionTemplate<any>[]>(templates: [...T]): [...T];
+interface VoteValues {
+    contract: string;
+    proposalId: string;
+    choice: string;
+}
+/**
+ * Built-in `Vote` template — `vote(proposalId, choice)` on a governance
+ * contract. Pin the contract and/or entrypoint up front (then they drop
+ * out of the form), or leave them for the proposer to fill.
+ */
+declare function voteTemplate(opts?: {
+    governanceContract?: string;
+    entrypoint?: string;
+}): ActionTemplate<VoteValues>;
+
+/** shortString.encodeShortString("SN_MAIN") — Starknet mainnet. */
+declare const SN_MAIN_CHAIN_ID = "0x534e5f4d41494e";
+/**
+ * Max on-chain OE validity window (`executeBefore - executeAfter`), capped
+ * by the SHHH contract audit (M-2). This is the longest a proposal stays
+ * EXECUTABLE — distinct from how long its record lives in the coordination
+ * backend. NOTE: with `executeAfter` pinned to 0 the window would be the
+ * whole epoch and the contract rejects it, so `executeAfter` is set to ~now
+ * and persisted alongside the nonce + `executeBefore`.
+ */
+declare const OE_WINDOW_SECONDS: number;
+/**
+ * Signs an OE message hash for one owner → that owner's inner V2_SNIP12
+ * envelope (an array of felts). Implementations wrap a passkey / MetaMask /
+ * Phantom / STARK signer; the private key never leaves the implementation.
+ */
+type OeSigner = (params: {
+    messageHash: bigint;
+    ownerIndex: bigint;
+}) => Promise<bigint[]> | bigint[];
+/** Serialize an inner envelope (felt[]) to the comma-joined 0x-hex string
+ *  the coordination backend stores per signature. */
+declare function serializeEnvelope(env: bigint[]): string;
+declare function deserializeEnvelope(s: string): bigint[];
+/**
+ * OE replay nonce: ms timestamp shifted left 24 bits, ORed with a 24-bit
+ * random suffix. `nowMs`/`rand` are injectable for deterministic tests.
+ */
+declare function newOeNonce(nowMs: number, rand: number): bigint;
+interface ActionProposal {
+    oeMessageHash: string;
+    oeNonce: string;
+    oeExecuteBefore: string;
+    /** The proposer's inner V2_SNIP12 envelope, comma-joined 0x-hex. */
+    proposerSignature: string;
+}
+/** Derive the OE's executeAfter from its persisted executeBefore. The
+ *  window is a fixed constant (the contract cap), so the executor needs
+ *  only executeBefore to reconstruct the exact signed OE — no separate
+ *  executeAfter persistence (and no backend column). */
+declare function deriveExecuteAfter(oeExecuteBefore: string): bigint;
+/**
+ * Build an OE over `calls`, sign it as the proposer (owner 0 by default),
+ * and return everything a propose endpoint needs. The OE params (nonce +
+ * executeBefore) are returned; executeAfter is `executeBefore - OE_WINDOW`,
+ * so only executeBefore needs persisting. The window is the contract cap
+ * (the longest executable window M-2 allows).
+ */
+declare function buildActionProposal(params: {
+    walletAddress: string;
+    calls: CallSpec[];
+    sign: OeSigner;
+    ownerIndex?: bigint;
+    chainId?: string;
+    nowMs?: number;
+    rand?: number;
+}): Promise<ActionProposal>;
+/** Sign an existing proposal's OE hash as an approver → inner envelope string. */
+declare function signActionApproval(params: {
+    oeMessageHash: string;
+    ownerIndex: bigint;
+    sign: OeSigner;
+}): Promise<string>;
+/**
+ * Rebuild the exact OE from the persisted params + collected signatures and
+ * serialize the `execute` calldata. A 1-of-N wallet uses the single inner
+ * envelope; N≥2 wraps the inner envelopes in a V2_THRESHOLD envelope.
+ */
+declare function assembleActionExecuteCalldata(params: {
+    calls: CallSpec[];
+    oeNonce: string;
+    oeExecuteBefore: string;
+    signatures: string[];
+    requiredApprovals: number;
+}): string[];
+
+/**
+ * Injectable boundaries for the multisig governance hooks. The package owns
+ * the OE crypto + template engine + orchestration; the host supplies the
+ * transport (an authed coordination backend) and the signer (a per-owner
+ * OE signer + owner-index resolution). This keeps the package auth- and
+ * chain-agnostic: the dashboard wires Clerk today; the owner-signature SDK
+ * client wires it for integrators at P1.
+ */
+
+/** One owner's collected signature on a proposal. */
+interface ProposalSignature {
+    ownerId: number;
+    signerKind: string;
+    /** The owner's serialized inner V2_SNIP12 envelope (comma-joined felts). */
+    signature: string;
+}
+/** A treasury proposal as returned by the coordination backend. */
+interface TreasuryProposal {
+    id: string;
+    /** Set for generalized actions (vote / call any contract). */
+    calls?: {
+        to: string;
+        entrypoint: string;
+        calldata: string[];
+    }[] | null;
+    /** Human label for an action ("Vote YES on Proposal #5"). */
+    title?: string | null;
+    /** Arbitrary integrator context (e.g. `{ poolId }`). */
+    meta?: Record<string, string | number> | null;
+    oeMessageHash: string;
+    oeNonce: string | null;
+    oeExecuteBefore: string | null;
+    requiredApprovals: number;
+    status: "PROPOSED" | "APPROVED" | "EXECUTED" | "CANCELED" | "EXPIRED";
+    executedTxHash?: string | null;
+    signatures: ProposalSignature[];
+}
+/** The body the coordination backend's `propose` endpoint accepts. */
+interface ProposeBody {
+    proposerOwnerId: number;
+    recipient: string;
+    tokenAddress: string;
+    amount: string;
+    title: string;
+    calls: {
+        to: string;
+        entrypoint: string;
+        calldata: string[];
+    }[];
+    meta?: Record<string, string | number>;
+    oeMessageHash: string;
+    oeNonce: string;
+    oeExecuteBefore: string;
+    requiredApprovals: number;
+    proposerSignature: string;
+    proposerSignerKind: string;
+}
+/** The coordination backend (propose / list / sign / execute), host-wired. */
+interface MultisigTransport {
+    list(): Promise<{
+        items: TreasuryProposal[];
+    }>;
+    propose(body: ProposeBody): Promise<TreasuryProposal>;
+    sign(proposalId: string, body: {
+        ownerId: number;
+        signature: string;
+        signerKind: string;
+    }): Promise<unknown>;
+    execute(proposalId: string, calldata: string[]): Promise<{
+        executedTxHash?: string;
+        transactionHash?: string;
+    }>;
+}
+/**
+ * A per-owner OE signer. `sign` produces this device's inner envelope (key
+ * never leaves it). `resolveOwnerIndex` maps the device's credential to its
+ * position in the on-chain owner set (for approving as a non-proposer).
+ */
+interface MultisigSigner {
+    /** ShhhSignerKind, e.g. "WEBAUTHN_P256" / "STARK" / "EIP191_SECP256K1". */
+    signerKind: string;
+    /** Owner index this device proposes as (the bootstrap owner; default 0). */
+    proposerOwnerIndex?: number;
+    sign: OeSigner;
+    resolveOwnerIndex(walletAddress: string): Promise<number>;
+}
+
+/**
+ * Pure orchestration for the multisig governance flow — build a propose
+ * body, build an approval, assemble execute calldata. No React, no network:
+ * the hooks (`use-hooks.ts`) wrap these in mutations/queries, and they're
+ * directly unit-testable with a mock signer + injected `nowMs`/`rand`.
+ */
+
+/**
+ * Build a propose body for a template + its validated field values: derive
+ * the call(s) + title (+ meta), build & proposer-sign the OE, and shape the
+ * body the coordination backend expects. For an action the payment fields
+ * are placeholders (recipient/token = the first call's target, amount "0");
+ * the real intent rides in `calls` + `title`.
+ */
+declare function createProposal<V>(params: {
+    template: ActionTemplate<V>;
+    values: V;
+    walletAddress: string;
+    requiredApprovals: number;
+    signer: MultisigSigner;
+    chainId?: string;
+    nowMs?: number;
+    rand?: number;
+}): Promise<ProposeBody>;
+/**
+ * Build an approver's signature on an existing proposal: resolve this
+ * device's owner index from chain, then sign the SAME OE hash.
+ */
+declare function buildApproval(params: {
+    proposal: Pick<TreasuryProposal, "oeMessageHash">;
+    walletAddress: string;
+    signer: MultisigSigner;
+}): Promise<{
+    ownerId: number;
+    signature: string;
+    signerKind: string;
+}>;
+/**
+ * Assemble the execute calldata from a proposal's persisted call(s) + its
+ * collected signatures (sorted by owner index). Requires `calls` — this is
+ * the generalized-action flow; a host with payment-only proposals supplies
+ * the transfer calls.
+ */
+declare function buildExecuteCalldata(proposal: TreasuryProposal): string[];
+
+interface ProposeInput {
+    template: ActionTemplate<any>;
+    values: any;
+}
+/**
+ * Propose a templated action: build the call(s) + title from the template,
+ * passkey-/key-sign the OE as the proposer, and submit it. `getRequiredApprovals`
+ * supplies the wallet's threshold (the host reads it from chain — the package
+ * stays chain-agnostic).
+ */
+declare function useProposeAction(config: {
+    walletAddress: string;
+    transport: MultisigTransport;
+    signer: MultisigSigner;
+    getRequiredApprovals: () => Promise<number>;
+    chainId?: string;
+}): _tanstack_react_query.UseMutationResult<TreasuryProposal, Error, ProposeInput, unknown>;
+/**
+ * List a treasury's proposals and expose approve / execute mutations. An
+ * approver signs the same OE hash as their resolved owner index; once enough
+ * approvals are collected, execute rebuilds the OE from the persisted call(s)
+ * and relays it.
+ */
+declare function useTreasuryProposals(config: {
+    walletAddress: string;
+    transport: MultisigTransport;
+    signer: MultisigSigner;
+}): {
+    proposals: _tanstack_react_query.UseQueryResult<{
+        items: TreasuryProposal[];
+    }, Error>;
+    approve: _tanstack_react_query.UseMutationResult<unknown, Error, TreasuryProposal, unknown>;
+    execute: _tanstack_react_query.UseMutationResult<{
+        executedTxHash?: string;
+        transactionHash?: string;
+    }, Error, TreasuryProposal, unknown>;
+};
+
+export { type ActionProposal, type ActionTemplate, type CallSpec, FELT_PRIME, type FeltLike, type FieldSpec, type MultisigSigner, type MultisigTransport, OE_WINDOW_SECONDS, type OeSigner, type ProposalSignature, type ProposeBody, type ProposeInput, SN_MAIN_CHAIN_ID, type TreasuryProposal, type VoteValues, amountToBase, assembleActionExecuteCalldata, buildActionProposal, buildApproval, buildExecuteCalldata, createProposal, defineActions, deriveExecuteAfter, deserializeEnvelope, newOeNonce, serializeEnvelope, signActionApproval, toFelt, u256, useProposeAction, useTreasuryProposals, voteTemplate };

package/dist/multisig.js

@@ -0,0 +1,278 @@
+'use strict';
+
+var backend = require('@chipi-stack/backend');
+var reactQuery = require('@tanstack/react-query');
+
+// src/multisig/action-template.ts
+var FELT_PRIME = BigInt(
+  "0x800000000000011000000000000000000000000000000000000000000000001"
+);
+var U128_MASK = (1n << 128n) - 1n;
+function toFelt(v) {
+  let n;
+  try {
+    n = BigInt(typeof v === "string" ? v.trim() : v);
+  } catch {
+    throw new Error(`Not a felt: ${String(v)}`);
+  }
+  if (n < 0n || n >= FELT_PRIME) {
+    throw new Error(`Felt out of range: ${String(v)}`);
+  }
+  return "0x" + n.toString(16);
+}
+function u256(v) {
+  const n = BigInt(typeof v === "string" ? v.trim() : v);
+  if (n < 0n) throw new Error("u256 must be non-negative");
+  return ["0x" + (n & U128_MASK).toString(16), "0x" + (n >> 128n).toString(16)];
+}
+function amountToBase(amount, decimals) {
+  const t = amount.trim();
+  if (!/^\d+(\.\d+)?$/.test(t)) throw new Error(`Invalid amount: ${amount}`);
+  const [whole, frac = ""] = t.split(".");
+  if (frac.length > decimals) {
+    throw new Error(`Too many decimal places (max ${decimals})`);
+  }
+  const padded = (frac + "0".repeat(decimals)).slice(0, decimals);
+  return BigInt(whole) * 10n ** BigInt(decimals) + BigInt(padded || "0");
+}
+function defineActions(templates) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const t of templates) {
+    if (!t.key) throw new Error("ActionTemplate.key is required");
+    if (seen.has(t.key)) throw new Error(`Duplicate ActionTemplate key: ${t.key}`);
+    seen.add(t.key);
+  }
+  return templates;
+}
+var VOTE_CHOICES = [
+  { label: "Yes", value: "0x1" },
+  { label: "No", value: "0x0" },
+  { label: "Abstain", value: "0x2" }
+];
+function voteTemplate(opts) {
+  const fields = [];
+  if (!opts?.governanceContract) {
+    fields.push({ name: "contract", label: "Governance contract", type: "address" });
+  }
+  fields.push(
+    { name: "proposalId", label: "Proposal ID", type: "felt" },
+    { name: "choice", label: "Your vote", type: "select", options: VOTE_CHOICES }
+  );
+  const labelFor = (v) => VOTE_CHOICES.find((c) => c.value === v)?.label ?? v;
+  return {
+    key: "vote",
+    label: "Vote",
+    description: "Vote on a governance proposal.",
+    fields,
+    toCalls: (v) => [
+      {
+        to: opts?.governanceContract ?? v.contract,
+        entrypoint: opts?.entrypoint ?? "vote",
+        calldata: [toFelt(v.proposalId), toFelt(v.choice)]
+      }
+    ],
+    title: (v) => `Vote ${labelFor(v.choice)} on Proposal #${v.proposalId}`
+  };
+}
+var SN_MAIN_CHAIN_ID = "0x534e5f4d41494e";
+var OE_WINDOW_SECONDS = Number(backend.MAX_OE_VALIDITY_WINDOW_SECONDS);
+var OE_AFTER_SKEW_SECONDS = 60;
+function toOeCalls(calls) {
+  return calls.map((c) => ({
+    contractAddress: c.to,
+    entrypoint: c.entrypoint,
+    calldata: c.calldata
+  }));
+}
+function serializeEnvelope(env) {
+  return env.map((f) => "0x" + f.toString(16)).join(",");
+}
+function deserializeEnvelope(s) {
+  return s.split(",").filter(Boolean).map((f) => BigInt(f));
+}
+function newOeNonce(nowMs, rand) {
+  return BigInt(nowMs) << 24n | BigInt(Math.floor(rand * 16777215));
+}
+function deriveExecuteAfter(oeExecuteBefore) {
+  return BigInt(oeExecuteBefore) - BigInt(OE_WINDOW_SECONDS);
+}
+async function buildActionProposal(params) {
+  const nowMs = params.nowMs ?? Date.now();
+  const nonce = newOeNonce(nowMs, params.rand ?? Math.random());
+  const executeAfter = BigInt(Math.floor(nowMs / 1e3) - OE_AFTER_SKEW_SECONDS);
+  const executeBefore = executeAfter + BigInt(OE_WINDOW_SECONDS);
+  const oe = backend.buildOutsideExecution({
+    nonce,
+    calls: toOeCalls(params.calls),
+    caller: backend.ANY_CALLER_FELT,
+    executeAfter,
+    executeBefore
+  });
+  const messageHash = backend.computeOeHash(oe, params.walletAddress, params.chainId ?? SN_MAIN_CHAIN_ID);
+  const inner = await params.sign({
+    messageHash,
+    ownerIndex: params.ownerIndex ?? 0n
+  });
+  return {
+    oeMessageHash: "0x" + messageHash.toString(16),
+    oeNonce: "0x" + nonce.toString(16),
+    oeExecuteBefore: executeBefore.toString(),
+    proposerSignature: serializeEnvelope(inner)
+  };
+}
+async function signActionApproval(params) {
+  const inner = await params.sign({
+    messageHash: BigInt(params.oeMessageHash),
+    ownerIndex: params.ownerIndex
+  });
+  return serializeEnvelope(inner);
+}
+function assembleActionExecuteCalldata(params) {
+  const oe = backend.buildOutsideExecution({
+    nonce: BigInt(params.oeNonce),
+    calls: toOeCalls(params.calls),
+    caller: backend.ANY_CALLER_FELT,
+    executeAfter: deriveExecuteAfter(params.oeExecuteBefore),
+    executeBefore: BigInt(params.oeExecuteBefore)
+  });
+  const inner = params.signatures.map(deserializeEnvelope);
+  if (inner.length < Math.max(1, params.requiredApprovals)) {
+    throw new Error(
+      `Not enough signatures: have ${inner.length}, need ${params.requiredApprovals}.`
+    );
+  }
+  const signature = params.requiredApprovals <= 1 ? inner[0] : backend.buildThresholdEnvelope({ innerEnvelopes: inner });
+  return backend.serializeExecuteFromOutsideV2Calldata({
+    outsideExecution: oe,
+    signature
+  });
+}
+
+// src/multisig/proposals.ts
+async function createProposal(params) {
+  const calls = params.template.toCalls(params.values);
+  if (calls.length === 0) {
+    throw new Error("Template produced no calls");
+  }
+  const title = params.template.title(params.values);
+  const meta = params.template.meta?.(params.values);
+  const proposerOwnerId = params.signer.proposerOwnerIndex ?? 0;
+  const proposal = await buildActionProposal({
+    walletAddress: params.walletAddress,
+    calls,
+    sign: params.signer.sign,
+    ownerIndex: BigInt(proposerOwnerId),
+    chainId: params.chainId,
+    nowMs: params.nowMs,
+    rand: params.rand
+  });
+  return {
+    proposerOwnerId,
+    recipient: calls[0].to,
+    tokenAddress: calls[0].to,
+    amount: "0",
+    title,
+    calls,
+    ...meta ? { meta } : {},
+    oeMessageHash: proposal.oeMessageHash,
+    oeNonce: proposal.oeNonce,
+    oeExecuteBefore: proposal.oeExecuteBefore,
+    requiredApprovals: params.requiredApprovals,
+    proposerSignature: proposal.proposerSignature,
+    proposerSignerKind: params.signer.signerKind
+  };
+}
+async function buildApproval(params) {
+  const ownerId = await params.signer.resolveOwnerIndex(params.walletAddress);
+  const signature = await signActionApproval({
+    oeMessageHash: params.proposal.oeMessageHash,
+    ownerIndex: BigInt(ownerId),
+    sign: params.signer.sign
+  });
+  return { ownerId, signature, signerKind: params.signer.signerKind };
+}
+function buildExecuteCalldata(proposal) {
+  if (!proposal.calls || proposal.calls.length === 0) {
+    throw new Error("Proposal has no calls to execute");
+  }
+  if (!proposal.oeNonce || !proposal.oeExecuteBefore) {
+    throw new Error("Proposal is missing OE params (nonce / executeBefore)");
+  }
+  const signatures = [...proposal.signatures].sort((a, b) => a.ownerId - b.ownerId).map((s) => s.signature);
+  return assembleActionExecuteCalldata({
+    calls: proposal.calls,
+    oeNonce: proposal.oeNonce,
+    oeExecuteBefore: proposal.oeExecuteBefore,
+    signatures,
+    requiredApprovals: proposal.requiredApprovals
+  });
+}
+var proposalsKey = (walletAddress) => ["chipi-multisig-proposals", walletAddress];
+function useProposeAction(config) {
+  const qc = reactQuery.useQueryClient();
+  return reactQuery.useMutation({
+    mutationFn: async (input) => {
+      const requiredApprovals = await config.getRequiredApprovals();
+      const body = await createProposal({
+        template: input.template,
+        values: input.values,
+        walletAddress: config.walletAddress,
+        requiredApprovals,
+        signer: config.signer,
+        chainId: config.chainId
+      });
+      return config.transport.propose(body);
+    },
+    onSuccess: () => qc.invalidateQueries({
+      queryKey: proposalsKey(config.walletAddress)
+    })
+  });
+}
+function useTreasuryProposals(config) {
+  const qc = reactQuery.useQueryClient();
+  const invalidate = () => qc.invalidateQueries({ queryKey: proposalsKey(config.walletAddress) });
+  const proposals = reactQuery.useQuery({
+    queryKey: proposalsKey(config.walletAddress),
+    staleTime: 30 * 1e3,
+    queryFn: () => config.transport.list()
+  });
+  const approve = reactQuery.useMutation({
+    mutationFn: async (proposal) => {
+      const body = await buildApproval({
+        proposal,
+        walletAddress: config.walletAddress,
+        signer: config.signer
+      });
+      return config.transport.sign(proposal.id, body);
+    },
+    onSuccess: invalidate
+  });
+  const execute = reactQuery.useMutation({
+    mutationFn: (proposal) => config.transport.execute(proposal.id, buildExecuteCalldata(proposal)),
+    onSuccess: invalidate
+  });
+  return { proposals, approve, execute };
+}
+
+exports.FELT_PRIME = FELT_PRIME;
+exports.OE_WINDOW_SECONDS = OE_WINDOW_SECONDS;
+exports.SN_MAIN_CHAIN_ID = SN_MAIN_CHAIN_ID;
+exports.amountToBase = amountToBase;
+exports.assembleActionExecuteCalldata = assembleActionExecuteCalldata;
+exports.buildActionProposal = buildActionProposal;
+exports.buildApproval = buildApproval;
+exports.buildExecuteCalldata = buildExecuteCalldata;
+exports.createProposal = createProposal;
+exports.defineActions = defineActions;
+exports.deriveExecuteAfter = deriveExecuteAfter;
+exports.deserializeEnvelope = deserializeEnvelope;
+exports.newOeNonce = newOeNonce;
+exports.serializeEnvelope = serializeEnvelope;
+exports.signActionApproval = signActionApproval;
+exports.toFelt = toFelt;
+exports.u256 = u256;
+exports.useProposeAction = useProposeAction;
+exports.useTreasuryProposals = useTreasuryProposals;
+exports.voteTemplate = voteTemplate;
+//# sourceMappingURL=multisig.js.map
+//# sourceMappingURL=multisig.js.map