@metadaoproject/futarchy 0.4.0-alpha.4 → 0.4.0-alpha.41

package/dist/v0.3/types/conditional_vault.js

@@ -0,0 +1,448 @@
+export const IDL = {
+    version: "0.3.0",
+    name: "conditional_vault",
+    instructions: [
+        {
+            name: "initializeConditionalVault",
+            accounts: [
+                {
+                    name: "vault",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "underlyingTokenMint",
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: "conditionalOnFinalizeTokenMint",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "conditionalOnRevertTokenMint",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "vaultUnderlyingTokenAccount",
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: "payer",
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: "tokenProgram",
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: "associatedTokenProgram",
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: "systemProgram",
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: "args",
+                    type: {
+                        defined: "InitializeConditionalVaultArgs",
+                    },
+                },
+            ],
+        },
+        {
+            name: "addMetadataToConditionalTokens",
+            accounts: [
+                {
+                    name: "payer",
+                    isMut: true,
+                    isSigner: true,
+                },
+                {
+                    name: "vault",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "underlyingTokenMint",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "underlyingTokenMetadata",
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: "conditionalOnFinalizeTokenMint",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "conditionalOnRevertTokenMint",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "conditionalOnFinalizeTokenMetadata",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "conditionalOnRevertTokenMetadata",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "tokenMetadataProgram",
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: "systemProgram",
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: "rent",
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: "args",
+                    type: {
+                        defined: "AddMetadataToConditionalTokensArgs",
+                    },
+                },
+            ],
+        },
+        {
+            name: "settleConditionalVault",
+            accounts: [
+                {
+                    name: "settlementAuthority",
+                    isMut: false,
+                    isSigner: true,
+                },
+                {
+                    name: "vault",
+                    isMut: true,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: "newStatus",
+                    type: {
+                        defined: "VaultStatus",
+                    },
+                },
+            ],
+        },
+        {
+            name: "mergeConditionalTokensForUnderlyingTokens",
+            accounts: [
+                {
+                    name: "vault",
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: "conditionalOnFinalizeTokenMint",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "conditionalOnRevertTokenMint",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "vaultUnderlyingTokenAccount",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "authority",
+                    isMut: false,
+                    isSigner: true,
+                },
+                {
+                    name: "userConditionalOnFinalizeTokenAccount",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "userConditionalOnRevertTokenAccount",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "userUnderlyingTokenAccount",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "tokenProgram",
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: "amount",
+                    type: "u64",
+                },
+            ],
+        },
+        {
+            name: "mintConditionalTokens",
+            accounts: [
+                {
+                    name: "vault",
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: "conditionalOnFinalizeTokenMint",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "conditionalOnRevertTokenMint",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "vaultUnderlyingTokenAccount",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "authority",
+                    isMut: false,
+                    isSigner: true,
+                },
+                {
+                    name: "userConditionalOnFinalizeTokenAccount",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "userConditionalOnRevertTokenAccount",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "userUnderlyingTokenAccount",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "tokenProgram",
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [
+                {
+                    name: "amount",
+                    type: "u64",
+                },
+            ],
+        },
+        {
+            name: "redeemConditionalTokensForUnderlyingTokens",
+            accounts: [
+                {
+                    name: "vault",
+                    isMut: false,
+                    isSigner: false,
+                },
+                {
+                    name: "conditionalOnFinalizeTokenMint",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "conditionalOnRevertTokenMint",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "vaultUnderlyingTokenAccount",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "authority",
+                    isMut: false,
+                    isSigner: true,
+                },
+                {
+                    name: "userConditionalOnFinalizeTokenAccount",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "userConditionalOnRevertTokenAccount",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "userUnderlyingTokenAccount",
+                    isMut: true,
+                    isSigner: false,
+                },
+                {
+                    name: "tokenProgram",
+                    isMut: false,
+                    isSigner: false,
+                },
+            ],
+            args: [],
+        },
+    ],
+    accounts: [
+        {
+            name: "conditionalVault",
+            type: {
+                kind: "struct",
+                fields: [
+                    {
+                        name: "status",
+                        type: {
+                            defined: "VaultStatus",
+                        },
+                    },
+                    {
+                        name: "settlementAuthority",
+                        docs: [
+                            "The account that can either finalize the vault to make conditional tokens",
+                            "redeemable for underlying tokens or revert the vault to make deposit",
+                            "slips redeemable for underlying tokens.",
+                        ],
+                        type: "publicKey",
+                    },
+                    {
+                        name: "underlyingTokenMint",
+                        docs: ["The mint of the tokens that are deposited into the vault."],
+                        type: "publicKey",
+                    },
+                    {
+                        name: "underlyingTokenAccount",
+                        docs: ["The vault's storage account for deposited funds."],
+                        type: "publicKey",
+                    },
+                    {
+                        name: "conditionalOnFinalizeTokenMint",
+                        type: "publicKey",
+                    },
+                    {
+                        name: "conditionalOnRevertTokenMint",
+                        type: "publicKey",
+                    },
+                    {
+                        name: "pdaBump",
+                        type: "u8",
+                    },
+                    {
+                        name: "decimals",
+                        type: "u8",
+                    },
+                ],
+            },
+        },
+    ],
+    types: [
+        {
+            name: "AddMetadataToConditionalTokensArgs",
+            type: {
+                kind: "struct",
+                fields: [
+                    {
+                        name: "proposalNumber",
+                        type: "u64",
+                    },
+                    {
+                        name: "onFinalizeUri",
+                        type: "string",
+                    },
+                    {
+                        name: "onRevertUri",
+                        type: "string",
+                    },
+                ],
+            },
+        },
+        {
+            name: "InitializeConditionalVaultArgs",
+            type: {
+                kind: "struct",
+                fields: [
+                    {
+                        name: "settlementAuthority",
+                        type: "publicKey",
+                    },
+                ],
+            },
+        },
+        {
+            name: "VaultStatus",
+            type: {
+                kind: "enum",
+                variants: [
+                    {
+                        name: "Active",
+                    },
+                    {
+                        name: "Finalized",
+                    },
+                    {
+                        name: "Reverted",
+                    },
+                ],
+            },
+        },
+    ],
+    errors: [
+        {
+            code: 6000,
+            name: "InsufficientUnderlyingTokens",
+            msg: "Insufficient underlying token balance to mint this amount of conditional tokens",
+        },
+        {
+            code: 6001,
+            name: "InvalidVaultUnderlyingTokenAccount",
+            msg: "This `vault_underlying_token_account` is not this vault's `underlying_token_account`",
+        },
+        {
+            code: 6002,
+            name: "InvalidConditionalTokenMint",
+            msg: "This conditional token mint is not this vault's conditional token mint",
+        },
+        {
+            code: 6003,
+            name: "CantRedeemConditionalTokens",
+            msg: "Vault needs to be settled as finalized before users can redeem conditional tokens for underlying tokens",
+        },
+        {
+            code: 6004,
+            name: "VaultAlreadySettled",
+            msg: "Once a vault has been settled, its status as either finalized or reverted cannot be changed",
+        },
+    ],
+};
+//# sourceMappingURL=conditional_vault.js.map

package/dist/v0.3/types/conditional_vault.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional_vault.js","sourceRoot":"","sources":["../../../src/v0.3/types/conditional_vault.ts"],"names":[],"mappings":"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"}

package/dist/v0.3/types/index.d.ts

@@ -0,0 +1,21 @@
+import { Autocrat } from "./autocrat.js";
+export { Autocrat, IDL as AutocratIDL } from "./autocrat.js";
+import { Amm } from "./amm.js";
+export { Amm, IDL as AmmIDL } from "./amm.js";
+import { ConditionalVault } from "./conditional_vault.js";
+export { ConditionalVault, IDL as ConditionalVaultIDL, } from "./conditional_vault.js";
+export { LowercaseKeys } from "./utils.js";
+import type { IdlAccounts, IdlTypes } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+export type InitializeDaoParams = IdlTypes<Autocrat>["InitializeDaoParams"];
+export type UpdateDaoParams = IdlTypes<Autocrat>["UpdateDaoParams"];
+export type ProposalInstruction = IdlTypes<Autocrat>["ProposalInstruction"];
+export type Proposal = IdlAccounts<Autocrat>["proposal"];
+export type ProposalWrapper = {
+    account: Proposal;
+    publicKey: PublicKey;
+};
+export type DaoAccount = IdlAccounts<Autocrat>["dao"];
+export type ProposalAccount = IdlAccounts<Autocrat>["proposal"];
+export type AmmAccount = IdlAccounts<Amm>["amm"];
+export type ConditionalVaultAccount = IdlAccounts<ConditionalVault>["conditionalVault"];

package/dist/v0.3/types/index.js

@@ -0,0 +1,4 @@
+export { IDL as AutocratIDL } from "./autocrat.js";
+export { IDL as AmmIDL } from "./amm.js";
+export { IDL as ConditionalVaultIDL, } from "./conditional_vault.js";
+//# sourceMappingURL=index.js.map

package/dist/v0.3/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/v0.3/types/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,GAAG,IAAI,WAAW,EAAE,MAAM,eAAe,CAAC;AAG7D,OAAO,EAAO,GAAG,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAG9C,OAAO,EAEL,GAAG,IAAI,mBAAmB,GAC3B,MAAM,wBAAwB,CAAC"}

package/dist/v0.3/types/utils.d.ts

@@ -0,0 +1,3 @@
+export type LowercaseKeys<T> = {
+    [K in keyof T as Lowercase<string & K>]: T[K];
+};

package/dist/v0.3/types/utils.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.js.map

package/dist/v0.3/types/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/v0.3/types/utils.ts"],"names":[],"mappings":""}

package/dist/v0.3/utils/ammMath.d.ts

@@ -0,0 +1,39 @@
+import BN from "bn.js";
+import { AmmAccount } from "../types/index.js";
+import { SwapType } from "../AmmClient.js";
+export type AddLiquiditySimulation = {
+    baseAmount: BN;
+    quoteAmount: BN;
+    expectedLpTokens: BN;
+    minLpTokens?: BN;
+    maxBaseAmount?: BN;
+};
+export type SwapSimulation = {
+    expectedOut: BN;
+    newBaseReserves: BN;
+    newQuoteReserves: BN;
+    minExpectedOut?: BN;
+};
+export type RemoveLiquiditySimulation = {
+    expectedBaseOut: BN;
+    expectedQuoteOut: BN;
+    minBaseOut?: BN;
+    minQuoteOut?: BN;
+};
+export declare class AmmMath {
+    static getHumanPriceFromReserves(baseReserves: BN, quoteReserves: BN, baseDecimals: number, quoteDecimals: number): number;
+    static getAmmPriceFromReserves(baseReserves: BN, quoteReserves: BN): BN;
+    static getChainAmount(humanAmount: number, decimals: number): BN;
+    static getHumanAmount(chainAmount: BN, decimals: number): number;
+    static getHumanPrice(ammPrice: BN, baseDecimals: number, quoteDecimals: number): number;
+    static getAmmPrice(humanPrice: number, baseDecimals: number, quoteDecimals: number): BN;
+    static getAmmPrices(baseDecimals: number, quoteDecimals: number, ...prices: number[]): BN[];
+    static scale(number: number, decimals: number): BN;
+    static addSlippage(chainAmount: BN, slippageBps: BN): BN;
+    static subtractSlippage(chainAmount: BN, slippageBps: BN): BN;
+    static getTwap(amm: AmmAccount): BN;
+    static simulateAddLiquidity(baseReserves: BN, quoteReserves: BN, lpMintSupply: number, baseAmount?: BN, quoteAmount?: BN, slippageBps?: BN): AddLiquiditySimulation;
+    static simulateSwap(inputAmount: BN, swapType: SwapType, baseReserves: BN, quoteReserves: BN, slippageBps?: BN): SwapSimulation;
+    static simulateRemoveLiquidity(lpTokensToBurn: BN, baseReserves: BN, quoteReserves: BN, lpTotalSupply: BN, slippageBps?: BN): RemoveLiquiditySimulation;
+}
+export { AmmMath as PriceMath };

package/dist/v0.3/utils/ammMath.js

@@ -0,0 +1,142 @@
+import BN from "bn.js";
+const BN_TEN = new BN(10);
+const PRICE_SCALE = BN_TEN.pow(new BN(12));
+const PRICE_SCALE_NUMBER = 1e12;
+export class AmmMath {
+    static getHumanPriceFromReserves(baseReserves, quoteReserves, baseDecimals, quoteDecimals) {
+        return this.getHumanPrice(this.getAmmPriceFromReserves(baseReserves, quoteReserves), baseDecimals, quoteDecimals);
+    }
+    static getAmmPriceFromReserves(baseReserves, quoteReserves) {
+        return quoteReserves.mul(PRICE_SCALE).div(baseReserves);
+    }
+    static getChainAmount(humanAmount, decimals) {
+        // you have to do it this weird way because BN can't be constructed with
+        // numbers larger than 2**50
+        const [integerPart, fractionalPart = ""] = humanAmount
+            .toString()
+            .split(".");
+        return new BN(integerPart + fractionalPart)
+            .mul(new BN(10).pow(new BN(decimals)))
+            .div(new BN(10).pow(new BN(fractionalPart.length)));
+    }
+    static getHumanAmount(chainAmount, decimals) {
+        return chainAmount.toNumber() / 10 ** decimals;
+    }
+    static getHumanPrice(ammPrice, baseDecimals, quoteDecimals) {
+        let decimalScalar = BN_TEN.pow(new BN(quoteDecimals - baseDecimals).abs());
+        let price1e12 = quoteDecimals > baseDecimals
+            ? ammPrice.div(decimalScalar)
+            : ammPrice.mul(decimalScalar);
+        return price1e12.toNumber() / 1e12;
+    }
+    static getAmmPrice(humanPrice, baseDecimals, quoteDecimals) {
+        let price1e12 = new BN(humanPrice * PRICE_SCALE_NUMBER);
+        let decimalScalar = BN_TEN.pow(new BN(quoteDecimals - baseDecimals).abs());
+        let scaledPrice = quoteDecimals > baseDecimals
+            ? price1e12.mul(decimalScalar)
+            : price1e12.div(decimalScalar);
+        return scaledPrice;
+    }
+    static getAmmPrices(baseDecimals, quoteDecimals, ...prices) {
+        // Map through each price, scaling it using the scalePrice method
+        return prices.map((price) => this.getAmmPrice(price, baseDecimals, quoteDecimals));
+    }
+    static scale(number, decimals) {
+        return new BN(number * 10 ** decimals);
+        // return new BN(number).mul(new BN(10).pow(new BN(decimals)));
+    }
+    static addSlippage(chainAmount, slippageBps) {
+        return chainAmount.mul(slippageBps.addn(10_000)).divn(10_000);
+    }
+    static subtractSlippage(chainAmount, slippageBps) {
+        return chainAmount.mul(new BN(10_000).sub(slippageBps)).divn(10_000);
+    }
+    static getTwap(amm) {
+        return amm.oracle.aggregator.div(amm.oracle.lastUpdatedSlot.sub(amm.createdAtSlot));
+    }
+    static simulateAddLiquidity(baseReserves, quoteReserves, lpMintSupply, baseAmount, quoteAmount, slippageBps) {
+        if (lpMintSupply == 0) {
+            throw new Error("This AMM doesn't have existing liquidity so we can't fill in the blanks");
+        }
+        if (baseAmount == undefined && quoteAmount == undefined) {
+            throw new Error("Must specify either a base amount or a quote amount");
+        }
+        let expectedLpTokens;
+        if (quoteAmount == undefined) {
+            quoteAmount = baseAmount?.mul(quoteReserves).div(baseReserves);
+        }
+        baseAmount = quoteAmount?.mul(baseReserves).div(quoteReserves).addn(1);
+        expectedLpTokens = quoteAmount
+            ?.mul(new BN(lpMintSupply))
+            .div(quoteReserves);
+        let minLpTokens, maxBaseAmount;
+        if (slippageBps) {
+            minLpTokens = AmmMath.subtractSlippage(expectedLpTokens, slippageBps);
+            maxBaseAmount = AmmMath.addSlippage(baseAmount, slippageBps);
+        }
+        return {
+            quoteAmount: quoteAmount,
+            baseAmount: baseAmount,
+            expectedLpTokens,
+            minLpTokens,
+            maxBaseAmount,
+        };
+    }
+    static simulateSwap(inputAmount, swapType, baseReserves, quoteReserves, slippageBps) {
+        if (baseReserves.eqn(0) || quoteReserves.eqn(0)) {
+            throw new Error("reserves must be non-zero");
+        }
+        let inputReserves, outputReserves;
+        if (swapType.buy) {
+            inputReserves = quoteReserves;
+            outputReserves = baseReserves;
+        }
+        else {
+            inputReserves = baseReserves;
+            outputReserves = quoteReserves;
+        }
+        let inputAmountWithFee = inputAmount.muln(990);
+        let numerator = inputAmountWithFee.mul(outputReserves);
+        let denominator = inputReserves.muln(1000).add(inputAmountWithFee);
+        let expectedOut = numerator.div(denominator);
+        let minExpectedOut;
+        if (slippageBps) {
+            minExpectedOut = AmmMath.subtractSlippage(expectedOut, slippageBps);
+        }
+        let newBaseReserves, newQuoteReserves;
+        if (swapType.buy) {
+            newBaseReserves = baseReserves.sub(expectedOut);
+            newQuoteReserves = quoteReserves.add(inputAmount);
+        }
+        else {
+            newBaseReserves = baseReserves.add(inputAmount);
+            newQuoteReserves = quoteReserves.sub(expectedOut);
+        }
+        return {
+            expectedOut,
+            newBaseReserves,
+            newQuoteReserves,
+            minExpectedOut,
+        };
+    }
+    static simulateRemoveLiquidity(lpTokensToBurn, baseReserves, quoteReserves, lpTotalSupply, slippageBps) {
+        const expectedBaseOut = lpTokensToBurn.mul(baseReserves).div(lpTotalSupply);
+        const expectedQuoteOut = lpTokensToBurn
+            .mul(quoteReserves)
+            .div(lpTotalSupply);
+        let minBaseOut, minQuoteOut;
+        if (slippageBps) {
+            minBaseOut = AmmMath.subtractSlippage(expectedBaseOut, slippageBps);
+            minQuoteOut = AmmMath.subtractSlippage(expectedQuoteOut, slippageBps);
+        }
+        return {
+            expectedBaseOut,
+            expectedQuoteOut,
+            minBaseOut,
+            minQuoteOut,
+        };
+    }
+}
+// Add backwards compatibility alias
+export { AmmMath as PriceMath };
+//# sourceMappingURL=ammMath.js.map