@metadaoproject/futarchy 0.6.0-alpha.2 → 0.6.0-alpha.20

package/dist/v0.5/SharedLiquidityManagerClient.js.map

@@ -1 +1 @@
-{"version":3,"file":"SharedLiquidityManagerClient.js","sourceRoot":"","sources":["../../src/v0.5/SharedLiquidityManagerClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAkBtE,OAAO,EAEL,GAAG,IAAI,yBAAyB,GACjC,MAAM,qCAAqC,CAAC;AAO7C,OAAO,EACL,mCAAmC,EACnC,0BAA0B,EAC1B,iBAAiB,EAIjB,sBAAsB,EACtB,+BAA+B,GAChC,MAAM,gBAAgB,CAAC;AAexB,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAUrD,MAAM,CAAC,MAAM,iCAAiC,GAAG;IAC/C,gBAAgB,EAAE,iBAAiB;IACnC,SAAS,EAAE,sBAAsB;IACjC,aAAa,EAAE,0BAA0B;IACzC,aAAa,EAAE,+BAA+B;CAC/C,CAAC;AAEF,MAAM,OAAO,4BAA4B;IACvB,QAAQ,CAAiB;IACzB,OAAO,CAAyC;IACzD,cAAc,CAAiB;IAEtC,YAAY,MAAgD;QAC1D,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;QAChC,IAAI,CAAC,OAAO,GAAG,IAAI,OAAO,CACxB,yBAAyB,EACzB,MAAM,CAAC,+BAA+B;YACpC,mCAAmC,EACrC,IAAI,CAAC,QAAQ,CACd,CAAC;QACF,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC,YAAY,CAAC;YAChD,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,iBAAiB,EAAE,MAAM,CAAC,iBAAiB;YAC3C,yBAAyB,EAAE,MAAM,CAAC,yBAAyB;YAC3D,YAAY,EAAE,MAAM,CAAC,YAAY;SAClC,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,YAAY,CACxB,MAAgD;QAEhD,OAAO,IAAI,4BAA4B,CAAC,MAAM,CAAC,CAAC;IAClD,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;IAChC,CAAC;CA6vBF"}
+{"version":3,"file":"SharedLiquidityManagerClient.js","sourceRoot":"","sources":["../../src/v0.5/SharedLiquidityManagerClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAiBtE,OAAO,EAEL,GAAG,IAAI,yBAAyB,GACjC,MAAM,qCAAqC,CAAC;AAO7C,OAAO,EACL,mCAAmC,EACnC,0BAA0B,EAC1B,iBAAiB,EAIjB,sBAAsB,EACtB,+BAA+B,GAChC,MAAM,gBAAgB,CAAC;AAexB,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAUrD,MAAM,CAAC,MAAM,iCAAiC,GAAG;IAC/C,gBAAgB,EAAE,iBAAiB;IACnC,SAAS,EAAE,sBAAsB;IACjC,aAAa,EAAE,0BAA0B;IACzC,aAAa,EAAE,+BAA+B;CAC/C,CAAC;AAEF,MAAM,OAAO,4BAA4B;IACvB,QAAQ,CAAiB;IACzB,OAAO,CAAyC;IACzD,cAAc,CAAiB;IAEtC,YAAY,MAAgD;QAC1D,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;QAChC,IAAI,CAAC,OAAO,GAAG,IAAI,OAAO,CACxB,yBAAyB,EACzB,MAAM,CAAC,+BAA+B;YACpC,mCAAmC,EACrC,IAAI,CAAC,QAAQ,CACd,CAAC;QACF,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC,YAAY,CAAC;YAChD,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,iBAAiB,EAAE,MAAM,CAAC,iBAAiB;YAC3C,yBAAyB,EAAE,MAAM,CAAC,yBAAyB;YAC3D,YAAY,EAAE,MAAM,CAAC,YAAY;SAClC,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,YAAY,CACxB,MAAgD;QAEhD,OAAO,IAAI,4BAA4B,CAAC,MAAM,CAAC,CAAC;IAClD,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC;IAChC,CAAC;CA6vBF"}

package/dist/v0.6/FutarchyClient.d.ts

@@ -1,13 +1,14 @@
 import { AnchorProvider, Program } from "@coral-xyz/anchor";
-import { AccountInfo, AddressLookupTableAccount, PublicKey } from "@solana/web3.js";
+import { AccountInfo, AddressLookupTableAccount, PublicKey, Transaction, TransactionInstruction } from "@solana/web3.js";
 import { InitializeDaoParams, UpdateDaoParams } from "./types/index.js";
 import { Futarchy } from "./types/futarchy.js";
+import { Futarchy as v0_6_0_futarchy } from "./types/v0.6.0-futarchy.js";
 import BN from "bn.js";
 import { ConditionalVaultClient } from "./ConditionalVaultClient.js";
 import { Dao, Proposal } from "./types/index.js";
 export type CreateClientParams = {
     provider: AnchorProvider;
-    autocratProgramId?: PublicKey;
+    futarchyProgramId?: PublicKey;
     conditionalVaultProgramId?: PublicKey;
 };
 export type ProposalVaults = {
@@ -16,11 +17,12 @@ export type ProposalVaults = {
 };
 export declare class FutarchyClient {
     readonly provider: AnchorProvider;
-    readonly autocrat: Program<Futarchy>;
+    readonly futarchy: Program<Futarchy>;
+    readonly v0_6_0_futarchy: Program<v0_6_0_futarchy>;
     readonly vaultClient: ConditionalVaultClient;
     readonly luts: AddressLookupTableAccount[];
-    constructor(provider: AnchorProvider, autocratProgramId: PublicKey, conditionalVaultProgramId: PublicKey, luts: AddressLookupTableAccount[]);
-    static createClient(createAutocratClientParams: CreateClientParams): FutarchyClient;
+    constructor(provider: AnchorProvider, futarchyProgramId: PublicKey, conditionalVaultProgramId: PublicKey, luts: AddressLookupTableAccount[]);
+    static createClient(params: CreateClientParams): FutarchyClient;
     getProgramId(): PublicKey;
     getProposal(proposal: PublicKey): Promise<Proposal>;
     getDao(dao: PublicKey): Promise<Dao>;
@@ -214,7 +216,7 @@ export declare class FutarchyClient {
     spotSwapIx({ dao, baseMint, quoteMint, swapType, inputAmount, minOutputAmount, trader, }: {
         dao: PublicKey;
         baseMint: PublicKey;
-        quoteMint: PublicKey;
+        quoteMint?: PublicKey;
         swapType: "buy" | "sell";
         inputAmount: BN;
         minOutputAmount?: BN;
@@ -318,6 +320,14 @@ export declare class FutarchyClient {
             name: "tokenProgram";
             isMut: false;
             isSigner: false;
+        }, {
+            name: "eventAuthority";
+            isMut: false;
+            isSigner: false;
+        }, {
+            name: "program";
+            isMut: false;
+            isSigner: false;
         }];
         args: [{
             name: "params";
@@ -328,16 +338,17 @@ export declare class FutarchyClient {
     } & {
         name: "provideLiquidity";
     }>;
-    conditionalSwapIx({ dao, trader, payer, baseMint, quoteMint, proposal, market, swapType, inputAmount, }: {
+    conditionalSwapIx({ dao, trader, payer, baseMint, quoteMint, proposal, market, swapType, inputAmount, minOutputAmount, }: {
         dao: PublicKey;
         trader?: PublicKey;
         payer?: PublicKey;
         baseMint: PublicKey;
-        quoteMint: PublicKey;
+        quoteMint?: PublicKey;
         proposal: PublicKey;
         market: "pass" | "fail";
         swapType: "buy" | "sell";
         inputAmount: BN;
+        minOutputAmount: BN;
     }): import("@coral-xyz/anchor/dist/cjs/program/namespace/methods.js").MethodsBuilder<Futarchy, {
         name: "conditionalSwap";
         accounts: [{
@@ -432,6 +443,14 @@ export declare class FutarchyClient {
             name: "tokenProgram";
             isMut: false;
             isSigner: false;
+        }, {
+            name: "eventAuthority";
+            isMut: false;
+            isSigner: false;
+        }, {
+            name: "program";
+            isMut: false;
+            isSigner: false;
         }];
         args: [{
             name: "params";
@@ -442,6 +461,15 @@ export declare class FutarchyClient {
     } & {
         name: "conditionalSwap";
     }>;
+    squadsProposalCreateTx({ dao, instructions, transactionIndex, payer, }: {
+        dao: PublicKey;
+        instructions: TransactionInstruction[];
+        transactionIndex: bigint;
+        payer?: PublicKey;
+    }): {
+        tx: Transaction;
+        squadsProposal: PublicKey;
+    };
     initializeProposal(dao: PublicKey, squadsProposal: PublicKey): Promise<PublicKey>;
     initializeProposalIx(squadsProposal: PublicKey, dao: PublicKey, baseMint: PublicKey, quoteMint: PublicKey, question: PublicKey, proposer?: PublicKey): import("@coral-xyz/anchor/dist/cjs/program/namespace/methods.js").MethodsBuilder<Futarchy, {
         name: "initializeProposal";
@@ -495,7 +523,122 @@ export declare class FutarchyClient {
         name: "initializeProposal";
     }>;
     finalizeProposal(proposal: PublicKey): Promise<string>;
-    finalizeProposalIx(proposal: PublicKey, squadsProposal: PublicKey, dao: PublicKey, daoToken: PublicKey, usdc: PublicKey, proposer: PublicKey): import("@coral-xyz/anchor/dist/cjs/program/namespace/methods.js").MethodsBuilder<Futarchy, {
+    finalizeProposalIxV2({ squadsProposal, dao, baseMint, quoteMint, }: {
+        squadsProposal: PublicKey;
+        dao: PublicKey;
+        baseMint: PublicKey;
+        quoteMint?: PublicKey;
+    }): import("@coral-xyz/anchor/dist/cjs/program/namespace/methods.js").MethodsBuilder<Futarchy, {
+        name: "finalizeProposal";
+        accounts: [{
+            name: "proposal";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "dao";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "question";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "squadsProposal";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "squadsMultisig";
+            isMut: false;
+            isSigner: false;
+        }, {
+            name: "squadsMultisigProgram";
+            isMut: false;
+            isSigner: false;
+        }, {
+            name: "ammPassBaseVault";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "ammPassQuoteVault";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "ammFailBaseVault";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "ammFailQuoteVault";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "ammBaseVault";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "ammQuoteVault";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "vaultProgram";
+            isMut: false;
+            isSigner: false;
+        }, {
+            name: "vaultEventAuthority";
+            isMut: false;
+            isSigner: false;
+        }, {
+            name: "tokenProgram";
+            isMut: false;
+            isSigner: false;
+        }, {
+            name: "quoteVault";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "quoteVaultUnderlyingTokenAccount";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "passQuoteMint";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "failQuoteMint";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "passBaseMint";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "failBaseMint";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "baseVault";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "baseVaultUnderlyingTokenAccount";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "eventAuthority";
+            isMut: false;
+            isSigner: false;
+        }, {
+            name: "program";
+            isMut: false;
+            isSigner: false;
+        }];
+        args: [];
+    } & {
+        name: "finalizeProposal";
+    }>;
+    /**
+     * @deprecated use `finalizeProposalIxV2` instead
+     */
+    finalizeProposalIx(proposal: PublicKey, squadsProposal: PublicKey, dao: PublicKey, daoToken: PublicKey, usdc: PublicKey): import("@coral-xyz/anchor/dist/cjs/program/namespace/methods.js").MethodsBuilder<Futarchy, {
         name: "finalizeProposal";
         accounts: [{
             name: "proposal";
@@ -700,6 +843,64 @@ export declare class FutarchyClient {
     } & {
         name: "stakeToProposal";
     }>;
+    unstakeFromProposalIx({ proposal, dao, baseMint, amount, staker, }: {
+        proposal: PublicKey;
+        dao: PublicKey;
+        baseMint: PublicKey;
+        amount: BN;
+        staker?: PublicKey;
+    }): import("@coral-xyz/anchor/dist/cjs/program/namespace/methods.js").MethodsBuilder<Futarchy, {
+        name: "unstakeFromProposal";
+        accounts: [{
+            name: "proposal";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "dao";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "stakerBaseAccount";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "proposalBaseAccount";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "stakeAccount";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "staker";
+            isMut: false;
+            isSigner: true;
+        }, {
+            name: "tokenProgram";
+            isMut: false;
+            isSigner: false;
+        }, {
+            name: "associatedTokenProgram";
+            isMut: false;
+            isSigner: false;
+        }, {
+            name: "eventAuthority";
+            isMut: false;
+            isSigner: false;
+        }, {
+            name: "program";
+            isMut: false;
+            isSigner: false;
+        }];
+        args: [{
+            name: "params";
+            type: {
+                defined: "UnstakeFromProposalParams";
+            };
+        }];
+    } & {
+        name: "unstakeFromProposal";
+    }>;
     collectFeesIx({ dao, baseMint, quoteMint, baseTokenAccount, quoteTokenAccount, }: {
         dao: PublicKey;
         baseMint: PublicKey;
@@ -736,9 +937,48 @@ export declare class FutarchyClient {
             name: "tokenProgram";
             isMut: false;
             isSigner: false;
+        }, {
+            name: "eventAuthority";
+            isMut: false;
+            isSigner: false;
+        }, {
+            name: "program";
+            isMut: false;
+            isSigner: false;
         }];
         args: [];
     } & {
         name: "collectFees";
     }>;
+    sponsorProposalIx({ proposal, dao, teamAddress, }: {
+        proposal: PublicKey;
+        dao: PublicKey;
+        teamAddress?: PublicKey;
+    }): import("@coral-xyz/anchor/dist/cjs/program/namespace/methods.js").MethodsBuilder<Futarchy, {
+        name: "sponsorProposal";
+        accounts: [{
+            name: "proposal";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "dao";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "teamAddress";
+            isMut: false;
+            isSigner: true;
+        }, {
+            name: "eventAuthority";
+            isMut: false;
+            isSigner: false;
+        }, {
+            name: "program";
+            isMut: false;
+            isSigner: false;
+        }];
+        args: [];
+    } & {
+        name: "sponsorProposal";
+    }>;
 }

package/dist/v0.6/FutarchyClient.js

@@ -1,53 +1,59 @@
 import { Program } from "@coral-xyz/anchor";
-import { ComputeBudgetProgram, PublicKey, SystemProgram, } from "@solana/web3.js";
+import { ComputeBudgetProgram, PublicKey, SystemProgram, Transaction, } from "@solana/web3.js";
 // import { Autocrat, IDL as AutocratIDL } from "./types/autocrat.js";
 import { IDL as FutarchyIDL } from "./types/futarchy.js";
+import { IDL as v0_6_0_futarchyIDL, } from "./types/v0.6.0-futarchy.js";
 import BN from "bn.js";
-import { AUTOCRAT_PROGRAM_ID, CONDITIONAL_VAULT_PROGRAM_ID, MAINNET_USDC, SQUADS_PROGRAM_CONFIG, SQUADS_PROGRAM_CONFIG_TREASURY, SQUADS_PROGRAM_ID, } from "./constants.js";
-import { InstructionUtils, getConditionalTokenMintAddr, getDaoAddr, getEventAuthorityAddr, getProposalAddr, getQuestionAddr, getVaultAddr, } from "./utils/index.js";
+import { FUTARCHY_PROGRAM_ID, CONDITIONAL_VAULT_PROGRAM_ID, MAINNET_USDC, PERMISSIONLESS_ACCOUNT, SQUADS_PROGRAM_CONFIG, SQUADS_PROGRAM_CONFIG_TREASURY, SQUADS_PROGRAM_ID, } from "./constants.js";
+import { InstructionUtils, getConditionalTokenMintAddr, getDaoAddr, getEventAuthorityAddr, getProposalAddr, getProposalAddrV2, getQuestionAddr, getVaultAddr, } from "./utils/index.js";
 import { ConditionalVaultClient } from "./ConditionalVaultClient.js";
 import { createAssociatedTokenAccountIdempotentInstruction, getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, } from "@solana/spl-token";
 import { sha256 } from "@noble/hashes/sha256";
 import * as multisig from "@sqds/multisig";
+import { TransactionMessage } from "@solana/web3.js";
+import { getStakeAddr } from "./utils/index.js";
 export class FutarchyClient {
     provider;
-    autocrat;
+    futarchy;
+    // useful for parsing old events
+    v0_6_0_futarchy;
     vaultClient;
     luts;
-    constructor(provider, autocratProgramId, conditionalVaultProgramId, luts) {
+    constructor(provider, futarchyProgramId, conditionalVaultProgramId, luts) {
         this.provider = provider;
-        this.autocrat = new Program(FutarchyIDL, autocratProgramId, provider);
+        this.futarchy = new Program(FutarchyIDL, futarchyProgramId, provider);
+        this.v0_6_0_futarchy = new Program(v0_6_0_futarchyIDL, futarchyProgramId, provider);
         this.vaultClient = ConditionalVaultClient.createClient({
             provider,
             conditionalVaultProgramId,
         });
         this.luts = luts;
     }
-    static createClient(createAutocratClientParams) {
-        let { provider, autocratProgramId, conditionalVaultProgramId } = createAutocratClientParams;
+    static createClient(params) {
+        let { provider, futarchyProgramId: autocratProgramId, conditionalVaultProgramId, } = params;
         const luts = [];
-        return new FutarchyClient(provider, autocratProgramId || AUTOCRAT_PROGRAM_ID, conditionalVaultProgramId || CONDITIONAL_VAULT_PROGRAM_ID, luts);
+        return new FutarchyClient(provider, autocratProgramId || FUTARCHY_PROGRAM_ID, conditionalVaultProgramId || CONDITIONAL_VAULT_PROGRAM_ID, luts);
     }
     getProgramId() {
-        return this.autocrat.programId;
+        return this.futarchy.programId;
     }
     async getProposal(proposal) {
-        return this.autocrat.account.proposal.fetch(proposal);
+        return this.futarchy.account.proposal.fetch(proposal);
     }
     async getDao(dao) {
-        return this.autocrat.account.dao.fetch(dao);
+        return this.futarchy.account.dao.fetch(dao);
     }
     async fetchProposal(proposal) {
-        return this.autocrat.account.proposal.fetchNullable(proposal);
+        return this.futarchy.account.proposal.fetchNullable(proposal);
     }
     async fetchDao(dao) {
-        return this.autocrat.account.dao.fetchNullable(dao);
+        return this.futarchy.account.dao.fetchNullable(dao);
     }
     async deserializeProposal(accountInfo) {
-        return this.autocrat.coder.accounts.decode("proposal", accountInfo.data);
+        return this.futarchy.coder.accounts.decode("proposal", accountInfo.data);
     }
     async deserializeDao(accountInfo) {
-        return this.autocrat.coder.accounts.decode("dao", accountInfo.data);
+        return this.futarchy.coder.accounts.decode("dao", accountInfo.data);
     }
     getProposalPdas(proposal, baseMint, quoteMint, dao) {
         let vaultProgramId = this.vaultClient.vaultProgram.programId;
@@ -88,7 +94,7 @@ export class FutarchyClient {
             multisigPda,
             createKey: dao,
         })[0];
-        return this.autocrat.methods.initializeDao(params).accounts({
+        return this.futarchy.methods.initializeDao(params).accounts({
             dao,
             baseMint,
             quoteMint,
@@ -104,7 +110,7 @@ export class FutarchyClient {
     }
     launchProposalIx({ proposal, dao, baseMint, quoteMint, }) {
         const { baseVault, quoteVault, passBaseMint, passQuoteMint, failBaseMint, failQuoteMint, } = this.getProposalPdas(proposal, baseMint, quoteMint, dao);
-        return this.autocrat.methods
+        return this.futarchy.methods
             .launchProposal()
             .accounts({
             proposal,
@@ -125,8 +131,8 @@ export class FutarchyClient {
             ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 }),
         ]);
     }
-    spotSwapIx({ dao, baseMint, quoteMint, swapType, inputAmount, minOutputAmount = new BN(0), trader = this.provider.publicKey, }) {
-        return this.autocrat.methods
+    spotSwapIx({ dao, baseMint, quoteMint = MAINNET_USDC, swapType, inputAmount, minOutputAmount = new BN(0), trader = this.provider.publicKey, }) {
+        return this.futarchy.methods
             .spotSwap({
             swapType: swapType === "buy" ? { buy: {} } : { sell: {} },
             inputAmount,
@@ -146,13 +152,12 @@ export class FutarchyClient {
         ]);
     }
     provideLiquidityIx({ dao, baseMint, quoteMint, quoteAmount, maxBaseAmount, minLiquidity = new BN(0), positionAuthority = this.provider.publicKey, liquidityProvider = this.provider.publicKey, }) {
-        console.log(positionAuthority);
         const ammPosition = PublicKey.findProgramAddressSync([
             Buffer.from("amm_position"),
             dao.toBuffer(),
             positionAuthority.toBuffer(),
         ], this.getProgramId())[0];
-        return this.autocrat.methods
+        return this.futarchy.methods
             .provideLiquidity({
             quoteAmount,
             maxBaseAmount,
@@ -175,7 +180,7 @@ export class FutarchyClient {
             createAssociatedTokenAccountIdempotentInstruction(this.provider.publicKey, getAssociatedTokenAddressSync(quoteMint, liquidityProvider, true), liquidityProvider, quoteMint),
         ]);
     }
-    conditionalSwapIx({ dao, trader = this.provider.publicKey, payer = this.provider.publicKey, baseMint, quoteMint, proposal, market, swapType, inputAmount, }) {
+    conditionalSwapIx({ dao, trader = this.provider.publicKey, payer = this.provider.publicKey, baseMint, quoteMint = MAINNET_USDC, proposal, market, swapType, inputAmount, minOutputAmount, }) {
         const { passBaseMint, passQuoteMint, failBaseMint, failQuoteMint, baseVault, quoteVault, question, } = this.getProposalPdas(proposal, baseMint, quoteMint, dao);
         let inputMint, outputMint;
         if (market == "pass" && swapType == "buy") {
@@ -197,12 +202,12 @@ export class FutarchyClient {
         else {
             throw new Error("Either `market` or `swapType` is incorrectly configured");
         }
-        return this.autocrat.methods
+        return this.futarchy.methods
             .conditionalSwap({
             market: market == "pass" ? { pass: {} } : { fail: {} },
             swapType: swapType == "buy" ? { buy: {} } : { sell: {} },
             inputAmount,
-            minOutputAmount: new BN(0),
+            minOutputAmount,
         })
             .accounts({
             dao,
@@ -231,9 +236,38 @@ export class FutarchyClient {
             createAssociatedTokenAccountIdempotentInstruction(payer, getAssociatedTokenAddressSync(outputMint, trader, true), trader, outputMint),
         ]);
     }
+    squadsProposalCreateTx({ dao, instructions, transactionIndex, payer = this.provider.publicKey, }) {
+        const multisigPda = multisig.getMultisigPda({ createKey: dao })[0];
+        const transactionMessage = new TransactionMessage({
+            payerKey: payer,
+            recentBlockhash: "", // this doesn't get used
+            instructions,
+        });
+        const vaultTxCreate = multisig.instructions.vaultTransactionCreate({
+            multisigPda,
+            transactionIndex,
+            creator: PERMISSIONLESS_ACCOUNT.publicKey,
+            rentPayer: payer,
+            vaultIndex: 0,
+            ephemeralSigners: 0,
+            transactionMessage,
+        });
+        const proposalCreate = multisig.instructions.proposalCreate({
+            multisigPda,
+            transactionIndex,
+            creator: PERMISSIONLESS_ACCOUNT.publicKey,
+            rentPayer: payer,
+        });
+        const [squadsProposal] = multisig.getProposalPda({
+            multisigPda,
+            transactionIndex: transactionIndex,
+        });
+        const tx = new Transaction().add(vaultTxCreate, proposalCreate);
+        return { tx, squadsProposal };
+    }
     async initializeProposal(dao, squadsProposal) {
         const storedDao = await this.getDao(dao);
-        let [proposal] = getProposalAddr(this.autocrat.programId, squadsProposal);
+        let [proposal] = getProposalAddr(this.futarchy.programId, squadsProposal);
         await this.vaultClient.initializeQuestion(sha256(`Will ${proposal} pass?/FAIL/PASS`), proposal, 2);
         const { question } = this.getProposalPdas(proposal, storedDao.baseMint, storedDao.quoteMint, dao);
         // it's important that these happen in a single atomic transaction
@@ -249,10 +283,10 @@ export class FutarchyClient {
         return proposal;
     }
     initializeProposalIx(squadsProposal, dao, baseMint, quoteMint, question, proposer = this.provider.publicKey) {
-        let [proposal] = getProposalAddr(this.autocrat.programId, squadsProposal);
+        let [proposal] = getProposalAddr(this.futarchy.programId, squadsProposal);
         const { baseVault, quoteVault, passBaseMint, passQuoteMint, failBaseMint, failQuoteMint, } = this.getProposalPdas(proposal, baseMint, quoteMint, dao);
         let [futarchyAmm] = PublicKey.findProgramAddressSync([Buffer.from("futarchy_amm")], this.getProgramId());
-        return this.autocrat.methods
+        return this.futarchy.methods
             .initializeProposal()
             .accounts({
             question,
@@ -273,18 +307,24 @@ export class FutarchyClient {
     async finalizeProposal(proposal) {
         let storedProposal = await this.getProposal(proposal);
         let storedDao = await this.getDao(storedProposal.dao);
-        return this.finalizeProposalIx(proposal, storedProposal.squadsProposal, storedProposal.dao, storedDao.baseMint, storedDao.quoteMint, storedProposal.proposer).rpc();
+        return this.finalizeProposalIx(proposal, storedProposal.squadsProposal, storedProposal.dao, storedDao.baseMint, storedDao.quoteMint).rpc();
     }
-    finalizeProposalIx(proposal, squadsProposal, dao, daoToken, usdc, proposer) {
+    finalizeProposalIxV2({ squadsProposal, dao, baseMint, quoteMint = MAINNET_USDC, }) {
+        const [proposal] = getProposalAddrV2({ squadsProposal });
+        return this.finalizeProposalIx(proposal, squadsProposal, dao, baseMint, quoteMint);
+    }
+    /**
+     * @deprecated use `finalizeProposalIxV2` instead
+     */
+    finalizeProposalIx(proposal, squadsProposal, dao, daoToken, usdc) {
         let vaultProgramId = this.vaultClient.vaultProgram.programId;
         const multisigPda = multisig.getMultisigPda({ createKey: dao })[0];
         const { question, quoteVault, passBaseMint, passQuoteMint, failBaseMint, failQuoteMint, baseVault, } = this.getProposalPdas(proposal, daoToken, usdc, dao);
         const [vaultEventAuthority] = getEventAuthorityAddr(vaultProgramId);
-        return this.autocrat.methods
+        return this.futarchy.methods
             .finalizeProposal()
             .accounts({
             proposal,
-            // futarchyAmm,
             dao,
             squadsProposal,
             squadsMultisig: multisigPda,
@@ -304,8 +344,6 @@ export class FutarchyClient {
             ammBaseVault: getAssociatedTokenAddressSync(daoToken, dao, true),
             baseVault,
             baseVaultUnderlyingTokenAccount: getAssociatedTokenAddressSync(daoToken, baseVault, true),
-            // baseVault,
-            // quoteVault,
             vaultProgram: this.vaultClient.vaultProgram.programId,
             vaultEventAuthority,
         })
@@ -313,51 +351,20 @@ export class FutarchyClient {
             ComputeBudgetProgram.setComputeUnitLimit({ units: 300_000 }),
         ]);
     }
-    // async executeProposal(proposal: PublicKey) {
-    //   let storedProposal = await this.getProposal(proposal);
-    //   return this.executeProposalIx(
-    //     proposal,
-    //     storedProposal.dao,
-    //     storedProposal.instruction
-    //   ).rpc();
-    // }
-    // executeProposalIx(proposal: PublicKey, dao: PublicKey, instruction: any) {
-    //   const [daoTreasury] = getDaoTreasuryAddr(this.autocrat.programId, dao);
-    //   return this.autocrat.methods
-    //     .executeProposal()
-    //     .accounts({
-    //       proposal,
-    //       dao,
-    //       // daoTreasury,
-    //     })
-    //     .remainingAccounts(
-    //       instruction.accounts
-    //         .concat({
-    //           pubkey: instruction.programId,
-    //           isWritable: false,
-    //           isSigner: false,
-    //         })
-    //         .map((meta: AccountMeta) =>
-    //           meta.pubkey.equals(daoTreasury)
-    //             ? { ...meta, isSigner: false }
-    //             : meta
-    //         )
-    //     );
-    // }
     updateDaoIx({ dao, params }) {
         const multisigPda = multisig.getMultisigPda({ createKey: dao })[0];
         const squadsMultisigVault = multisig.getVaultPda({
             multisigPda,
             index: 0,
         })[0];
-        return this.autocrat.methods.updateDao(params).accounts({
+        return this.futarchy.methods.updateDao(params).accounts({
             dao,
             squadsMultisigVault,
         });
     }
     stakeToProposalIx({ proposal, dao, baseMint, amount, staker = this.provider.publicKey, payer = this.provider.publicKey, }) {
-        const stakeAccount = PublicKey.findProgramAddressSync([Buffer.from("stake"), proposal.toBuffer(), staker.toBuffer()], this.getProgramId())[0];
-        return this.autocrat.methods
+        const stakeAccount = getStakeAddr(FUTARCHY_PROGRAM_ID, proposal, staker)[0];
+        return this.futarchy.methods
             .stakeToProposal({ amount })
             .accounts({
             proposal,
@@ -376,8 +383,21 @@ export class FutarchyClient {
             createAssociatedTokenAccountIdempotentInstruction(payer, getAssociatedTokenAddressSync(baseMint, proposal, true), proposal, baseMint),
         ]);
     }
+    unstakeFromProposalIx({ proposal, dao, baseMint, amount, staker = this.provider.publicKey, }) {
+        const stakeAccount = getStakeAddr(FUTARCHY_PROGRAM_ID, proposal, staker)[0];
+        return this.futarchy.methods.unstakeFromProposal({ amount }).accounts({
+            proposal,
+            dao,
+            stakerBaseAccount: getAssociatedTokenAddressSync(baseMint, staker, true),
+            proposalBaseAccount: getAssociatedTokenAddressSync(baseMint, proposal, true),
+            stakeAccount,
+            staker,
+            tokenProgram: TOKEN_PROGRAM_ID,
+            associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+        });
+    }
     collectFeesIx({ dao, baseMint, quoteMint, baseTokenAccount = getAssociatedTokenAddressSync(baseMint, this.provider.publicKey), quoteTokenAccount = getAssociatedTokenAddressSync(quoteMint, this.provider.publicKey), }) {
-        return this.autocrat.methods.collectFees().accounts({
+        return this.futarchy.methods.collectFees().accounts({
             dao,
             admin: this.provider.publicKey,
             ammBaseVault: getAssociatedTokenAddressSync(baseMint, dao, true),
@@ -386,5 +406,12 @@ export class FutarchyClient {
             quoteTokenAccount,
         });
     }
+    sponsorProposalIx({ proposal, dao, teamAddress = this.provider.publicKey, }) {
+        return this.futarchy.methods.sponsorProposal().accounts({
+            proposal,
+            dao,
+            teamAddress,
+        });
+    }
 }
 //# sourceMappingURL=FutarchyClient.js.map