@metadaoproject/futarchy 0.3.0-alpha.16 → 0.3.0-alpha.17

package/dist/ConditionalVaultClient.d.ts

@@ -1,5 +1,5 @@
 import { AnchorProvider, Program } from "@coral-xyz/anchor";
-import { Keypair, PublicKey } from "@solana/web3.js";
+import { AddressLookupTableAccount, Keypair, PublicKey } from "@solana/web3.js";
 import { ConditionalVault } from "./types/conditional_vault";
 import BN from "bn.js";
 import { MethodsBuilder } from "@coral-xyz/anchor/dist/cjs/program/namespace/methods";
@@ -10,110 +10,65 @@ export type CreateVaultClientParams = {
 export declare class ConditionalVaultClient {
     readonly provider: AnchorProvider;
     readonly vaultProgram: Program<ConditionalVault>;
-    constructor(provider: AnchorProvider, conditionalVaultProgramId: PublicKey);
+    readonly luts: AddressLookupTableAccount[];
+    constructor(provider: AnchorProvider, conditionalVaultProgramId: PublicKey, luts: AddressLookupTableAccount[]);
     static createClient(createVaultClientParams: CreateVaultClientParams): ConditionalVaultClient;
-    fetchQuestion(question: PublicKey): Promise<{
-        questionId: number[];
-        oracle: PublicKey;
-        payoutNumerators: number[];
-        payoutDenominator: number;
-    }>;
-    fetchVault(vault: PublicKey): Promise<{
-        question: PublicKey;
-        underlyingTokenMint: PublicKey;
-        underlyingTokenAccount: PublicKey;
-        conditionalTokenMints: PublicKey[];
-        pdaBump: number;
-        decimals: number;
-    }>;
     getVault(vault: PublicKey): Promise<{
-        question: PublicKey;
+        status: ({
+            finalized?: undefined;
+            reverted?: undefined;
+        } & {
+            active: Record<string, never>;
+        }) | ({
+            active?: undefined;
+            reverted?: undefined;
+        } & {
+            finalized: Record<string, never>;
+        }) | ({
+            active?: undefined;
+            finalized?: undefined;
+        } & {
+            reverted: Record<string, never>;
+        });
+        settlementAuthority: PublicKey;
         underlyingTokenMint: PublicKey;
         underlyingTokenAccount: PublicKey;
-        conditionalTokenMints: PublicKey[];
+        conditionalOnFinalizeTokenMint: PublicKey;
+        conditionalOnRevertTokenMint: PublicKey;
         pdaBump: number;
         decimals: number;
     }>;
-    initializeQuestionIx(questionId: Uint8Array, oracle: PublicKey, numConditions: number): MethodsBuilder<ConditionalVault, {
-        name: "initializeQuestion";
+    mintConditionalTokens(vault: PublicKey, uiAmount: number, user?: PublicKey | Keypair): Promise<string>;
+    mintConditionalTokensIx(vault: PublicKey, underlyingTokenMint: PublicKey, amount: BN, user?: PublicKey | Keypair): MethodsBuilder<ConditionalVault, {
+        name: "mintConditionalTokens";
         accounts: [{
-            name: "question";
-            isMut: true;
+            name: "vault";
+            isMut: false;
             isSigner: false;
         }, {
-            name: "payer";
+            name: "conditionalOnFinalizeTokenMint";
             isMut: true;
-            isSigner: true;
+            isSigner: false;
         }, {
-            name: "systemProgram";
-            isMut: false;
+            name: "conditionalOnRevertTokenMint";
+            isMut: true;
             isSigner: false;
-        }];
-        args: [{
-            name: "args";
-            type: {
-                defined: "InitializeQuestionArgs";
-            };
-        }];
-    } & {
-        name: "initializeQuestion";
-    }>;
-    initializeQuestion(questionId: Uint8Array, oracle: PublicKey, numConditions: number): Promise<PublicKey>;
-    initializeVaultIx(question: PublicKey, underlyingTokenMint: PublicKey, numOutcomes: number): MethodsBuilder<ConditionalVault, any>;
-    initializeVault(question: PublicKey, underlyingTokenMint: PublicKey, numOutcomes: number): Promise<PublicKey>;
-    resolveQuestionIx(question: PublicKey, oracle: Keypair, payoutNumerators: number[]): MethodsBuilder<ConditionalVault, {
-        name: "resolveQuestion";
-        accounts: [{
-            name: "question";
+        }, {
+            name: "vaultUnderlyingTokenAccount";
             isMut: true;
             isSigner: false;
         }, {
-            name: "oracle";
+            name: "authority";
             isMut: false;
             isSigner: true;
-        }];
-        args: [{
-            name: "args";
-            type: {
-                defined: "ResolveQuestionArgs";
-            };
-        }];
-    } & {
-        name: "resolveQuestion";
-    }>;
-    getConditionalTokenMints(vault: PublicKey, numOutcomes: number): PublicKey[];
-    getRemainingAccounts(conditionalTokenMints: PublicKey[], userConditionalAccounts: PublicKey[]): {
-        pubkey: PublicKey;
-        isWritable: boolean;
-        isSigner: boolean;
-    }[];
-    getConditionalTokenAccountsAndInstructions(vault: PublicKey, numOutcomes: number, user: PublicKey): {
-        userConditionalAccounts: PublicKey[];
-        preInstructions: import("@solana/web3.js").TransactionInstruction[];
-        remainingAccounts: {
-            pubkey: PublicKey;
-            isWritable: boolean;
-            isSigner: boolean;
-        }[];
-    };
-    splitTokensIx(question: PublicKey, vault: PublicKey, underlyingTokenMint: PublicKey, amount: BN, numOutcomes: number, user?: PublicKey): MethodsBuilder<ConditionalVault, {
-        name: "splitTokens";
-        accounts: [{
-            name: "question";
-            isMut: false;
-            isSigner: false;
         }, {
-            name: "vault";
-            isMut: false;
+            name: "userConditionalOnFinalizeTokenAccount";
+            isMut: true;
             isSigner: false;
         }, {
-            name: "vaultUnderlyingTokenAccount";
+            name: "userConditionalOnRevertTokenAccount";
             isMut: true;
             isSigner: false;
-        }, {
-            name: "authority";
-            isMut: false;
-            isSigner: true;
         }, {
             name: "userUnderlyingTokenAccount";
             isMut: true;
@@ -128,51 +83,78 @@ export declare class ConditionalVaultClient {
             type: "u64";
         }];
     } & {
-        name: "splitTokens";
+        name: "mintConditionalTokens";
     }>;
-    mergeTokensIx(question: PublicKey, vault: PublicKey, underlyingTokenMint: PublicKey, amount: BN, numOutcomes: number, user?: PublicKey): MethodsBuilder<ConditionalVault, {
-        name: "mergeTokens";
+    initializeVaultIx(settlementAuthority: PublicKey, underlyingTokenMint: PublicKey): MethodsBuilder<ConditionalVault, any>;
+    addMetadataToConditionalTokensIx(vault: PublicKey, underlyingTokenMint: PublicKey, proposalNumber: number, onFinalizeUri: string, onRevertUri: string): MethodsBuilder<ConditionalVault, {
+        name: "addMetadataToConditionalTokens";
         accounts: [{
-            name: "question";
-            isMut: false;
-            isSigner: false;
+            name: "payer";
+            isMut: true;
+            isSigner: true;
         }, {
             name: "vault";
-            isMut: false;
+            isMut: true;
             isSigner: false;
         }, {
-            name: "vaultUnderlyingTokenAccount";
+            name: "underlyingTokenMint";
             isMut: true;
             isSigner: false;
         }, {
-            name: "authority";
+            name: "underlyingTokenMetadata";
             isMut: false;
-            isSigner: true;
+            isSigner: false;
         }, {
-            name: "userUnderlyingTokenAccount";
+            name: "conditionalOnFinalizeTokenMint";
             isMut: true;
             isSigner: false;
         }, {
-            name: "tokenProgram";
+            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: "amount";
-            type: "u64";
+            name: "args";
+            type: {
+                defined: "AddMetadataToConditionalTokensArgs";
+            };
         }];
     } & {
-        name: "mergeTokens";
+        name: "addMetadataToConditionalTokens";
     }>;
-    redeemTokensIx(question: PublicKey, vault: PublicKey, underlyingTokenMint: PublicKey, numOutcomes: number, user?: PublicKey): MethodsBuilder<ConditionalVault, {
-        name: "redeemTokens";
+    redeemConditionalTokensIx(vault: PublicKey, underlyingTokenMint: PublicKey): MethodsBuilder<ConditionalVault, {
+        name: "redeemConditionalTokensForUnderlyingTokens";
         accounts: [{
-            name: "question";
+            name: "vault";
             isMut: false;
             isSigner: false;
         }, {
-            name: "vault";
-            isMut: false;
+            name: "conditionalOnFinalizeTokenMint";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "conditionalOnRevertTokenMint";
+            isMut: true;
             isSigner: false;
         }, {
             name: "vaultUnderlyingTokenAccount";
@@ -182,6 +164,14 @@ export declare class ConditionalVaultClient {
             name: "authority";
             isMut: false;
             isSigner: true;
+        }, {
+            name: "userConditionalOnFinalizeTokenAccount";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "userConditionalOnRevertTokenAccount";
+            isMut: true;
+            isSigner: false;
         }, {
             name: "userUnderlyingTokenAccount";
             isMut: true;
@@ -193,46 +183,53 @@ export declare class ConditionalVaultClient {
         }];
         args: [];
     } & {
-        name: "redeemTokens";
+        name: "redeemConditionalTokensForUnderlyingTokens";
     }>;
-    addMetadataToConditionalTokensIx(vault: PublicKey, index: number, name: string, symbol: string, image: string): MethodsBuilder<ConditionalVault, {
-        name: "addMetadataToConditionalTokens";
+    mergeConditionalTokensIx(vault: PublicKey, underlyingTokenMint: PublicKey, amount: BN): MethodsBuilder<ConditionalVault, {
+        name: "mergeConditionalTokensForUnderlyingTokens";
         accounts: [{
-            name: "payer";
-            isMut: true;
-            isSigner: true;
-        }, {
             name: "vault";
+            isMut: false;
+            isSigner: false;
+        }, {
+            name: "conditionalOnFinalizeTokenMint";
             isMut: true;
             isSigner: false;
         }, {
-            name: "conditionalTokenMint";
+            name: "conditionalOnRevertTokenMint";
             isMut: true;
             isSigner: false;
         }, {
-            name: "conditionalTokenMetadata";
+            name: "vaultUnderlyingTokenAccount";
             isMut: true;
             isSigner: false;
         }, {
-            name: "tokenMetadataProgram";
+            name: "authority";
             isMut: false;
+            isSigner: true;
+        }, {
+            name: "userConditionalOnFinalizeTokenAccount";
+            isMut: true;
             isSigner: false;
         }, {
-            name: "systemProgram";
-            isMut: false;
+            name: "userConditionalOnRevertTokenAccount";
+            isMut: true;
             isSigner: false;
         }, {
-            name: "rent";
+            name: "userUnderlyingTokenAccount";
+            isMut: true;
+            isSigner: false;
+        }, {
+            name: "tokenProgram";
             isMut: false;
             isSigner: false;
         }];
         args: [{
-            name: "args";
-            type: {
-                defined: "AddMetadataToConditionalTokensArgs";
-            };
+            name: "amount";
+            type: "u64";
         }];
     } & {
-        name: "addMetadataToConditionalTokens";
+        name: "mergeConditionalTokensForUnderlyingTokens";
     }>;
+    initializeVault(settlementAuthority: PublicKey, underlyingTokenMint: PublicKey): Promise<PublicKey>;
 }