@xgamesfun/solana 0.20.1 → 0.25.0

package/types/client/ix.d.ts

@@ -5,6 +5,3299 @@ export { IDL, ASSOCIATED_TOKEN_PROGRAM };
 export declare const TOKEN_METADATA_PROGRAM = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
 /** 32 bytes a project names a call by (a match id, a payout's reason). Zeros when not given. */
 export declare function reference(value: any): Uint8Array<ArrayBuffer>;
+/** The IDL entry of the loot instruction whose data is `data` (its tag first), or null. */
+export declare const instructionOf: (data: any) => {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+        address?: undefined;
+    } | {
+        signer?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        address?: undefined;
+    } | {
+        signer?: undefined;
+        name: string;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+    } | {
+        signer?: undefined;
+        name: string;
+        writable: boolean;
+        docs?: undefined;
+        address?: undefined;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        name: string;
+        docs: string[];
+        address: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        name: string;
+        address: string;
+    })[];
+    args: {
+        name: string;
+        type: string;
+    }[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        docs?: undefined;
+        address?: undefined;
+        name: string;
+        writable: boolean;
+        signer: boolean;
+        optional?: undefined;
+        accounts?: undefined;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        name: string;
+        optional?: undefined;
+        accounts?: undefined;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        name: string;
+        writable: boolean;
+        optional?: undefined;
+        accounts?: undefined;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        name: string;
+        docs: string[];
+        optional?: undefined;
+        accounts?: undefined;
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        optional: boolean;
+        accounts?: undefined;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        name: string;
+        writable: boolean;
+        optional: boolean;
+        accounts?: undefined;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        name: string;
+        address: string;
+        accounts?: undefined;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    })[];
+    args: ({
+        name: string;
+        type: string;
+    } | {
+        name: string;
+        type: {
+            array: (string | number)[];
+        };
+    })[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        address: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        optional: boolean;
+        address: string;
+    })[];
+    args: ({
+        name: string;
+        type: string;
+    } | {
+        name: string;
+        type: {
+            option: string;
+        };
+    })[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        name: string;
+        docs: string[];
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        name: string;
+    })[];
+    args: {
+        name: string;
+        type: {
+            array: (string | number)[];
+        };
+    }[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        writable?: undefined;
+        name: string;
+        docs: string[];
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        name: string;
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        name: string;
+        docs: string[];
+    })[];
+    args: {
+        name: string;
+        type: {
+            array: (string | number)[];
+        };
+    }[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+        pda?: undefined;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        pda?: undefined;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        writable: boolean;
+        pda?: undefined;
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        pda?: undefined;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        writable: boolean;
+        pda: {
+            seeds: ({
+                kind: string;
+                value: number[];
+                path?: undefined;
+            } | {
+                value?: undefined;
+                kind: string;
+                path: string;
+            })[];
+        };
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        pda?: undefined;
+        name: string;
+        address: string;
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        pda?: undefined;
+        name: string;
+        writable: boolean;
+        optional: boolean;
+    })[];
+    args: ({
+        name: string;
+        type: string;
+    } | {
+        name: string;
+        type: {
+            vec: string;
+        };
+    })[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+    } | {
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        accounts?: undefined;
+        name: string;
+        optional: boolean;
+        address: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        optional: boolean;
+    })[];
+    args: ({
+        name: string;
+        type: {
+            vec: {
+                defined: {
+                    name: string;
+                };
+                vec?: undefined;
+            };
+            array?: undefined;
+        };
+    } | {
+        name: string;
+        type: string;
+    } | {
+        name: string;
+        type: {
+            array: (string | number)[];
+            vec?: undefined;
+        };
+    } | {
+        name: string;
+        type: {
+            array?: undefined;
+            vec: {
+                defined?: undefined;
+                vec: {
+                    array: (string | number)[];
+                };
+            };
+        };
+    })[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        writable?: undefined;
+        pda?: undefined;
+        name: string;
+    } | {
+        writable?: undefined;
+        name: string;
+        pda: {
+            seeds: ({
+                path?: undefined;
+                kind: string;
+                value: number[];
+            } | {
+                value?: undefined;
+                kind: string;
+                path: string;
+            })[];
+        };
+    } | {
+        pda?: undefined;
+        name: string;
+        writable: boolean;
+    })[];
+    args: {
+        name: string;
+        type: string;
+    }[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        optional: boolean;
+    })[];
+    args: ({
+        name: string;
+        type: {
+            array?: undefined;
+            defined: {
+                name: string;
+            };
+        };
+    } | {
+        name: string;
+        type: {
+            defined?: undefined;
+            array: (string | number)[];
+        };
+    })[];
+} | {
+    docs?: undefined;
+    name: string;
+    discriminator: number[];
+    accounts: ({
+        address?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        pda?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        name: string;
+        writable: boolean;
+        pda: {
+            seeds: ({
+                path?: undefined;
+                kind: string;
+                value: number[];
+            } | {
+                value?: undefined;
+                kind: string;
+                path: string;
+            })[];
+        };
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        pda?: undefined;
+        name: string;
+        address: string;
+    })[];
+    args: ({
+        name: string;
+        type: string;
+    } | {
+        name: string;
+        type: {
+            vec: string;
+        };
+    })[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        pda: {
+            seeds: ({
+                path?: undefined;
+                kind: string;
+                value: number[];
+            } | {
+                value?: undefined;
+                kind: string;
+                path: string;
+            })[];
+        };
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        address: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        pda?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        writable: boolean;
+        optional: boolean;
+    })[];
+    args: ({
+        name: string;
+        type: {
+            array?: undefined;
+            option: string;
+        };
+    } | {
+        name: string;
+        type: string;
+    } | {
+        name: string;
+        type: {
+            option?: undefined;
+            array: (string | number)[];
+        };
+    })[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        optional?: undefined;
+        name: string;
+        docs: string[];
+        address: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        name: string;
+        address: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        docs: string[];
+    })[];
+    args: {
+        name: string;
+        type: string;
+    }[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        accounts: ({
+            address?: undefined;
+            optional?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            address?: undefined;
+            name: string;
+            docs: string[];
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            optional: boolean;
+        } | {
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            writable: boolean;
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            optional: boolean;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        address: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        optional: boolean;
+    })[];
+    args: ({
+        name: string;
+        type: {
+            array: (string | number)[];
+        };
+    } | {
+        name: string;
+        type: string;
+    })[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        docs?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+            name: string;
+        } | {
+            docs?: undefined;
+            address?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+            name: string;
+            writable: boolean;
+        } | {
+            docs?: undefined;
+            address?: undefined;
+            optional?: undefined;
+            name: string;
+            writable: boolean;
+            pda: {
+                seeds: ({
+                    path?: undefined;
+                    kind: string;
+                    value: number[];
+                } | {
+                    value?: undefined;
+                    kind: string;
+                    path: string;
+                })[];
+            };
+        } | {
+            writable?: undefined;
+            address?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+            name: string;
+            docs: string[];
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+            name: string;
+            address: string;
+        } | {
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            writable: boolean;
+            optional: boolean;
+            pda: {
+                seeds: ({
+                    path?: undefined;
+                    kind: string;
+                    value: number[];
+                } | {
+                    value?: undefined;
+                    kind: string;
+                    path: string;
+                })[];
+            };
+        })[];
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        accounts?: undefined;
+        name: string;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        optional: boolean;
+    })[];
+    args: {
+        name: string;
+        type: string;
+    }[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        pda: {
+            seeds: ({
+                path?: undefined;
+                kind: string;
+                value: number[];
+                account?: undefined;
+            } | {
+                value?: undefined;
+                kind: string;
+                path: string;
+                account: string;
+            } | {
+                value?: undefined;
+                account?: undefined;
+                kind: string;
+                path: string;
+            })[];
+        };
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        pda?: undefined;
+        name: string;
+        accounts: ({
+            address?: undefined;
+            optional?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            address?: undefined;
+            name: string;
+            docs: string[];
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            optional: boolean;
+        } | {
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            writable: boolean;
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            optional: boolean;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        pda?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        address: string;
+    })[];
+    args: ({
+        name: string;
+        type: string;
+    } | {
+        name: string;
+        type: {
+            array: (string | number)[];
+        };
+    })[];
+} | {
+    docs?: undefined;
+    name: string;
+    discriminator: number[];
+    accounts: ({
+        address?: undefined;
+        pda?: undefined;
+        name: string;
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        name: string;
+        writable: boolean;
+        pda: {
+            seeds: {
+                kind: string;
+                value: number[];
+            }[];
+        };
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        pda?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        pda?: undefined;
+        name: string;
+        address: string;
+    })[];
+    args: {
+        name: string;
+        type: {
+            defined: {
+                name: string;
+            };
+        };
+    }[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        address: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        optional: boolean;
+    })[];
+    args: ({
+        name: string;
+        type: {
+            array?: undefined;
+            defined: {
+                name: string;
+            };
+        };
+    } | {
+        name: string;
+        type: {
+            defined?: undefined;
+            array: (string | number)[];
+        };
+    })[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        pda: {
+            seeds: ({
+                path?: undefined;
+                kind: string;
+                value: number[];
+            } | {
+                value?: undefined;
+                kind: string;
+                path: string;
+            })[];
+        };
+    } | {
+        signer?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        pda?: undefined;
+        name: string;
+        accounts: ({
+            address?: undefined;
+            optional?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            address?: undefined;
+            name: string;
+            docs: string[];
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            optional: boolean;
+        } | {
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            writable: boolean;
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            optional: boolean;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        pda?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        optional: boolean;
+    })[];
+    args: ({
+        name: string;
+        type: string;
+    } | {
+        name: string;
+        type: {
+            defined: {
+                name: string;
+            };
+        };
+    })[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+    } | {
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        accounts: ({
+            docs?: undefined;
+            address?: undefined;
+            pda?: undefined;
+            name: string;
+            writable: boolean;
+            signer: boolean;
+        } | {
+            signer?: undefined;
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            pda?: undefined;
+            name: string;
+        } | {
+            signer?: undefined;
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+            pda: {
+                seeds: ({
+                    path?: undefined;
+                    kind: string;
+                    value: number[];
+                } | {
+                    value?: undefined;
+                    kind: string;
+                    path: string;
+                })[];
+            };
+        } | {
+            signer?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            pda?: undefined;
+            name: string;
+            writable: boolean;
+        } | {
+            signer?: undefined;
+            address?: undefined;
+            pda?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            signer?: undefined;
+            writable?: undefined;
+            docs?: undefined;
+            pda?: undefined;
+            name: string;
+            address: string;
+        } | {
+            signer?: undefined;
+            writable?: undefined;
+            address?: undefined;
+            pda?: undefined;
+            name: string;
+            docs: string[];
+        })[];
+    } | {
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        accounts: ({
+            address?: undefined;
+            optional?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            address?: undefined;
+            name: string;
+            docs: string[];
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            optional: boolean;
+        } | {
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            writable: boolean;
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            optional: boolean;
+            address: string;
+        })[];
+    } | {
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+    } | {
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+    } | {
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        address: string;
+    } | {
+        writable?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        optional: boolean;
+    } | {
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        optional: boolean;
+    })[];
+    args: ({
+        name: string;
+        type: string;
+    } | {
+        name: string;
+        type: {
+            option: string;
+        };
+    })[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        pda: {
+            seeds: ({
+                path?: undefined;
+                kind: string;
+                value: number[];
+            } | {
+                value?: undefined;
+                kind: string;
+                path: string;
+            })[];
+        };
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        address: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        pda?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        writable: boolean;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+        optional: boolean;
+    })[];
+    args: ({
+        name: string;
+        type: string;
+    } | {
+        name: string;
+        type: {
+            defined: {
+                name: string;
+            };
+        };
+    })[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        pda: {
+            seeds: ({
+                path?: undefined;
+                kind: string;
+                value: number[];
+            } | {
+                value?: undefined;
+                kind: string;
+                path: string;
+            })[];
+        };
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        address: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        pda?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        optional: boolean;
+        pda: {
+            seeds: ({
+                path?: undefined;
+                kind: string;
+                value: number[];
+            } | {
+                value?: undefined;
+                kind: string;
+                path: string;
+            })[];
+        };
+    })[];
+    args: ({
+        name: string;
+        type: string;
+    } | {
+        name: string;
+        type: {
+            defined: {
+                name: string;
+            };
+        };
+    })[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        pda: {
+            seeds: ({
+                path?: undefined;
+                account?: undefined;
+                kind: string;
+                value: number[];
+            } | {
+                value?: undefined;
+                account?: undefined;
+                kind: string;
+                path: string;
+            } | {
+                value?: undefined;
+                kind: string;
+                path: string;
+                account: string;
+            })[];
+        };
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        pda?: undefined;
+        name: string;
+        accounts: ({
+            address?: undefined;
+            optional?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            address?: undefined;
+            name: string;
+            docs: string[];
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            optional: boolean;
+        } | {
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            writable: boolean;
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            optional: boolean;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        pda?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    })[];
+    args: ({
+        name: string;
+        type: {
+            vec?: undefined;
+            defined: {
+                name: string;
+            };
+        };
+    } | {
+        name: string;
+        type: {
+            defined?: undefined;
+            vec: {
+                defined: {
+                    name: string;
+                };
+            };
+        };
+    })[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        pda: {
+            seeds: ({
+                path?: undefined;
+                kind: string;
+                value: number[];
+            } | {
+                value?: undefined;
+                kind: string;
+                path: string;
+            })[];
+        };
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        address: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        pda?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    })[];
+    args: ({
+        name: string;
+        type: string;
+    } | {
+        name: string;
+        type: {
+            defined: {
+                name: string;
+            };
+        };
+    })[];
+} | {
+    docs?: undefined;
+    name: string;
+    discriminator: number[];
+    accounts: ({
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        pda: {
+            seeds: ({
+                path?: undefined;
+                kind: string;
+                value: number[];
+            } | {
+                value?: undefined;
+                kind: string;
+                path: string;
+            })[];
+        };
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        address: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        pda?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    })[];
+    args: {
+        name: string;
+        type: string;
+    }[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        accounts?: undefined;
+        name: string;
+        address: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    })[];
+    args: ({
+        name: string;
+        type: string;
+    } | {
+        name: string;
+        type: {
+            array?: undefined;
+            vec: {
+                defined: {
+                    name: string;
+                };
+            };
+        };
+    } | {
+        name: string;
+        type: {
+            vec?: undefined;
+            array: (string | number)[];
+        };
+    })[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        address?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        name: string;
+        docs: string[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        name: string;
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        name: string;
+        address: string;
+    })[];
+    args: ({
+        name: string;
+        type: {
+            vec: {
+                array?: undefined;
+                defined: {
+                    name: string;
+                };
+            };
+        };
+    } | {
+        name: string;
+        type: {
+            vec: {
+                defined?: undefined;
+                array: (string | number)[];
+            };
+        };
+    })[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        name: string;
+        writable: boolean;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        name: string;
+        address: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        docs: string[];
+    })[];
+    args: ({
+        name: string;
+        type: string;
+    } | {
+        name: string;
+        type: {
+            defined: {
+                name: string;
+            };
+        };
+    })[];
+} | {
+    docs?: undefined;
+    name: string;
+    discriminator: number[];
+    accounts: ({
+        writable?: undefined;
+        docs?: undefined;
+        name: string;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        name: string;
+        writable: boolean;
+    } | {
+        writable?: undefined;
+        name: string;
+        docs: string[];
+        signer: boolean;
+    })[];
+    args: {
+        name: string;
+        type: {
+            defined: {
+                name: string;
+            };
+        };
+    }[];
+} | {
+    docs?: undefined;
+    name: string;
+    discriminator: number[];
+    accounts: ({
+        writable?: undefined;
+        name: string;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        name: string;
+        writable: boolean;
+    })[];
+    args: {
+        name: string;
+        type: string;
+    }[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+            name: string;
+        } | {
+            docs?: undefined;
+            address?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+            name: string;
+            writable: boolean;
+        } | {
+            docs?: undefined;
+            address?: undefined;
+            optional?: undefined;
+            name: string;
+            writable: boolean;
+            pda: {
+                seeds: ({
+                    path?: undefined;
+                    kind: string;
+                    value: number[];
+                } | {
+                    value?: undefined;
+                    kind: string;
+                    path: string;
+                })[];
+            };
+        } | {
+            writable?: undefined;
+            address?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+            name: string;
+            docs: string[];
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+            name: string;
+            address: string;
+        } | {
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            writable: boolean;
+            optional: boolean;
+            pda: {
+                seeds: ({
+                    path?: undefined;
+                    kind: string;
+                    value: number[];
+                } | {
+                    value?: undefined;
+                    kind: string;
+                    path: string;
+                })[];
+            };
+        })[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        accounts: ({
+            address?: undefined;
+            optional?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            address?: undefined;
+            name: string;
+            docs: string[];
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            optional: boolean;
+        } | {
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            writable: boolean;
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            optional: boolean;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        optional?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        optional: boolean;
+        address: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        optional: boolean;
+    })[];
+    args: {
+        name: string;
+        type: string;
+    }[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        docs?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        pda?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+            name: string;
+        } | {
+            docs?: undefined;
+            address?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+            name: string;
+            writable: boolean;
+        } | {
+            docs?: undefined;
+            address?: undefined;
+            optional?: undefined;
+            name: string;
+            writable: boolean;
+            pda: {
+                seeds: ({
+                    path?: undefined;
+                    kind: string;
+                    value: number[];
+                } | {
+                    value?: undefined;
+                    kind: string;
+                    path: string;
+                })[];
+            };
+        } | {
+            writable?: undefined;
+            address?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+            name: string;
+            docs: string[];
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            optional?: undefined;
+            pda?: undefined;
+            name: string;
+            address: string;
+        } | {
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            writable: boolean;
+            optional: boolean;
+            pda: {
+                seeds: ({
+                    path?: undefined;
+                    kind: string;
+                    value: number[];
+                } | {
+                    value?: undefined;
+                    kind: string;
+                    path: string;
+                })[];
+            };
+        })[];
+    } | {
+        signer?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        pda: {
+            seeds: ({
+                path?: undefined;
+                account?: undefined;
+                kind: string;
+                value: number[];
+            } | {
+                value?: undefined;
+                kind: string;
+                path: string;
+                account: string;
+            } | {
+                value?: undefined;
+                account?: undefined;
+                kind: string;
+                path: string;
+            })[];
+        };
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        writable: boolean;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        pda?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        optional: boolean;
+    })[];
+    args: {
+        name: string;
+        type: string;
+    }[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        name: string;
+        accounts: ({
+            address?: undefined;
+            optional?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            address?: undefined;
+            name: string;
+            docs: string[];
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            optional: boolean;
+        } | {
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            writable: boolean;
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            optional: boolean;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        optional: boolean;
+    })[];
+    args: ({
+        name: string;
+        type: {
+            vec?: undefined;
+            defined: {
+                name: string;
+            };
+        };
+    } | {
+        name: string;
+        type: string;
+    } | {
+        name: string;
+        type: {
+            defined?: undefined;
+            vec: string;
+        };
+    })[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+        pda: {
+            seeds: ({
+                path?: undefined;
+                account?: undefined;
+                kind: string;
+                value: number[];
+            } | {
+                value?: undefined;
+                account?: undefined;
+                kind: string;
+                path: string;
+            } | {
+                value?: undefined;
+                kind: string;
+                path: string;
+                account: string;
+            })[];
+        };
+    } | {
+        signer?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        pda?: undefined;
+        name: string;
+        accounts: ({
+            address?: undefined;
+            optional?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            address?: undefined;
+            name: string;
+            docs: string[];
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            optional: boolean;
+        } | {
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+            writable: boolean;
+            optional: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            optional: boolean;
+            address: string;
+        })[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        address: string;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        address?: undefined;
+        accounts?: undefined;
+        pda?: undefined;
+        name: string;
+        docs: string[];
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        address?: undefined;
+        pda?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    })[];
+    args: ({
+        name: string;
+        type: {
+            array: (string | number)[];
+        };
+    } | {
+        name: string;
+        type: string;
+    })[];
+} | {
+    docs?: undefined;
+    name: string;
+    discriminator: number[];
+    accounts: ({
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+    } | {
+        writable?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        signer: boolean;
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        optional: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        optional?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    })[];
+    args: {
+        name: string;
+        type: {
+            defined: {
+                name: string;
+            };
+        };
+    }[];
+} | {
+    name: string;
+    docs: string[];
+    discriminator: number[];
+    accounts: ({
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+        signer: boolean;
+    } | {
+        signer?: undefined;
+        docs?: undefined;
+        accounts?: undefined;
+        name: string;
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        accounts?: undefined;
+        name: string;
+        docs: string[];
+        writable: boolean;
+    } | {
+        signer?: undefined;
+        writable?: undefined;
+        docs?: undefined;
+        name: string;
+        accounts: ({
+            writable?: undefined;
+            docs?: undefined;
+            address?: undefined;
+            name: string;
+        } | {
+            address?: undefined;
+            name: string;
+            docs: string[];
+            writable: boolean;
+        } | {
+            writable?: undefined;
+            docs?: undefined;
+            name: string;
+            address: string;
+        })[];
+    })[];
+    args: {
+        name: string;
+        type: {
+            option: {
+                defined: {
+                    name: string;
+                };
+            };
+        };
+    }[];
+} | null;
+/**
+ * An instruction's tail (`tokens::tail`): the accounts every NFT move hands Core (what a check its collection carries
+ * reads, an oracle's account) and every token transfer hands a transfer hook, after the route's own. It starts at the
+ * Memo program's account, which serves a transfer into an account that requires a memo; with none, it is empty. So
+ * `extra` (hook accounts, Core's adapters) goes after the Memo program, which this puts first.
+ */
+export declare function tailOf(extra?: any[]): any[];
 /**
  * Any loot instruction. `accounts` names accounts by their IDL leaf name; `null` for an optional one passes "None".
  * Options: `remaining` (metas after the instruction's own), `writable` and `signer` (leaf names whose flag is set
@@ -34,6 +3327,14 @@ export declare function destinationAccounts(project: any, to: any, mint: any, {
     isWritable: any;
 }[];
 /** A split's destinations, in order. */
+/** The most shares a split kept to be paid later holds (`MAX_SHARES`, not in the IDL): a box's, a lottery's, a contest's,
+ * an auction's, an offer's or a listing's (a ninth is `BadShares`); a payment's own split has no such cap. */
+export declare const MAX_SHARES = 8;
+/** The most traits a fresh item draws (`MAX_ITEM_TRAITS`, not in the IDL): each is written as its unit is minted, which
+ * one transaction must hold. */
+export declare const MAX_ITEM_TRAITS = 64;
+/** The longest name a fresh item's trait has, in bytes (`MAX_TRAIT_KEY`, not in the IDL). */
+export declare const MAX_TRAIT_KEY = 64;
 export declare const shareAccounts: (project: any, shares: any, mint: any, options: any) => any;
 /**
  * A split with the buyer's choice written in, as the program does at `open_box` and `buy_tickets`: a wallet, the
@@ -46,9 +3347,11 @@ export declare const sharesBurn: (shares: any) => any;
 /**
  * The account each prize of a box's entries comes with at the roll, in entry order and each entry's prizes in order:
  * its item for an item, its pool for tokens from one, its stash for an NFT of one (a named one, or one at random). All
- * written: the roll takes from them. Tokens minted and rolls take none here.
+ * written: the roll takes from them. Tokens minted and rolls take none here. A fresh item's tables follow it while
+ * they fit the box's table budget (`tableBudget`), walked in entry order; an item whose tables don't fit what is left
+ * takes none, and is out of stock for that roll.
  */
-export declare function entryAccounts(project: any, entries: any): any;
+export declare function entryAccounts(project: any, entries: any, items?: {}): any;
 /**
  * For each mint a box's tokens are in, in the order their prizes first name them, the mint (written when the roll
  * mints from it) and the project's vault for it, where tokens won wait. `poolMints` maps a pool index to its mint (a
@@ -61,12 +3364,29 @@ export declare function prizeAccounts(project: any, entries: any, poolMints: {}
 }[];
 /** Whether a box leaves its outcome to the oracle: more than one entry, or an entry gives a stash's NFT at random. */
 export declare const boxRolls: (entries: any) => any;
-/** What an order of `box` holds for the collectibles its roll may mint: a collectible's rent for each item the entry
- * with the most of them gives. */
-export declare const orderEscrow: (box: any) => bigint;
+/** The tables a fresh item's traits draw from, in the order of its traits (none for an item whose units are alike). */
+export declare const traitTables: (item: any) => any;
+/** Whether a box gives a fresh item (one with traits): its units' traits are drawn by the oracle (`items` maps an
+ * item's id to its decoded Item, as `entryAccounts`). */
+export declare const boxFresh: (entries: any, items?: {}) => any;
+/**
+ * What one prize a settle hands over may open or mint, at most: a collectible's Core asset with the program's plugins
+ * (about 0.004 SOL), a stash's NFT's new token account, a fresh compressed NFT's Sheet, a token account of a mint, the
+ * NFT rolled on's numbers or its stash row. A client's own figure (the program keeps no reserve): what a throwaway key
+ * that settles is funded with for each, and gives back unspent.
+ */
+export declare const SETTLE_RENT_UNIT = 6000000n;
+/**
+ * What a settle of an order of `opens` opens of `box` may open or mint, at most, in lamports: whoever settles pays it
+ * (the order lends nothing). For each draw of each open, each prize of the entry with the most of them that opens an
+ * account (a collectible, a stash's NFT, a fresh compressed NFT's Sheet: `items` maps an item's id to its decoded
+ * Item); once an order, each source of tokens it may pay, and the fate of the NFT it rolls on; one `SETTLE_RENT_UNIT`
+ * each. A throwaway key that settles is funded with it, and gives back what it doesn't spend.
+ */
+export declare function settleRent(box: any, opens?: number, items?: {}): bigint;
 /**
  * The nonce the `k`th roll an order won is named by when it settles: the first 8 bytes, little
- * endian, of sha256("roll" | order | its requested slot (u64 LE) | k (u8)). Like every prize's roll, its order is at
+ * endian, of sha256("roll" | order | its requested slot (u64 LE) | k (u32 LE)). Like every prize's roll, its order is at
  * `prizeRollNonce` of it.
  */
 export declare function rollNonce(order: any, requestedSlot: any, k: any): bigint;
@@ -80,6 +3400,12 @@ export declare const nonceOn: (asset: any) => bigint;
 /** Whether a box's roll holds the NFT it rolls on, or moves its numbers: an entry burns it, gives it
  * away or moves its numbers. Its order is at the NFT's nonce (`nonceOn`). */
 export declare const boxHolds: (box: any) => any;
+/**
+ * The nonce of the order a roll a sender names is made in: a craft's roll on a collectible kept (`RollOn`) and a
+ * mission's roll on the NFT leaving it. On an NFT its box holds (`boxHolds`), the NFT's own (`nonceOn`), whatever was
+ * named; otherwise `prizeRollNonce` of the named one, so no sender reaches the address of a roll an order won.
+ */
+export declare const namedRollNonce: (box: any, asset: any, named: any) => bigint;
 /**
  * The accounts of an NFT the player shows, for a gate or for odds: right after the instruction's other accounts.
  * `shown` is a Core asset the project has authority over (its address), one it has no authority over (`{ asset }`: then
@@ -99,8 +3425,8 @@ export declare function shownAccounts(project: any, shown: any): {
  */
 export declare const gateAccounts: (project: any, { gate, wallet, shown, listProof }?: Readonly<Record<string, any>>) => any[];
 /**
- * A nonce a prize route names (its `nonce` argument), from what names the prize: a grant and its round, a lottery's
- * contribution, a contest's entry, an auction and its last bid. Any nonce works (the sender picks it); the roll's order
+ * A nonce a prize route names (its `nonce` argument), from what names the prize: a grant, its wallet and rounds, a
+ * contest and its player, an auction and its last bid. Any nonce works (the sender picks it); the roll's order
  * is then at `prizeRollNonce` of it (plus the place where the route says so), which no roll on an NFT is at.
  */
 export declare const prizeNonce: (...parts: any[]) => bigint;
@@ -118,18 +3444,15 @@ export declare const prizeRollNonce: (n: any) => bigint;
  *   Tokens  the mint (written when minted), the pool when they come from one, the winner's account of the mint;
  *   Item    the item; for a collectible, its collection (the Item's), its address at the item's next serial, Metaplex Core;
  *   Nft     the stash, the NFT as `piece` takes it, then a compressed NFT's proof;
- *   Roll    the box, then the order its roll is made in, at `prizeRollNonce(nonce)`; on a route the player pays or
- *           asks for (`strict`: a buy, a craft, a grant's claim), then the box's prize mints (`rollMints`);
+ *   Roll    the box, then the order its roll is made in, at `prizeRollNonce(nonce)` (what the roll can give is read
+ *           when it is asked: `askRollIx`);
  *   Held    the lottery's own stash (`lottery`: the lottery's address), the NFT as `piece` takes it, then its proof.
  * `poolMints` maps a pool's index to its mint (null for a pool never opened, which gives nothing: `projectMint` stands in
  * for its mint); `items` an item's id to its decoded Item (for its next serial; `made`
  * collectibles of the same item already made earlier in the instruction); `nft` the NFT's kind, as `piece` takes it
- * ({ collection, tokenMetadata, compressed }). A strict roll's `boxes` maps the box's id to its decoded LootBox (null
- * for one never written), and `rollPools` each pool its prizes name to its mint (null for one never opened;
- * `poolMints` when not given).
+ * ({ collection, tokenMetadata, compressed }).
  */
-export declare function prizeMetas({ project, collection, prize, winner, nonce, poolMints, items, nft, made, projectMint, programs, lottery, strict, boxes, rollPools }: {
-    boxes?: {} | undefined;
+export declare function prizeMetas({ project, collection, prize, winner, nonce, poolMints, items, nft, made, projectMint, programs, lottery, }: {
     collection: any;
     items?: {} | undefined;
     lottery: any;
@@ -141,19 +3464,28 @@ export declare function prizeMetas({ project, collection, prize, winner, nonce,
     programs: any;
     project: any;
     projectMint: any;
-    rollPools?: any;
-    strict?: boolean | undefined;
     winner: any;
 }): any[];
 /**
- * The accounts the program reads after a roll's box and order, to check the roll can be asked for, on a route the
- * player pays or asks for (a craft's `Prize::Roll` or `RollOn`, a buy's roll, a grant's claim of one): for each of the
- * box's token prizes, in order, its pool and then, for a pool opened, the pool's mint; for tokens minted, their mint. The program refuses the whole
- * transaction (PrizeHasHook) when any of those mints has a transfer hook, so the player keeps what the route takes.
- * `box` is the decoded LootBox (null for one never written: no roll is made, and nothing follows); `pools` maps each
- * pool its prizes name to its mint, or null for a pool never opened (its address alone).
+ * The roll accounts of a box, as `open_box`, `ask_roll` and the oracle's answer take them after their own: each entry's
+ * prizes' (`entryAccounts`: an item, its tables when it is fresh and they fit the box's table budget; a pool; a stash),
+ * then each mint its tokens are in and the project's vault for it (`prizeAccounts`). `box` is the decoded LootBox (null
+ * for one never written: none). `rolls`: { items (an item's id to its decoded Item, null for none written), poolMints
+ * (a pool's index to its mint, null for one never opened), programs }.
+ */
+export declare function rollAccounts(project: any, box: any, rolls?: {}): any[];
+/**
+ * What a write or a route that names boxes to roll later passes for them (`order::rollables`): each box once, in the
+ * order they first come, and nothing after it. What a roll can give is read when it is asked.
  */
-export declare function rollMints(project: any, box: any, pools?: {}): any;
+export declare function boxesAccounts(project: any, ids: any): {
+    pubkey: any;
+    isSigner: any;
+    isWritable: any;
+}[];
+/** The boxes a record names to roll later (`Def::rolls`), in order: a box's entries' rolls, a recipe's rolls and
+ * `RollOn`s, a grant's, a lottery's places'. */
+export declare function defRolls(def: any): any;
 /** Bubblegum's signer for its calls to Core, `["mpl_core_cpi_signer"]`. */
 export declare const BUBBLEGUM_CORE_SIGNER = "CbNY3JiXdXNE9tPNEk1aRZVEkWdj2v7kfJLNQwZZgpXk";
 /**
@@ -242,7 +3574,7 @@ export declare const createProjectIx: ({ owner, id, authority, treasury, collect
  * authority or treasury comes with the account at its key (`new_authority`, `new_treasury`), which the program checks
  * as `createProjectIx`'s.
  */
-export declare const updateProjectIx: ({ owner, project, authority, paused, treasury, collections, newOwner }: {
+export declare const updateProjectIx: ({ owner, project, authority, paused, treasury, collections, newOwner, }: {
     authority?: null | undefined;
     collections?: null | undefined;
     newOwner?: null | undefined;
@@ -271,16 +3603,24 @@ export declare function recordAddress(project: any, def: any): any;
  * `def` with optional fields filled in (no window, no limit for each wallet, no key root, a fall on its own clock).
  */
 export declare function withDefaults(def: any): {
+    Lottery: any;
+} | {
     [x: string]: any;
+    Lottery?: undefined;
 };
 /**
  * The owner writes one record (`def`: { Item: { id, args } }, { Box: … }, …), at its own address. A lottery names
- * its pot's mint, its pot (which its first write opens), its ticket mint, its
- * funds and both token programs.
+ * its mint, the pot its terms pay from (which a write opens when it isn't open; pot 0's address for a lottery whose
+ * rounds pay from their own money, where any account will do), its ticket mint, both token programs and the round it waits on
+ * (`lotteryState`: the lottery as it is, null for a new one; `idleRound`: its current round's record, or round 0's once
+ * it drew once and ended: a lottery made again, edited once ended or made to repeat waits while that round runs or
+ * still owes NFTs of its own stash), then its own stash when a place holds or draws an NFT of it. A box, a recipe, a grant or a lottery that
+ * names a box to roll later passes that box after (`boxesAccounts`), which must be written: a box is written before
+ * anything names it (it may name itself).
  */
-export declare function upsertIx({ owner, project, def: given, lottery }: {
+export declare function upsertIx({ owner, project, def: given, lotteryState }: {
     def: any;
-    lottery?: null | undefined;
+    lotteryState?: null | undefined;
     owner: any;
     project: any;
 }): {
@@ -290,14 +3630,15 @@ export declare function upsertIx({ owner, project, def: given, lottery }: {
 };
 /**
  * The owner closes the record at `target`, and its rent comes back: a grant's with the funds it held. A lottery
- * (`lottery`: its decoded record) sends what its pot holds to `to`, a token account of the pot's mint (the owner's own
- * by default), and closes the pot.
+ * (`lottery`: its decoded record) sends what every pot it opened holds (`Lottery::pots`) to `to`, a token account of its
+ * mint (the owner's own by default), and closes each, once its current round has no record (one that drew once and
+ * ended: once its round 0 gave out every NFT of its own stash, `idleRound`), and once the round its `owing` names has
+ * moved in what it owes its pot (pull it first, `Part::Common`). One that never opened a pot names only those rounds.
  */
-export declare function closeRecordIx({ owner, project, target, lottery, schedule, programs, to, paymentTo, extra }: {
+export declare function closeRecordIx({ owner, project, target, lottery, schedule, programs, to, extra }: {
     extra?: never[] | undefined;
     lottery: any;
     owner: any;
-    paymentTo: any;
     programs: any;
     project: any;
     schedule: any;
@@ -312,7 +3653,7 @@ export declare function closeRecordIx({ owner, project, target, lottery, schedul
  * `player` (or a sponsor, or the project's own keys funding a pool) pays `amount` of `mint`, split at once by `shares`.
  * The rest goes to the project's `treasury` wallet. The player opens any account this pays into that is not there.
  */
-export declare function payIx({ player, project, mint, treasury, amount, shares, reference: ref, playerToken, holders, programs, extra }: {
+export declare function payIx({ player, project, mint, treasury, amount, shares, reference: ref, playerToken, holders, programs, extra, }: {
     amount: any;
     extra?: never[] | undefined;
     holders: any;
@@ -335,17 +3676,19 @@ export declare function payIx({ player, project, mint, treasury, amount, shares,
  * prizes take tokens from to its mint (a pool's tokens won wait in the project's vault for that mint); one not given
  * is taken to be in the box's currency, one given as null is closed. `shown`: an NFT the player shows for the box's
  * gate or odds; `listProof`: for a list gate, the proof's nodes. `chosenRecipient`: the wallet (or, for a share with an
- * item, the collectible, `chosen`) the buyer names for a share the box lets them choose. A box of one entry with
- * nothing random is rolled at once and takes no oracle accounts (a box that needs no roll at all sells with `buyIx`).
+ * item, the collectible, `chosen`) the buyer names for a share the box lets them choose. Every open asks the oracle,
+ * even of a box with nothing random (which sells in one step with `buyIx`, when it rolls on no NFT).
  * The player opens the project's vault for the price's mint, and for each prize's, when it is not there. A box that
- * limits each wallet counts the purchase in the player's receipt (its rent theirs).
+ * limits each wallet counts the purchase in the player's counts (`pda.counts`, its rent theirs).
  */
-export declare function openBoxIx({ player, project, box, boxAddress, nonce, maxPrice, shown, listProof, subject, chosenRecipient, chosen, poolMints, playerToken, programs, extra }: {
+export declare function openBoxIx({ player, project, box, boxAddress, nonce, maxPrice, count, items, shown, listProof, subject, chosenRecipient, chosen, settler, poolMints, playerToken, programs, extra, }: {
     box: any;
     boxAddress: any;
     chosen?: null | undefined;
     chosenRecipient?: null | undefined;
+    count?: number | undefined;
     extra?: never[] | undefined;
+    items?: {} | undefined;
     listProof: any;
     maxPrice: any;
     nonce: any;
@@ -354,6 +3697,7 @@ export declare function openBoxIx({ player, project, box, boxAddress, nonce, max
     poolMints: any;
     programs: any;
     project: any;
+    settler?: string | undefined;
     shown: any;
     subject: any;
 }): {
@@ -362,20 +3706,22 @@ export declare function openBoxIx({ player, project, box, boxAddress, nonce, max
     data: Uint8Array<any>;
 };
 /**
- * Buys a box that needs no roll (one entry, nothing random, no NFT to roll on: `boxRolls` false and no subject) in one
- * instruction: the price is split at once (or burned, for an entry that burns) and the entry's prizes are given to
- * the player (`prizeMetas`: `items` maps an item's id to its decoded Item, `poolMints` a pool's index to its mint,
- * `nfts` an NFT a prize names to its kind; a roll's `boxes` and `rollPools`, for the rolled box's prize mints). No
- * order. A prize that can't be given refuses the purchase. `treasury` is
- * the project's treasury wallet; `holders` maps a collectible a share pays to its holder; a roll the entry gives is
- * made at `nonce` (the next one for each roll after). `shown`/`listProof` pass the box's gate.
+ * Buys `count` of a box that needs no roll (one entry, nothing random, no NFT to roll on: `boxRolls` false and no
+ * subject) in one instruction, any number of draws each (a fixed pack): each at the price the one before it left, all
+ * within `maxPrice` (the price times `count` when not given: pass the sum for a box whose price rises with each sale).
+ * The price is split at once (a share may burn it) and the entry's prizes are given to the player: a fixed amount of
+ * tokens once, the whole of every draw's, and every other prize once for each draw of each sale, its accounts repeated
+ * (`prizeMetas`: `items` maps an item's id to its decoded Item, `poolMints` a pool's index to its mint, `nfts` an NFT a
+ * prize names to its kind). No order. A prize that can't be given refuses the purchase. `treasury` is the project's
+ * treasury wallet; `holders` maps a collectible a share pays to its holder; each roll the entry gives is made at the
+ * next nonce from `nonce` (`buyRolls`). `shown`/`listProof` pass the box's gate.
  */
-export declare function buyIx({ player, project, box, boxAddress, maxPrice, treasury, chosenRecipient, chosen, nonce, shown, listProof, items, poolMints, nfts, boxes, rollPools, holders, playerToken, programs, extra }: {
+export declare function buyIx({ player, project, box, boxAddress, maxPrice, count, treasury, chosenRecipient, chosen, nonce, shown, listProof, items, poolMints, nfts, holders, playerToken, programs, extra, }: {
     box: any;
     boxAddress: any;
-    boxes?: {} | undefined;
     chosen?: null | undefined;
     chosenRecipient?: null | undefined;
+    count?: number | undefined;
     extra?: never[] | undefined;
     holders: any;
     items?: {} | undefined;
@@ -388,7 +3734,6 @@ export declare function buyIx({ player, project, box, boxAddress, maxPrice, trea
     poolMints?: {} | undefined;
     programs: any;
     project: any;
-    rollPools?: any;
     shown: any;
     treasury: any;
 }): {
@@ -396,6 +3741,16 @@ export declare function buyIx({ player, project, box, boxAddress, maxPrice, trea
     keys: any[];
     data: Uint8Array<any>;
 };
+/**
+ * What a `buy` of `count` of `box` gives, in the order it gives it (`buy.rs`): each prize of its one entry in turn, a
+ * fixed amount of tokens once (`times` the box's draws × `count`), any other prize once for each of those draws. `k`
+ * counts the gives: a roll given at `k` is made at the buy's `nonce + k` (its order at `prizeRollNonce` of it).
+ */
+export declare function buyGives(box: any, count?: number): {
+    prize: any;
+    k: number;
+    times: number;
+}[];
 /**
  * The oracle's answer to a box order (for a local simulation: on chain MagicBlock's oracle sends it). The accounts
  * are the ones `open_box` handed the oracle: the order, the box, the roll's ticket (named by its first ask,
@@ -404,10 +3759,11 @@ export declare function buyIx({ player, project, box, boxAddress, maxPrice, trea
  * for a prize in a mint with a transfer hook, the hook's accounts (`extra`). The buyer's odds boosts were fixed at
  * purchase.
  */
-export declare function callbackRollIx({ order, orderState, box, boxAddress, randomness, project, poolMints, programs, extra }: {
+export declare function callbackRollIx({ order, orderState, box, boxAddress, randomness, project, poolMints, items, programs, extra, }: {
     box: any;
     boxAddress: any;
     extra?: never[] | undefined;
+    items?: {} | undefined;
     order: any;
     orderState: any;
     poolMints: any;
@@ -421,20 +3777,40 @@ export declare function callbackRollIx({ order, orderState, box, boxAddress, ran
 };
 /**
  * The accounts of what an order won (`order.won`), in order, as `settle` hands each over:
- *   Item    the item; for a collectible (`items[id]` its decoded Item), its collection, its address, Metaplex Core
+ *   Item    the item; for a collectible (`items[id]` its decoded Item), its collection, its address, Metaplex Core;
+ *           for a fresh one (`drawn` set), then the table of each of its table traits
  *   Tokens  the mint, the project's vault for it, the player's account of it (`prizeTo`, when given)
  *   Nft     the NFT as `piece` takes it (`nfts[nft]` its kind), going to the player, then a compressed NFT's proof
- *   Roll    the box, then the order its roll is made in (`rollNonce`)
+ *   Compressed  the item, the tree's config, the tree, the collection, Bubblegum's programs; for a fresh one, then its
+ *           tables and the Sheet of the NFT it mints
  */
-export declare function wonAccounts({ orderAddress, order, items, nfts, prizeTo, putBack, programs }: {
+export declare function wonAccounts({ order, items, nfts, prizeTo, putBack, programs, from, upto, tree, treeMinted, unminted, }: {
+    from?: number | undefined;
     items?: {} | undefined;
     nfts?: {} | undefined;
     order: any;
-    orderAddress: any;
     prizeTo: any;
     programs: any;
     putBack?: never[] | undefined;
+    tree: any;
+    treeMinted?: bigint | undefined;
+    unminted?: never[] | undefined;
+    upto?: any;
 }): any;
+/** The calls a transaction may make, its own instructions and every call inside them (Solana's instruction trace). */
+export declare const TRACE_LIMIT = 64;
+/** The calls one prize makes when a settle hands it over, measured on the program (`tests/limits.rs`): a collectible's
+ * mint by Core (4, so 14 a transaction), a compressed one's by Bubblegum (5) and with its Sheet (7), tokens (2), an NFT
+ * moved (3). `items` maps an item's id to its decoded Item (a normal item makes none). */
+export declare function prizeCalls(won: any, items?: {}): 0 | 2 | 3 | 4 | 5 | 7;
+/** Where a settle part that starts at `from` ends: as many of the order's prizes as fit the instruction trace (an
+ * NFT's move asks for the bigger heap, so at most three a part). Each part is its own transaction; anyone sends any. */
+export declare function settlePartEnd(order: any, from?: number, items?: {}): number;
+/** How many draws one open of `box` makes: its slots' counts, or one. */
+export declare const boxDraws: (box: any) => any;
+/** How many settle parts an order of `opens` opens of `box` takes at most: each card, at its most calls, and with
+ * shares one more (the first call splits the payment, alone when no prize fits beside its shares: `upto` 0). */
+export declare function settleParts(box: any, opens?: number): number;
 /** The heap a settle that moves three or more NFTs asks for (`settleHeapFrame`): all a transaction may have, 256 KiB. */
 export declare const LARGE_SETTLE_HEAP: number;
 /**
@@ -458,18 +3834,26 @@ export declare const MAX_COMPUTE_UNITS = 1400000;
  * them). A limit costs nothing more when no priority fee is set.
  */
 export declare function settleComputeUnits(order: any): 800000 | 1400000;
+/** `settle`'s `upto` for its last part: past the end of any order. The last part gives what is left, pays back the share
+ * of the draws the roll didn't make, carries out the roll on an NFT and closes the order. */
+export declare const SETTLE_LAST = 4294967295;
 /**
  * Carries out a rolled order: hands over what its roll set aside (`wonAccounts`: a collectible minted, the project's
- * backend delivering a normal item from the receipt; tokens from the project's vault; an NFT taken out of its stash;
- * a roll made for the player), then splits the payment, or burns it for an entry that burns. Anyone sends it, for the
- * order at `orderAddress`; `signer` opens any account it pays into that is not there, and pays a roll's order. `order`
- * is the decoded Order; `projectState` the decoded Project; `items` and `nfts` as `wonAccounts` takes them. `putBack`:
- * NFTs won that the player, signing, puts back into their stash in place of taking them (one its collection won't let move).
- * `handBack`: the wallet the box's fate gives the NFT rolled on to (`receiverOf`) is an account of the loot program
- * (`handsBack` of it as read), so the program gives it back to the player, and a Token Metadata NFT's `token` is the
- * player's. `extra`: a hook's or a memo's accounts.
- */
-export declare function settleIx({ signer, orderAddress, order, projectState, items, nfts, prizeTo, putBack, subject, handBack, holders, programs, extra }: {
+ * backend delivering a normal item from the receipt; tokens from the project's vault; an NFT taken out of its stash),
+ * then splits the payment (a share may burn it). The order's player, its settler or the project's keys send it, for the order at `orderAddress`; `signer` pays all
+ * the settle opens or mints (Core assets, token accounts, Sheets, a stash's row, the fate's writes: the order lends
+ * nothing, `settleRent`). `order` is the decoded Order; `projectState` the decoded Project; `items` and `nfts` as
+ * `wonAccounts` takes them. `putBack`: NFTs won that the player, signing, puts back into their stash in place of taking
+ * them (one its collection won't let move). `handBack`: the wallet the box's fate gives the NFT rolled on to
+ * (`receiverOf`) is an account of the loot program (`handsBack` of it as read), so the program gives it back to the
+ * player, and a Token Metadata NFT's `token` is the player's. `extra`: a hook's or a memo's accounts.
+ *
+ * `upto`, the part (`settle.rs`): `SETTLE_LAST` (the default, past the end) is the last part, all that is left (maybe
+ * nothing); 0 gives no prize and only splits the payment; any other gives the prizes from where the last part stopped
+ * (`settled`) up to it, and nothing more. The first call, whichever it is, splits the payment (its shares' accounts
+ * ride on it).
+ */
+export declare function settleIx({ signer, orderAddress, order, projectState, items, nfts, prizeTo, putBack, subject, handBack, holders, programs, upto, tree, treeMinted, unminted, extra, }: {
     extra?: never[] | undefined;
     handBack?: boolean | undefined;
     holders: any;
@@ -483,6 +3867,10 @@ export declare function settleIx({ signer, orderAddress, order, projectState, it
     putBack: any;
     signer: any;
     subject: any;
+    tree: any;
+    treeMinted: any;
+    unminted: any;
+    upto?: number | undefined;
 }): {
     programId: string;
     keys: any[];
@@ -505,8 +3893,9 @@ export declare const INCINERATOR = "1nc1nerator11111111111111111111111111111111"
 /**
  * Gives an order's payment back to its player, into their account of the mint (`signer`, anyone, opens it when it is
  * not there): an order whose roll failed or never came. A rolled order is settled, never refunded
- * (`orderRefundSlot`). A purchase counted against a box's limit for each
- * wallet is given back. `extra`: a hook's or a memo's accounts.
+ * (`orderRefundable`). A purchase counted against a box's limit for each
+ * wallet is given back. A purchase that counts its draws in its box's `in_flight` (`order.reserved`, a box that stops
+ * selling when an entry runs out) names the box, whose count it leaves. `extra`: a hook's or a memo's accounts.
  */
 export declare function refundIx({ signer, orderAddress, order, subject, programs, extra }: {
     extra?: never[] | undefined;
@@ -521,36 +3910,44 @@ export declare function refundIx({ signer, orderAddress, order, subject, program
     data: Uint8Array<any>;
 };
 /**
- * Anyone (`payer`, who pays the oracle) asks for the roll a mission's return, a recipe or a prize made (`order.status`
- * Waiting): the box's prizes' accounts, as `openBoxIx` passes them. It lands in `callback_roll`. Returns a list of
- * instructions: first `payer` opens the project's vault for each prize mint when it is not there (idempotent; the
- * program refuses the ask without them, since tokens won wait there), then the ask.
+ * Its player or the project's keys (`payer`, who pays the oracle) ask for the roll a mission's return, a recipe or a prize made (`order.status`
+ * Waiting): the box's roll accounts, as `openBoxIx` passes them (`items` maps an item a prize names to its decoded
+ * Item, for a fresh one's tables). It lands in `callback_roll`. Returns a list of instructions: first `payer` opens the
+ * project's vault for each prize mint when it is not there (idempotent; the program refuses the ask without them,
+ * since tokens won wait there), then the ask. A box with nothing in stock is refused (`SoldOut`) unless the order's own
+ * player asks in a later slot than the order was made or last asked in: a route that makes a roll and asks for it in
+ * the same transaction fails whole on an empty box, and the player keeps what the route took. The player's own ask on
+ * an empty box ends the roll there, with no oracle: rolled with nothing (an NFT it holds goes home as it was), or failed
+ * for its refund when its winner paid for it (an auction's roll lot). An answer that finds nothing at all in stock puts
+ * a free roll back to waiting (`Waiting`), for a restock or for its player to end it so. Once asked, every later ask
+ * comes in a later slot than the last (`SameSlot`, `rollAskable`).
  */
-export declare function askRollIx({ payer, orderAddress, order, box, poolMints, programs }: {
+export declare function askRollIx({ payer, orderAddress, order, box, settler, poolMints, items, programs }: {
     box: any;
+    items?: {} | undefined;
     order: any;
     orderAddress: any;
     payer: any;
     poolMints: any;
     programs: any;
+    settler?: string | undefined;
 }): {
     programId: string;
     keys: any[];
     data: Uint8Array<any>;
 }[];
-/** The SOL a box order holds for each collectible its roll may mint (`orderEscrow`): its rent, given back unspent. The
- * IDL's `ESCROW_LAMPORTS`. */
-export declare const ESCROW_LAMPORTS: bigint;
 /**
- * The authority moves the project's tokens: `from` { Pool: [i] } or { Mint: [mint] } (newly minted), `to` a pool, a
- * wallet, an account, the treasury (`treasury`, the project's wallet), a collectible's holder or 'Burn', `amount`
- * { Fixed: [n] } or { Bps: [bps] } of a pool. The authority opens the account it pays into when it is not there; a
- * collectible nobody holds gets nothing.
+ * The authority moves the project's tokens: `from` { Pool: [i] }, { Mint: [mint] } (newly minted) or { Farm: [id] } (what
+ * that farm's rewards vault holds free, beyond what it owes its seats: a fixed amount; `farm`: the farm decoded, so its
+ * record of ends comes when it keeps one), `to` a pool, a wallet, an account, the treasury (`treasury`, the project's
+ * wallet), a collectible's holder or 'Burn', `amount` { Fixed: [n] } or { Bps: [bps] } of a pool. The authority opens the
+ * account it pays into when it is not there; a collectible nobody holds gets nothing.
  */
-export declare function moveTokensIx({ authority, project, mint, from, to, amount, reference: ref, holders, programs, treasury, extra }: {
+export declare function moveTokensIx({ authority, project, mint, from, to, amount, reference: ref, holders, programs, treasury, farm, extra, }: {
     amount: any;
     authority: any;
     extra?: never[] | undefined;
+    farm?: null | undefined;
     from: any;
     holders: any;
     mint: any;
@@ -565,19 +3962,20 @@ export declare function moveTokensIx({ authority, project, mint, from, to, amoun
     data: Uint8Array<any>;
 };
 /**
- * The authority makes, rewrites or burns a collectible. `change`: { Make: { attributes } } (then `item` is the item id
- * it makes one of, `asset` is a new key that signs, and `owner` receives it), { Set: [attributes] } or 'Burn'. `collection`: the project's for a Make
- * or a Burn; for a Set, the asset's own (`MPL_CORE_PROGRAM` for one in none). `hasAuthority` false for a `Set` on an
- * NFT the project has no authority over (a Core asset of another collection, or a Token Metadata NFT's mint): what it
- * writes goes in the NFT's Sheet, or on the NFT itself when its Attributes plugin names the project.
+ * The authority rewrites or burns a collectible, or writes a wallet's profile. `change`: { Set: [attributes] }, 'Burn'
+ * (`owner`: whoever holds it, who gets its rent) or { Profile: [attributes] } (`asset` the wallet). `collection`: for a
+ * Burn the project's; for a Set the asset's own (`MPL_CORE_PROGRAM` for one in none). `hasAuthority` false for a `Set`
+ * on an NFT the project has no authority over (a Core asset of another collection, or a Token Metadata NFT's mint):
+ * what it writes goes in the NFT's Sheet, or on the NFT itself when its Attributes plugin names the project. A `Make`
+ * goes to `makeIx`.
  */
-export declare function collectibleIx({ authority, project, collection, asset, change, item, owner, hasAuthority, reference: ref }: {
+export declare function collectibleIx({ authority, project, collection, asset, change, owner, hasAuthority, reference: ref, ...make }: {
+    [x: string]: any;
     asset: any;
     authority: any;
     change: any;
     collection: any;
     hasAuthority?: boolean | undefined;
-    item?: null | undefined;
     owner?: null | undefined;
     project: any;
     reference: any;
@@ -586,57 +3984,88 @@ export declare function collectibleIx({ authority, project, collection, asset, c
     keys: any[];
     data: Uint8Array<any>;
 };
+/**
+ * The authority makes one of item `item` (`itemState`: its decoded Item, for its collection and next serial) for each
+ * of `owners`, in serial order (an owner may come more than once), with `attributes` written over the program's own: a
+ * collectible at `pda.itemAsset(item, serial)` (`madeAssets` says which), or with `tree`, a compressed NFT minted into
+ * that tree of the project's (no attributes: they go in its Sheet). A switched-off item still makes; one sold out
+ * refuses the whole call (`PrizeNotCovered`).
+ */
+export declare function makeIx({ authority, project, item, itemState, owners, attributes, tree, reference: ref }: {
+    attributes?: never[] | undefined;
+    authority: any;
+    item: any;
+    itemState: any;
+    owners: any;
+    project: any;
+    reference: any;
+    tree?: null | undefined;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/** The collectibles a `makeIx` of `count` mints (not compressed): at the item's next serials. */
+export declare const madeAssets: (project: any, item: any, itemState: any, count?: number) => any[];
 /**
  * A held NFT goes to `to`: the authority's choice while the hold runs, home to its player (anyone) after; a repaid
  * loan's home (anyone, whenever), an unpaid one's to its lender once due. `hold` is the
  * decoded Hold: its address names its end (`pda.hold(asset, free_at)`), so a release sent late never lands on a later
- * hold. The NFT is any kind
+ * hold; `address` names it when its `free_at` changed since (a repaid loan's is 0, at the address its loan named). The
+ * NFT is any kind
  * (`piece`): `asset` and `collection` for a Core asset, with `tokenMetadata` for a Token Metadata NFT, or `compressed`
  * (after a `proveLeafIx`).
  */
-export declare function releaseIx({ signer, project, collection, asset, tokenMetadata: tm, compressed, hold, to, reference: ref }: {
+export declare function releaseIx({ signer, project, collection, asset, tokenMetadata: tm, compressed, hold, address, to, treasury, reference: ref, more, }: {
+    address?: null | undefined;
     asset: any;
     collection: any;
     compressed: any;
     hold: any;
+    more?: never[] | undefined;
     project: any;
     reference: any;
     signer: any;
     to: any;
     tokenMetadata: any;
+    treasury: any;
 }): {
     programId: string;
     keys: any[];
     data: Uint8Array<any>;
 };
 /**
- * The authority opens contest `id` in `mint`. `args`: { sides, closes_at, result_by, shares, gate, deciders,
- * min_pot, stake, prize, nft, prize_split }: `prize`, what each winning entry gets when it is claimed (`prizeMetas`);
- * `nft`, a rule an NFT each entry stakes passes, in place of tokens (no shares then, no stake: the NFTs are the pot).
- * With `args.prize_split`, its token prize is set aside whole when it is
- * decided, in the contest's own vault (`pda.prizeVault`, opened now at the authority's rent), and each winning entry
+ * The authority opens contest `id` in `mint` (`projectState`: the decoded Project, whose next incarnation names the
+ * contest's list of entries). `args`: { sides, closes_at, result_by, shares, gate, deciders, min_pot, stake, prize, nft,
+ * prize_split, cap }: `prize`, what each winning entry gets with its first claim (`prizeMetas`); `nft`, a rule an NFT
+ * each entry stakes passes, in place of tokens (no shares then, no stake: the NFTs are the pot), each winner sharing the
+ * losers' NFTs, at most `cap` each (null: no cap). With `args.prize_split`, its token prize is set aside whole when it
+ * is decided, in the contest's own vault (`pda.prizeVault`, opened now at the authority's rent), and each winning entry
  * takes its part by what it put in: `prizeMint` names the prize's mint when it comes from a pool.
  */
-export declare const openContestIx: ({ authority, project, id, mint, args, prizeMint }: {
+export declare const openContestIx: ({ authority, project, projectState, id, mint, args, prizeMint }: {
     args: any;
     authority: any;
     id: any;
     mint: any;
     prizeMint: any;
     project: any;
+    projectState: any;
 }) => {
     programId: string;
     keys: any[];
     data: Uint8Array<any>;
 };
+/** A contest's list of entries, from its decoded Contest. */
+export declare const contestEntries: (contestAddress: any, contest: any) => any;
 /** The prefix of a contest's verdict (`verdictBytes`). */
-export declare const VERDICT_DOMAIN = "loot-verdict-v3";
+export declare const VERDICT_DOMAIN = "loot-verdict-v4";
 /**
- * The bytes a contest's decider key signs: "loot-verdict-v3" | program (32) | contest (32) | incarnation (u64 LE) |
- * side (1; 255 calls it off) | expires (i64 LE), then | recipient (32) when the verdict names the wallet the
- * contest's chosen share pays. `incarnation` is the contest's (the decoded Contest's), so a verdict decides only the
- * contest it was signed for, never one opened later at the same id. `decide` rebuilds them from its own accounts and
- * arguments.
+ * The bytes a contest's decider key signs: "loot-verdict-v4" | sha256(program (32) | contest (32) | incarnation (u64
+ * LE) | side (u16 LE; 65535 calls it off) | expires (i64 LE), then | recipient (32) when the verdict names the wallet
+ * the contest's chosen share pays). `incarnation` is the contest's (the decoded Contest's), so a verdict decides only
+ * the contest it was signed for, never one opened later at the same id. `decide` rebuilds them from its own accounts
+ * and arguments.
  */
 export declare function verdictBytes({ program, contest, incarnation, side, expires, recipient }: {
     contest: any;
@@ -650,12 +4079,13 @@ export declare function verdictBytes({ program, contest, incarnation, side, expi
  * Names the side that won (`side`), or calls the contest off (`side: null`). `signer` is the authority; or anyone
  * sending a decider's verdict (`verdict: { expires }`, taken once entries have closed): then this instruction goes
  * right after the Ed25519 check of the decider's signature over `verdictBytes` (`ed25519Ix` in grant.js), and
- * `signer` pays the fee. Anyone writes down a contest that is off by itself. The contest's incarnation names it, so a
+ * `signer` pays the fee, as the authority does. A contest that is off by itself (overdue) needs no decision, and takes
+ * none (`ResultOverdue`): `claim` closes it. The contest's incarnation names it, so a
  * decision sent late never decides a contest opened later at the same id. A call-off takes no share accounts. A
  * contest with a chosen share is decided naming its `recipient`, a wallet (a bounty's worker); a decider's verdict
  * signs it too (`verdictBytes`).
  */
-export declare function decideIx({ signer, project, projectState, contestAddress, contest, side, recipient, verdict, reference: ref, holders, prizeMint, programs, extra }: {
+export declare function decideIx({ signer, project, projectState, contestAddress, contest, side, recipient, verdict, reference: ref, holders, prizeMint, programs, extra, }: {
     contest: any;
     contestAddress: any;
     extra?: never[] | undefined;
@@ -699,10 +4129,12 @@ export declare const callbackRandomIx: ({ project, reference: ref, randomness }:
     data: Uint8Array<any>;
 };
 /**
- * Anyone (`payer`) runs a schedule that is due, and opens the account it pays into when that is not there.
+ * The project's keys or who it pays (`payer`; a sealed burn: anyone) run a schedule that is due, and open the account it
+ * pays into when that is not there. A run missed is missed: it pays once, for the latest run due, and the runs before it
+ * lapse; only a sealed schedule's fixed amount pays every run due, up to `upto` runs made (`scheduleCatchesUp`).
  * `poolMint`: the mint of the pool it moves from (when it moves from one). `extra`: a hook's or a memo's accounts.
  */
-export declare function runScheduleIx({ payer, project, id, schedule, poolMint, holders, programs, treasury, extra }: {
+export declare function runScheduleIx({ payer, project, id, schedule, poolMint, holders, programs, treasury, upto, extra, }: {
     extra?: never[] | undefined;
     holders: any;
     id: any;
@@ -712,61 +4144,81 @@ export declare function runScheduleIx({ payer, project, id, schedule, poolMint,
     project: any;
     schedule: any;
     treasury: any;
+    upto?: number | undefined;
 }): {
     programId: string;
     keys: any[];
     data: Uint8Array<any>;
 };
-export declare const lotteryPaymentMint: (lottery: any) => any;
+/** The address of a lottery's current round's record (there or not), from its decoded Lottery. */
+export declare const currentRound: (lotteryAddress: any, lottery: any) => any;
 /**
- * `player` buys `count` tickets: a contribution of their own at `nonce` (any number they have no contribution at in
- * this lottery), whose rent they pay and get back once it is finished. The ticket money waits in the lottery's
- * escrow until the draw. Whoever holds a collectible a fixed share pays is fixed now, from that collectible. It buys
- * only at the `lottery`'s incarnation and revision (`TermsChanged` once the owner edits or recreates it). A lottery
- * whose ticket costs an NFT (`lottery.nft_ticket`) sells one at a time, for `nft` ({ asset, collection, tokenMetadata,
- * compressed }, as `piece` takes it), which the project holds until the round is drawn (then it goes where its `then`
- * says, `spentTo`) or cancelled (then back to its buyer).
+ * `player` buys `count` tickets of lottery `id`'s current round (`lottery` decoded; `round` its decoded record, null when
+ * nobody bought into it yet: then this purchase opens it, and the lottery's spare SOL pays its rent, or the buyer fronts
+ * it, back at the close). It buys only at the revision the round copied (`TermsChanged` otherwise), and its round's
+ * address names the lottery's incarnation and round (a purchase that lands as the round moves on fails, and is sent
+ * again). A share the buyer chooses is paid now, out of the price, from the buyer's own account: to the wallet they name
+ * (`chosenRecipient`), the holder of the collectible `chosen` (its holder in `holders`), or with no choice the project's
+ * `treasury` wallet. A lottery whose ticket costs an NFT sells one at a time, for `nft` ({ asset, collection,
+ * tokenMetadata, compressed }, as `piece` takes it).
  */
-export declare function buyTicketsIx({ player, project, id, lottery, mint, count, nonce, shown, listProof, chosenRecipient, chosen, nft, playerToken, programs, extra }: {
+export declare function buyTicketsIx({ player, project, id, lottery, round, mint, count, shown, listProof, chosenRecipient, chosen, nft, holders, treasury, playerToken, programs, extra, }: {
     chosen?: null | undefined;
     chosenRecipient?: null | undefined;
     count: any;
     extra?: never[] | undefined;
+    holders?: {} | undefined;
     id: any;
     listProof: any;
     lottery: any;
     mint: any;
     nft: any;
-    nonce: any;
     player: any;
     playerToken: any;
     programs: any;
     project: any;
+    round?: null | undefined;
     shown: any;
+    treasury: any;
 }): {
     programId: string;
     keys: any[];
     data: Uint8Array<any>;
 };
-/** Anyone asks for a lottery's draw once it is due. */
-export declare const drawLotteryIx: ({ payer, project, id }: {
+/**
+ * Anyone asks for the draw of a lottery's round once it is due (`lottery` decoded). `round`: the decoded record of the
+ * round asked for (null when nobody bought into the current one: it moves on, or a lottery that draws once ends, with
+ * no ask), and `roundAddress` its address when it is not the current round's (an older round still waiting for its
+ * answer: asked again after `STALE_SECONDS`, or after the timeout cancelled, with no lottery account, so `lottery` may be
+ * null then; without `round`, the current round's, with the lottery's terms). A round's first ask fixes its money. Paid
+ * from a pot, it takes the pot, its mint and the round's account of it, then, when the lottery names a round that may
+ * still owe a pot (`lottery.owing`), that round, its account of the mint and its pot (`owing`: that round's decoded
+ * record, whose terms name its pot; without it, or when the record is gone, the pot this round pays from). A round paid
+ * from its own money takes none of these. Then each run of token prizes in place order, its mint and for a pool, the
+ * pool and the round's account of the mint (`poolMints`: a pool's index to its mint). With `skipHooked` (the project's
+ * authority only) a hooked pool or pot gives the round nothing. `extra`: hook accounts.
+ */
+export declare function drawLotteryIx({ payer, project, id, lottery, round, roundAddress, owing, skipHooked, poolMints, extra, }: {
+    extra?: never[] | undefined;
     id: any;
+    lottery: any;
+    owing?: null | undefined;
     payer: any;
+    poolMints?: {} | undefined;
     project: any;
-}) => {
+    round?: null | undefined;
+    roundAddress?: null | undefined;
+    skipHooked?: boolean | undefined;
+}): {
     programId: string;
     keys: any[];
     data: Uint8Array<any>;
 };
-/** The oracle's answer to a draw (for a local simulation). Every request of a round names the round's ticket, fixed
- * at its first ask (`asked_first`): a re-ask keeps it, so the first answer to land draws the round. */
-export declare function callbackLotteryIx({ project, id, lottery, askedFirst, randomness }: {
-    askedFirst?: any;
-    id: any;
-    lottery: any;
-    project: any;
+/** The oracle's answer to a round's draw (for a local simulation): the round's record is its only account. */
+export declare const callbackLotteryIx: ({ round, randomness }: {
     randomness: any;
-}): {
+    round: any;
+}) => {
     programId: string;
     keys: {
         pubkey: any;
@@ -775,61 +4227,89 @@ export declare function callbackLotteryIx({ project, id, lottery, askedFirst, ra
     }[];
     data: Uint8Array<any>;
 };
-export declare const cancelLotteryIx: ({ project, id }: {
-    id: any;
-    project: any;
-}) => {
-    programId: string;
-    keys: any[];
-    data: Uint8Array<any>;
-};
-/** Where a decoded contribution's shares go: as fixed when it was bought. */
-export declare function lotteryContributionShares(lottery: any, contribution: any): any;
-/**
- * Anyone (`payer`) sends a contribution's next step (`lotteryStep`; `contributionAddress`, decoded `contribution`):
- *   - a drawn round gives every place's prize first: the step of a contribution that won a place with a prize gives
- *     the first such prize not given yet to its buyer, one place a call (`prizeMetas`: `collection`, `poolMints`, `items`, `nfts` as it takes them; a roll's
- *     order at `nonce` plus the place, `prizeNonce(contributionAddress)` by default), and nothing else moves;
- *   - once every prize is given, it is routed through its shares into the pot (or its tickets burned, or its NFT ticket
- *     spent); a cancelled round's, or a lottery's that returns its tickets, goes back to its buyer, never waiting;
- *   - one that holds a winning ticket stays (`done`): once every contribution is finished, it pays its buyer every
- *     place's share of the pot it won, into their account of the pot's mint.
- * `payer` opens any account it pays into that is not there. `treasury`: the project's treasury wallet, for a share
- * that names it. A ticket an NFT paid for passes that NFT (`ticket`: its kind, as `piece` takes it); `handBack` when the
- * wallet its price gives it to is an account of the loot program (`handsBack`), where it goes back to its buyer (a
- * Token Metadata NFT into the buyer's token account).
- */
-export declare function finishLotteryContributionIx({ payer, project, id, lottery, contributionAddress, contribution, treasury, nonce, collection, poolMints, items, nfts, ticket, handBack, programs, extra }: {
-    collection: any;
-    contribution: any;
-    contributionAddress: any;
+/** The accounts a round's close takes after a pull's own: each of its token accounts, its mint and who opened it (the
+ * lottery, which gets its spare back, or a buyer who fronted it; `owner` for one the lottery opened, once it is closed). */
+export declare const roundCloseMetas: (key: any, r: any, owner?: null) => any;
+/** The NFT a raffle's place draws from the lottery's own stash (`stash` decoded, as it is now) with the round's answer. */
+export declare const raffledNft: (stash: any, answer: any, place: any) => any;
+/**
+ * The NFT of the lottery's own stash each place of a drawn round that holds or draws one gets, in place order, as the
+ * pulls take them out (`LotteryRound::assign`): the ones already taken out (`r.nfts`), then the rest as the stash
+ * (`stash`, decoded as it is now) gives them, a named one found or one drawn by weight with the round's answer, each
+ * taken out before the next. null for a place whose NFT isn't there (it gets nothing).
+ */
+export declare function stashNfts(r: any, stash: any): any;
+/**
+ * Anyone (`payer`) pulls `part` of the round at `roundAddress` (`round` decoded; `partsOwed` and `commonOwed` say what is
+ * owed):
+ *   'Own'            entry `entry`'s own part: a refund, a no-loss ticket's price, or its NFT ticket back or where its
+ *                    price sends it (`ticket` its kind as `piece` takes it; `handBack` when the wallet its price gives
+ *                    it to is an account of the loot program; `hold`: made a hold for whoever it is owed to instead);
+ *   { Pot: [run] }   the entry's places in the run, their part of what the round pays from, paid into the buyer's account;
+ *   { Prize: [run] } their prize: tokens into the buyer's account, or each place's prize (`prize`: { stash, the lottery's
+ *                    own stash decoded, for NFTs not taken out yet (`stashNfts`); stashes, a project stash's id to its
+ *                    decoded stash; nfts, an NFT's kind by its asset; hold, NFTs made holds; most, the most places a
+ *                    pull carries; and what `prizeMetas` takes: collection, poolMints, items, projectMint }), a roll's
+ *                    order at `prizeRollNonce(nonce + place)` (ask it in the same transaction: `pullRolls`);
+ *   { Common: [i] }  a part owed in common: share `i`, what the places leave (`i` = the shares' count: to the pot, or
+ *                    to `rest` for a round paid from its own money; never owed when that burns), a pool's prize back after a
+ *                    cancel (past it), paid where it goes (`holders`, `programs`); `toTreasury` when that can't take it
+ *                    (a pool never opened, the pot closed since or made again in another mint, an account gone: a
+ *                    holder nobody is is found here).
+ * The pull that leaves nothing owed closes the round (`projectState`: its treasury and owner; `lotteryClosed` when the
+ * lottery is gone, so rent it lent goes to the owner). A round that owes nothing and waits only for its close is closed
+ * by any pull.
+ */
+export declare function pullIx({ payer, project, roundAddress: key, round: r, entry, part, projectState, ticket, handBack, hold, nonce, prize, holders, toTreasury, lotteryClosed, programs, extra, }: {
+    entry?: number | undefined;
     extra?: never[] | undefined;
     handBack?: boolean | undefined;
-    id: any;
-    items: any;
-    lottery: any;
-    nfts?: {} | undefined;
-    nonce: any;
+    hold?: boolean | undefined;
+    holders?: {} | undefined;
+    lotteryClosed?: boolean | undefined;
+    nonce?: bigint | undefined;
+    part?: string | undefined;
     payer: any;
-    poolMints: any;
+    prize?: {} | undefined;
     programs: any;
     project: any;
+    projectState: any;
+    round: any;
+    roundAddress: any;
     ticket?: {} | undefined;
-    treasury: any;
+    toTreasury?: boolean | undefined;
 }): {
     programId: string;
     keys: any[];
     data: Uint8Array<any>;
 };
+/** The orders the rolls a `{ Prize: [run] }` pull of entry `entry` makes (a place's prize that is a roll), each with its
+ * box: [{ order, box }], at `prizeRollNonce(nonce + place)` for the entry's buyer. Ask each in the pull's transaction. */
+export declare function pullRolls({ project, round: r, entry, part, nonce }: {
+    entry: any;
+    nonce?: bigint | undefined;
+    part: any;
+    project: any;
+    round: any;
+}): {
+    order: any;
+    box: any;
+}[];
 /**
- * The owner opens farm `id`: of `stakedMint`'s tokens, or of collectibles when it is null. Its rewards come from pool
- * `args.rewards_pool`, whose mint is `rewardsMint`: all it receives, shared, or with `args.rate` ({ per_day, mints })
- * a fixed rate, minted or from that pool (a rate of 0 pays nothing: a farm that only grows or gives prizes).
- * `args.gates`: the rules an NFT must all pass. `args.growth`: up to 4 of { key, per_day, level, steps, streak }, each
- * writing points (and a level) on what is staked; tiers' `prize` is paid from `args.prize` ({ Mint: [mint] } or
- * { Pool: [index] }), whose mint is `prizeMint`. `args.ends_at`: when it ends (0: never). For a farm of collectibles,
- * `args.lock_key`: the attribute a staked NFT's lock is written under, as the time it ends, so recipes and rolls can
- * move it; `args.upkeep_key`: the attribute that says until when it earns and grows (fuel). Empty: none.
+ * The owner opens farm `id`: of `stakedMint`'s tokens, or of collectibles when it is null. Its rewards are `rewardsMint`'s,
+ * in its own rewards vault (`pda.rewards(farm)`), which anything funds by a plain transfer (a share or a schedule paying
+ * `{ Account: [vault] }`): all that lands there, shared, or with `args.rate` ({ per_day, mints, shared, halve_every }) a
+ * fixed rate, for each seat at x1 or with `shared` the whole farm's shared by weight, halving every `halve_every`
+ * seconds from the farm's opening (0: never), minted when a seat is paid or paid from what the vault holds free while it
+ * lasts (a rate of 0 pays nothing: a farm that only grows or gives prizes). `args.gates`: the rules an NFT must all
+ * pass. `args.growth`: any number of { key, per_day, level, steps, streak, profile, at_least }, each writing points (and
+ * a level) on what is staked, or with `profile` on the staker's profile (a token seat only while it stakes `at_least`);
+ * a tier's `earns_for`: seconds a seat earns and grows after its lock started (0: no end). `args.ends_at`: when it ends
+ * (0: never). For a farm of collectibles, `args.lock_key`: the attribute a staked NFT's lock is written under, as the
+ * time it ends, so recipes and rolls can move it; `args.upkeep_key`: the attribute that says until when it earns and
+ * grows (fuel). Empty: none. `args.exit_to`: where early-exit fees go, 'Burn', { Pool: [index] } or 'Rewards' (the
+ * farm's own vault: a farm whose staked token is its rewards'). A farm whose seats can stop earning and that pays keeps a
+ * record of when (`farmKeepsEnds`, `pda.ends`), made here at the owner's rent; each new time costs its writer `END_BYTES`.
  */
 export declare const openFarmIx: ({ owner, project, id, args, rewardsMint, stakedMint }: {
     args: any;
@@ -844,9 +4324,66 @@ export declare const openFarmIx: ({ owner, project, id, args, rewardsMint, stake
     data: Uint8Array<any>;
 };
 /**
- * `player` stakes `amount` at lock tier `tier`. `farm` is decoded; `extra` carries token hook/memo accounts. A new tier
- * on a seat with a booster, in a farm with growth, needs the booster's growth written first: put a `refreshSeatIx` of
- * the seat before it, in the same transaction.
+ * Whether a farm with these args keeps a record of when its seats stop earning (`Farm::keeps_ends`): a tier has a term
+ * (`earns_for`) or the farm reads an upkeep (`upkeep_key`), and it pays something (no rate, or a rate above 0). The farm
+ * and every move of it then pass the record (`WrongEnds` otherwise).
+ */
+export declare const farmKeepsEnds: (args: any) => any;
+/**
+ * What a farm has to walk (`Farm::walk`): the times of its record of ends (`ends`, from `decodeEnds`; an empty list for none)
+ * past its clock, up to `now` (Unix seconds, the chain's clock) or the farm's end. Every move walks all of them first, each a
+ * little compute, so a farm idle past many ends may leave a move no room: `farmNeedsWalk`.
+ */
+export declare function endsToWalk(farm: any, ends: any, now: any): any;
+/** How many ends `walk_farm` walks in one transaction at `WALK_COMPUTE_UNITS`: an end takes at most some 2,300 units, with a
+ * halving rate (`js/test/farm-ends.test.mjs` measures it). */
+export declare const WALK_PER_TX = 500;
+/** The compute units a transaction that walks ends asks for: `walk_farm`, or a move with ends to walk first. */
+export declare const WALK_COMPUTE_UNITS = 1400000;
+/** How many ends a move can walk first at `WALK_COMPUTE_UNITS` and still do its own work: past this, the farm is walked
+ * first (`farmNeedsWalk`). */
+export declare const MOVE_WALK_ROOM = 400;
+/**
+ * Whether a farm has passed more ends than a move can walk in its own transaction (`endsToWalk`, `MOVE_WALK_ROOM`): such
+ * a move fails on compute until `walk_farm` has caught the farm up. Nothing is lost by waiting: what a seat earned by
+ * its end is written when the farm walks past it, however late.
+ */
+export declare const farmNeedsWalk: (farm: any, ends: any, now: any) => boolean;
+/**
+ * The transactions that walk a farm up to now, oldest ends first: one `walkFarmIx` each, `perTx` ends at most, `[]` when
+ * it has nothing to walk. Anyone may send them, in order; each is free but for its network fee.
+ */
+export declare function walkFarmParts({ project, id, farm, ends, now, perTx }: {
+    ends: any;
+    farm: any;
+    id: any;
+    now: any;
+    perTx?: number | undefined;
+    project: any;
+}): {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+}[];
+/**
+ * Credits a farm up to at most `most` of the times its seats stopped earning. Anyone may send it, signing nothing but its
+ * network fee: it decides nothing, every move walks the same times the same way. For a farm that has passed more of them
+ * than a move's transaction can walk (`farmNeedsWalk`, `walkFarmParts`).
+ */
+export declare const walkFarmIx: ({ project, id, farm, most }: {
+    farm: any;
+    id: any;
+    most?: number | undefined;
+    project: any;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
+/**
+ * `player` stakes `amount` at lock tier `tier`. `farm` is decoded; `extra` carries token hook/memo accounts. A seat with
+ * a booster on, or one whose growth the stake changes, needs a `refreshSeatIx` of it first, in the same transaction
+ * (`stakeRefreshFirst`).
  */
 export declare const stakeTokensIx: ({ player, project, id, farm, amount, tier, programs, shown, extra }: {
     amount: any;
@@ -864,10 +4401,9 @@ export declare const stakeTokensIx: ({ player, project, id, farm, amount, tier,
     data: Uint8Array<any>;
 };
 /**
- * `player` takes `amount` out (0: only collects what is owed, and takes out tokens whose unbonding wait is over);
- * `forfeit` gives up rewards that can't move. Before the tier's lock has run, a tier with an early-exit fee
- * (`exit_bps`) lets it leave, leaving that share of `amount` to the farm's `exit_to`. In a farm that unbonds
- * (`unbond`), what is taken out waits that long first, earning nothing (`withdrawable`).
+ * `player` takes `amount` out (0: only collects what is owed); `forfeit` gives up rewards that can't move. Before the
+ * tier's lock has run, a tier with an early-exit fee (`exit_bps`) lets it leave, leaving that share of `amount` to the
+ * farm's `exit_to`; it keeps the rewards it was credited.
  */
 export declare const unstakeTokensIx: ({ player, project, id, farm, amount, forfeit, programs, extra }: {
     amount: any;
@@ -883,8 +4419,34 @@ export declare const unstakeTokensIx: ({ player, project, id, farm, amount, forf
     keys: any[];
     data: Uint8Array<any>;
 };
-/** What a token seat may take out now (Unix seconds `now`): its unbonded tokens once their wait is over, else 0. */
-export declare const withdrawable: (seat: any, now: any) => bigint;
+/**
+ * Whether taking `amount` out of a token seat (decoded `seat`) needs a `refreshSeatIx` of it first, in the same
+ * transaction (`RefreshFirst`): the farm grows, and the exit closes the seat or drops it below a growth's least stake, so
+ * what it grew since its last refresh is written before it goes. Never under `forfeit`.
+ */
+export declare const refreshFirst: (farm: any, seat: any, amount: any, forfeit?: boolean) => any;
+/**
+ * Whether a stake of tokens at `tier` in a token seat (decoded `seat`; null for a new one), or with `compound` a
+ * compound of what it is owed, needs a `refreshSeatIx` of it first, in the same transaction (`RefreshFirst`), at `now`
+ * (Unix seconds, the chain's clock): a seat with a booster on (its boost is read again there, so a top-up never stakes
+ * more at a boost its booster no longer gives), or a seat that grows (a booster's growth, or its player's profile's)
+ * when the stake changes how: a new tier, a farm whose growth reads the amount, a seat past its term; a compound when
+ * that growth reads the amount.
+ * @param {any} farm
+ * @param {any} seat
+ * @param {{ tier?: number, now?: bigint | number, compound?: boolean }} [options]
+ */
+export declare function stakeRefreshFirst(farm: any, seat: any, { tier, now, compound }?: {
+    tier?: number;
+    now?: bigint | number;
+    compound?: boolean;
+}): any;
+/**
+ * Whether a booster put on a token seat of `farm` (decoded) needs the seat refreshed first, in the same transaction
+ * (`stake_nft`'s `RefreshFirst`): in a farm of tokens whose growth writes its players' profiles, the booster's growth
+ * starts from now, so what the seat grew before is written first.
+ */
+export declare const boosterRefreshFirst: (farm: any) => any;
 /**
  * Whether a farm (decoded) takes a stake at lock tier `tier` at `now` (Unix seconds, the chain's clock), as the program
  * judges it: a farm with an end (`ends_at`, 0 for never) takes none at its end or after it, nor one whose lock
@@ -907,7 +4469,7 @@ export declare const AUTH_RULES_PROGRAM = "auth9SigNpDKz4sJJ1DfCTuZrZNSAgh9sFD3r
  *   `burns`: burns a Core asset (false when left out); `reads`: reads its Sheet; `held`: reads it in the project's token
  *   account (an escrow farm).
  */
-export declare function piece({ project, asset, wallet, collection, hasAuthority, tokenMetadata: tm, compressed: c, moves, locks, writes, burns, reads, held }: {
+export declare function piece({ project, asset, wallet, collection, hasAuthority, tokenMetadata: tm, compressed: c, moves, locks, writes, burns, reads, held, }: {
     asset: any;
     burns?: boolean | undefined;
     collection: any;
@@ -922,6 +4484,7 @@ export declare function piece({ project, asset, wallet, collection, hasAuthority
     wallet: any;
     writes?: boolean | undefined;
 }): {
+    kind: string;
     accounts: {
         mpl_core_program: null;
         metadata: null;
@@ -974,6 +4537,7 @@ export declare function piece({ project, asset, wallet, collection, hasAuthority
     proof: any;
     writable: string[];
 } | {
+    kind: string;
     accounts: {
         collection: null;
         mpl_core_program: null;
@@ -1002,6 +4566,7 @@ export declare function piece({ project, asset, wallet, collection, hasAuthority
     proof: never[];
     writable: never[];
 } | {
+    kind: string;
     accounts: {
         metadata: null;
         edition: null;
@@ -1030,6 +4595,7 @@ export declare function piece({ project, asset, wallet, collection, hasAuthority
     proof: never[];
     writable: string[];
 };
+export declare function anotherMetas(p: any): any[];
 /** The account an NFT paid goes to: the wallet it is given to, the stash it goes into, or the
  * incinerator for a burn (any account stands in for a Core asset, which Core burns). `then`: 'Burn', { Give: [wallet] }
  * or { Stash: [id] }. */
@@ -1055,7 +4621,7 @@ export declare function nftPaid({ project, owner, then, asset, collection, hasAu
  * place), or given to the wallet `to` (the treasury, a partner). The receipt (`PaidNft`) is the record: an app admits the player when the NFT, where it went (`to`: a payment to the player's own wallet pays nothing) and the reference
  * are the ones it asked for. `extra`: Core's transfer adapters.
  */
-export declare function payNftIx({ player, project, asset, to, collection, hasAuthority, tokenMetadata: tm, compressed, reference: ref, extra }: {
+export declare function payNftIx({ player, project, asset, to, collection, hasAuthority, tokenMetadata: tm, compressed, reference: ref, extra, }: {
     asset: any;
     collection: any;
     compressed: any;
@@ -1113,16 +4679,48 @@ export declare function freshNftAccount({ payer, holder, mint, index, there }: {
 export declare const FRESH_NFT_ACCOUNTS = 8;
 /** A token account's rent on every cluster (165 bytes). */
 export declare const TOKEN_ACCOUNT_RENT = 2039280n;
-/** Anyone closes a compressed NFT's record (`pda.leaf`) that no longer matches its tree; its rent goes to `payer`, who paid it. */
-export declare const closeLeafIx: ({ asset, tree, payer }: {
+/**
+ * A compressed NFT's record (`pda.leaf`) closes, its rent back to `payer`, who paid it: at any time with `payer` signing
+ * (`signs`, the default), or by anyone once it no longer matches its tree. A route that finds no record asks for a proof
+ * again (`NotProven`), so a client closes it in the transaction that used it (`withLeafCloses`).
+ */
+export declare const closeLeafIx: ({ asset, tree, payer, signs }: {
     asset: any;
     payer: any;
+    signs?: boolean | undefined;
     tree: any;
 }) => {
     programId: string;
     keys: any[];
     data: Uint8Array<any>;
 };
+/**
+ * `instructions` with a `close_leaf` after them for each compressed NFT's record a `prove_leaf` among them makes, its
+ * prover signing as the record's payer, so the record's rent comes back in the same transaction (one closed already is
+ * left alone).
+ */
+export declare function withLeafCloses(instructions: any): any;
+/**
+ * Anyone closes the Sheet of an NFT that is burned: `burned` is what shows it (the Core asset's own address, burned to
+ * one byte; a Token Metadata mint holding none; or a compressed NFT's record proving its leaf burned). Its rent goes to
+ * the project's `treasury` wallet. A compressed NFT's (`tree`: the tree it was minted in) closes only on a record proven
+ * empty (its data hash all zeros: a live leaf of the default owner is not burned) that still reads against that tree,
+ * or whose tree is gone: the tree goes in the edition's place, and `burned` defaults to the NFT's record
+ * (`pda.leaf`). A Token Metadata NFT's (`tokenMetadata`: true, or its kind) names its edition, which must be closed
+ * too: its mint holds none, with no mint authority but its edition (`NotBurned` otherwise).
+ */
+export declare const closeSheetIx: ({ project, nft, tree, burned, treasury, tokenMetadata: tm, }: {
+    burned?: any;
+    nft: any;
+    project: any;
+    tokenMetadata?: null | undefined;
+    treasury: any;
+    tree?: null | undefined;
+}) => {
+    programId: string;
+    keys: any[];
+    data: Uint8Array<any>;
+};
 /**
  * Anyone proves a compressed NFT's leaf (`compressed` from `compressedFromDas`): put it before the instruction that
  * uses the NFT, in the same transaction. The proof must be against the tree's current root (`StaleProof` otherwise:
@@ -1165,10 +4763,11 @@ export declare const proveTraitsIx: ({ signer, project, key, nft, attributes, pr
  * `player` stakes an NFT: on a seat of its own in a farm of collectibles, or as the booster of the player's token seat
  * in a farm of tokens. Any kind (`piece`): a Core asset, a Token Metadata NFT's mint with `tokenMetadata`, or
  * `compressed` (after a `proveLeafIx` in the same transaction). `previous`: in a farm that watches, the last staker of
- * an NFT that changed hands, whose seat this takes over. `extra` carries reward token hooks/memos and Core transfer
- * adapter accounts.
+ * an NFT that changed hands, whose seat this takes over (alone). In a farm of collectibles, `more` NFTs (each { asset,
+ * collection, hasAuthority, tokenMetadata, compressed }) go in the same call at the same tier, one fee, by their seats'
+ * addresses. `extra` carries reward token hooks/memos and Core transfer adapter accounts.
  */
-export declare const stakeNftIx: ({ player, project, id, farm, asset, collection, hasAuthority, tokenMetadata: tm, compressed, previous, tier, programs, extra }: {
+export declare const stakeNftIx: ({ player, project, id, farm, asset, collection, hasAuthority, tokenMetadata: tm, compressed, previous, tier, programs, more, extra, }: {
     asset: any;
     collection: any;
     compressed: any;
@@ -1176,6 +4775,7 @@ export declare const stakeNftIx: ({ player, project, id, farm, asset, collection
     farm: any;
     hasAuthority?: boolean | undefined;
     id: any;
+    more?: never[] | undefined;
     player: any;
     previous?: null | undefined;
     programs: any;
@@ -1190,11 +4790,16 @@ export declare const stakeNftIx: ({ player, project, id, farm, asset, collection
 /**
  * `player` takes an NFT out once its lock has run: it grows on its way out (a farm with growth writes on it, or on its
  * Sheet), and from its own seat takes its tier's prize. `forfeit` gives up the rewards and the prize. Leaving a tier
- * that rolls (`roll`: its box id), the NFT is rolled on that box, in an order at `nonce` (anyone then asks the oracle,
- * `askRollIx`, and settles); a box that can burn it or give it away keeps it in the project's hands until then.
+ * that rolls (`roll`: its box id, `boxes` its decoded box by id), the NFT is rolled on that box, in an order named by
+ * `nonce` (`namedRollNonce`: the NFT's own on a box that holds it; its player or the project's keys then ask the oracle,
+ * `askRollIx`, and settles); a box that can burn it or give it away keeps it in the project's hands until then. `more`
+ * NFTs of the player's in the farm (each { asset, collection, hasAuthority, tokenMetadata, compressed, tier, roll }) leave
+ * in the same call, one fee, one transfer of rewards: by their seats' addresses, the `i`th's roll at `nonce + 2i` and its
+ * prize's at `nonce + 2i + 1` (`seatNonces` says which NFT has which). One still locked refuses the whole call.
  */
-export declare const unstakeNftIx: ({ player, project, id, farm, asset, collection, hasAuthority, tokenMetadata: tm, compressed, forfeit, roll, nonce, tier, projectCollection, poolMints, items, nft, programs, extra }: {
+export declare const unstakeNftIx: ({ player, project, id, farm, asset, collection, hasAuthority, tokenMetadata: tm, compressed, forfeit, roll, nonce, tier, projectCollection, poolMints, items, nft, boxes, programs, more, extra, }: {
     asset: any;
+    boxes?: {} | undefined;
     collection: any;
     compressed: any;
     extra?: never[] | undefined;
@@ -1203,6 +4808,7 @@ export declare const unstakeNftIx: ({ player, project, id, farm, asset, collecti
     hasAuthority?: boolean | undefined;
     id: any;
     items: any;
+    more?: never[] | undefined;
     nft: any;
     nonce?: bigint | undefined;
     player: any;
@@ -1218,18 +4824,26 @@ export declare const unstakeNftIx: ({ player, project, id, farm, asset, collecti
     keys: any[];
     data: Uint8Array<any>;
 };
+/** The nonce each NFT's mission roll is named by in an `unstakeNftIx` of several (`assets`), in the order the call
+ * takes them: the `i`th by its seat's address `nonce + 2i` (its order at `namedRollNonce` of it), its prize's roll
+ * `nonce + 2i + 1` (at `prizeRollNonce`). */
+export declare const seatNonces: (project: any, id: any, farm: any, player: any, assets: any, nonce?: bigint) => any;
 /**
- * `player` collects what the seat of `by` owes (their own address for tokens, a collectible's asset). `held`: in a farm
+ * `player` collects what the seat of `by` owes (their own address for tokens, a collectible's asset); with `compound`, a
+ * token seat's is staked instead (a seat with a booster on needs a `refreshSeatIx` of it first: `stakeRefreshFirst`). `held`: in a farm
  * that watches, what shows the player still holds the seat's NFT (the Core asset, their token account of a Token
- * Metadata NFT, or a compressed NFT's record, `pda.leaf`, with its `tree`), which such a farm refuses to go without.
+ * Metadata NFT, or a compressed NFT's record, `pda.leaf`, with its `tree`), which such a farm refuses to go without
+ * (`NotProven`). `more` seats of the player's in the farm (each { by, held, tree }) collect in the same call, one fee,
+ * one transfer.
  */
-export declare const harvestIx: ({ player, project, id, farm, by, held, tree, compound, programs, extra }: {
+export declare const harvestIx: ({ player, project, id, farm, by, held, tree, compound, programs, more, extra, }: {
     by?: any;
     compound?: boolean | undefined;
     extra?: never[] | undefined;
     farm: any;
     held?: null | undefined;
     id: any;
+    more?: never[] | undefined;
     player: any;
     programs: any;
     project: any;
@@ -1247,7 +4861,7 @@ export declare const harvestIx: ({ player, project, id, farm, by, held, tree, co
  * NFT's token account that holds it, `holder`'s (its staker's, or a watched NFT's buyer's). `signer` pays for what the
  * write adds. `extra`: the reward mint's hook accounts.
  */
-export declare const refreshSeatIx: ({ signer, project, id, farm, by, seat, collection, hasAuthority, tokenMetadata: tm, compressed, holder, extra }: {
+export declare const refreshSeatIx: ({ signer, project, id, farm, by, seat, collection, hasAuthority, tokenMetadata: tm, compressed, holder, extra, }: {
     by: any;
     collection: any;
     compressed: any;
@@ -1269,19 +4883,25 @@ export declare const refreshSeatIx: ({ signer, project, id, farm, by, seat, coll
  * `player` crafts recipe `id` (`recipe` decoded, the version shown to them), `times` over. `assets`: the
  * collectibles handed in, in the recipe's order (the burned, the used, and for a `Show` line the NFT shown: its address
  * when it is the project's, `{ asset, collection }` for a Core NFT of another collection, `{ mint, owner }` for a Token
- * Metadata one; for a `Trade` line the NFT traded in, as `piece` takes it: `{ asset, collection, tokenMetadata,
- * compressed }`). A collectible used or renewed that is staked in a farm holding it for the player (escrow) is
- * `{ asset, farm }`, `farm` that farm's id: its seat and farm follow it. A `Staked` line names the farm its collectible
+ * Metadata one, `{ compressed, tree }` for a compressed one; with `farm` (a farm's id: `{ asset, farm }` for the
+ * project's own) when the project locks it in the player's wallet on a seat of that farm, which freezes, and a raise on
+ * it lowers a number: its seat and farm follow it, and the raise may not lower a number that farm reads; for a `Trade` line the NFT traded in, as `piece` takes it: `{ asset, collection, tokenMetadata,
+ * compressed }`). A collectible used that is staked in a farm holding it for the player (escrow) or locking it in their
+ * wallet (freeze) is `{ asset, farm }`, `farm` that farm's id: its seat and farm follow it (a raise on it may not lower a
+ * number its farm reads: `BadRecipe`). One that boosts the player's token seat in a farm of tokens is
+ * `{ asset, farm, booster: true }`: the player's token seat (`["seat", farm, player]`) and that farm follow it, on a kept
+ * `Use` line or a `Show` line alike. A `Staked` line names the farm its collectible
  * is staked in (`Input::Staked { item, farm }`, escrowed or frozen there): its address, or `{ asset, farm }` with that
  * farm, and its seat and that farm follow it. Each item line passes its item's collection
  * (`items[id].collection`, the decoded Items; `collection` when not given), written for a burn: Core writes it as it
  * burns a collectible. A recipe's `raises` write on the kept ones, in their Sheet when the project has no
  * authority over them. The player opens any account a line pays into that is not there. A roll it makes (a
- * `Prize::Roll` or a `RollOn`) passes its box's prize mints (`rollMints`): `boxes` maps the box's id to its decoded
- * LootBox, `rollPools` each pool its prizes name to its mint (null for one never opened; `poolMints` when not given).
+ * `Prize::Roll` or a `RollOn`) passes its box and its order, nothing more; a `RollOn`'s order is where `namedRollNonce`
+ * says, which reads the rolled box (`boxes`: a box's id to its decoded LootBox). Its player or the project's keys then ask for the roll
+ * (`askRollIx`, in the same transaction when it fits).
  * A craft makes several Core calls: raise the compute limit. `extra`: a token's hook accounts.
  */
-export declare function craftIx({ player, project, collection, id, recipe, assets, times, nonce, holders, programs, treasury, poolMints, items, nfts, boxes, rollPools, extra }: {
+export declare function craftIx({ player, project, collection, id, recipe, assets, times, nonce, holders, programs, treasury, poolMints, items, nfts, boxes, extra, }: {
     assets?: never[] | undefined;
     boxes?: {} | undefined;
     collection: any;
@@ -1296,7 +4916,6 @@ export declare function craftIx({ player, project, collection, id, recipe, asset
     programs: any;
     project: any;
     recipe: any;
-    rollPools?: any;
     times?: number | undefined;
     treasury: any;
 }): {
@@ -1311,11 +4930,12 @@ export declare const craftNewAssets: (recipe: any) => any;
  * asset (`collection` its own, Core's address for none), a Token Metadata NFT (`tokenMetadata`), or `compressed` (after
  * a `proveLeafIx`).
  */
-export declare function holdIx({ player, project, collection, asset, tokenMetadata: tm, compressed, freeAt, reference: ref }: {
+export declare function holdIx({ player, project, collection, asset, tokenMetadata: tm, compressed, freeAt, reference: ref, more, }: {
     asset: any;
     collection: any;
     compressed: any;
     freeAt: any;
+    more?: never[] | undefined;
     player: any;
     project: any;
     reference: any;
@@ -1329,19 +4949,24 @@ export declare function holdIx({ player, project, collection, asset, tokenMetada
  * The project's owner or authority (`signer`) puts an NFT it holds into stash `id`, or (`out`: a wallet) takes one the
  * stash holds out to that wallet. The NFT is any kind, as `piece` takes it: `collection` a Core asset's own,
  * `tokenMetadata`, or `compressed` after a `proveLeafIx` in the same transaction. The signer pays what the stash grows
- * by, and gets back the rent it no longer needs. Taken out with `out` the project's own address, the entry is only dropped
- * from the stash and the NFT stays where it is. `out` is never another account of the program (`ToTheProject`).
+ * by, and gets back the rent it no longer needs. `drop`: the NFT leaves the stash and stays where it is, owed to the
+ * treasury in its hold (`["hold", nft, 0]`, the signer paying its rent until anyone `release`s it to the treasury, one
+ * NFT a call). `out` is never the project's own address nor another account of the program (`ToTheProject`).
  */
-export declare function stashIx({ signer, project, id, lottery, asset, out, collection, tokenMetadata: tm, compressed }: {
+export declare function stashIx({ signer, project, id, lottery, lotteryState, asset, out, drop, weight, collection, tokenMetadata: tm, compressed, more, }: {
     asset: any;
     collection: any;
     compressed: any;
+    drop?: boolean | undefined;
     id: any;
     lottery?: null | undefined;
+    lotteryState?: null | undefined;
+    more?: never[] | undefined;
     out?: null | undefined;
     project: any;
     signer: any;
     tokenMetadata: any;
+    weight?: number | undefined;
 }): {
     programId: string;
     keys: any[];
@@ -1351,9 +4976,9 @@ export declare function stashIx({ signer, project, id, lottery, asset, out, coll
  * `player` backs `side` with `amount`, naming the contest's incarnation (which fixes its terms). `contest` is the
  * decoded Contest. A contest of NFTs (`contest.nft`) takes one NFT instead (`nft`: { asset, collection, tokenMetadata,
  * compressed }, as `piece` takes it), which the contest holds until it is claimed. `shown`/`listProof` pass its gate.
- * `extra`: a hook's accounts.
+ * A new entry's record is the player's to pay (not refunded). `extra`: a hook's accounts.
  */
-export declare function enterIx({ player, project, id, contest, side, amount, shown, listProof, nft, playerToken, programs, extra }: {
+export declare function enterIx({ player, project, id, contest, side, amount, shown, listProof, nft, playerToken, programs, extra, }: {
     amount: any;
     contest: any;
     extra?: never[] | undefined;
@@ -1372,63 +4997,61 @@ export declare function enterIx({ player, project, id, contest, side, amount, sh
     data: Uint8Array<any>;
 };
 /**
- * Anyone (`payer`) claims `player`'s entry on `side`, into the player's account of the mint, which `payer` opens when
- * it is not there (the last entry's claim closes the pot and writes the mint). A winning entry of a contest with a
- * prize (`contest.prize`) also gets it (`prizeMetas`: `collection`, `poolMints`, `items`, `nft`; a roll's order at
- * `nonce`, `prizeNonce(entry)` by default), `payer` paying what it opens. For a contest of NFTs, `entry` is the decoded
- * Entry: its own NFT (`own`, its kind as `piece` takes it) goes back to its player, or to the opener for a loser's NFT
- * no winner took; a winner, while losers' NFTs are left, also takes one (`taking`: { player, side } of a losing entry
- * that still holds one, and `kind`, its NFT's kind). While losers' NFTs are left only the winner sends their claim, and
- * picks which (`payer` the player; `WinnerPicks` otherwise). `extra`: a hook's accounts.
+ * Anyone (`payer`) claims `player`'s entry (`entries`: the contest's decoded entries, `decodeEntries`), into the
+ * player's account of the mint, which `payer` opens when it is not there. A winner's first claim also gives the
+ * contest's prize (`prizeMetas`: `collection`, `poolMints`, `items`, `nft`; a roll's order at `nonce`, `prizeNonce` of the
+ * contest and the player by default), unless the player (signing) `forgo`es it. In a contest of NFTs it moves the NFTs of
+ * the entries `nfts` names by their place in the list (the player's own by default, while the contest holds it): an
+ * entry's own back to its player (anyone sends it); a loser's to the winner while it has picks left of its share (only
+ * the winner sends it, and picks which: `WinnerPicks`), or to the opener once no winner has picks left. `kinds` maps an
+ * NFT to its kind, as `piece` takes it. With `hold` (true, or a list of assets), each becomes a hold for the wallet it goes to (an NFT that can't
+ * move now); with `end`, the winner leaves the rest of its share to the opener. The claim that leaves nothing owed
+ * closes the contest (`projectState`: its treasury); a contest that owes nothing (nobody entered, every part claimed,
+ * off by itself with none in) is closed by any claim, the `payer`'s. `extra`: a hook's accounts.
  */
-export declare function claimIx({ payer, project, id, contest, player, side, entry, own, taking, nonce, collection, poolMints, items, nft, prizeMint, forgo, programs, extra }: {
+export declare function claimIx({ payer, project, projectState, id, contest, entries, player, nfts, kinds, nonce, collection, poolMints, items, nft, prizeMint, forgo, end, hold, programs, extra, }: {
     collection: any;
     contest: any;
-    entry: any;
+    end?: boolean | undefined;
+    entries: any;
     extra?: never[] | undefined;
     forgo?: boolean | undefined;
+    hold?: boolean | undefined;
     id: any;
     items: any;
+    kinds?: {} | undefined;
     nft: any;
+    nfts: any;
     nonce: any;
-    own?: {} | undefined;
     payer: any;
     player: any;
     poolMints: any;
     prizeMint: any;
     programs: any;
     project: any;
-    side: any;
-    taking: any;
+    projectState: any;
 }): {
     programId: string;
     keys: any[];
     data: Uint8Array<any>;
 };
-/** What a bid signs: sha256(mint | Borsh(AuctionArgs)). */
-export declare function auctionTerms(mint: any, args: any): Uint8Array<ArrayBuffer>;
-/** An auction's AuctionArgs from its decoded account (what `open_auction` fixed). */
-export declare const auctionArgsOf: (auction: any) => {
-    lot: any;
-    reserve: any;
-    min_raise_bps: any;
-    starts_at: any;
-    ends_at: any;
-    extend: any;
-    shares: any;
-    gate: any;
-    nft_bids: any;
-};
+/**
+ * What a bid signs: the auction's bytes but the bid, which sits last (`high_bidder`, `high`, `last_bid_at`, `held`:
+ * 60 bytes, and an auction of NFT bids' room for `MAX_BID_NFTS` after them). `auction`: the decoded Auction, or its
+ * account's bytes.
+ */
+export declare function auctionTerms(auction: any): Uint8Array<ArrayBuffer>;
 /** When bids close, as the program reckons it: `ends_at`, or `extend` seconds after the last bid when that is later. */
 export declare const auctionEnds: (auction: any) => bigint;
-/** The least next bid the program takes, or null when no u64 amount can top it. */
+/** The least next bid the program takes, or null when nothing can top it (no u64 amount; a bid of NFTs past `MAX_BID_NFTS`). */
 export declare function leastBid(auction: any): bigint | null;
 /**
  * `seller` opens its auction `id` of `args.lot` ({ Item: [id] }, { Asset: [address] } or { Roll: [box id] }), alone,
  * and pays its rent: a player for an NFT of the project's own collection they hold; the project's owner or authority for an
  * NFT of any kind it holds (`piece`: `collection` a Core asset's own, `tokenMetadata`, or `compressed` after a
- * `proveLeafIx`), a new unit of its item, or a roll of one of its boxes (a mystery lot). Its address names the seller, so an
- * id is the seller's own.
+ * `proveLeafIx`), a new unit of its item, or a roll of one of its boxes (a mystery lot: the box must be written, burn
+ * no share of its price, and make an order with the auction's shares within one call's growth: `LotRefused`). Its
+ * address names the seller, so an id is the seller's own.
  */
 export declare function openAuctionIx({ seller, project, collection, tokenMetadata: tm, compressed, id, mint, args }: {
     args: any;
@@ -1444,20 +5067,25 @@ export declare function openAuctionIx({ seller, project, collection, tokenMetada
     keys: any[];
     data: Uint8Array<any>;
 };
+/** The most NFTs one bid of an auction of NFT bids holds (`MAX_BID_NFTS`, not in the IDL): a bid of more fails
+ * (`BidTooLow`), and a high bid of this many can't be topped. Its reserve is 1 to this many (`BadAuction`). */
+export declare const MAX_BID_NFTS = 3;
 /**
  * `bidder` bids `amount` on auction `id`, signing its terms; the bid it tops goes back to the high bidder's account
  * of the mint, which `bidder` opens when it is not there. `auction` is the decoded Auction. `shown`/`listProof`: what
  * passes the auction's gate. An auction of NFT bids (`auction.nft_bids`) takes `nfts` instead ([{ asset, collection,
  * tokenMetadata }], as `piece` takes each; never a compressed NFT: `CompressedBid`), handed to the project, and gives the high bid's NFTs
- * (`held`, the kinds of `auction.held`, in order) back to its bidder. `extra`: a hook's accounts.
+ * (`held`, the kinds of `auction.held`, in order) back to its bidder; one that can't move now (`hold`: true for all, or a
+ * list of assets) becomes a hold for them instead, `bidder` paying its rent until its release. `extra`: a hook's accounts.
  */
-export declare function bidIx({ bidder, project, id, auction, amount, shown, listProof, nfts, held, bidderToken, programs, extra }: {
+export declare function bidIx({ bidder, project, id, auction, amount, shown, listProof, nfts, held, hold, bidderToken, programs, extra, }: {
     amount: any;
     auction: any;
     bidder: any;
     bidderToken: any;
     extra?: never[] | undefined;
     held?: never[] | undefined;
+    hold?: boolean | undefined;
     id: any;
     listProof: any;
     nfts?: never[] | undefined;
@@ -1477,13 +5105,18 @@ export declare function bidIx({ bidder, project, id, auction, amount, shown, lis
  * roll), however long after the end it is sent. With no bid, the lot goes home. `signer` opens any account the end pays into that is
  * not there. `item` is the decoded Item of an item lot; for an NFT lot, `collection` its Core collection now (the
  * project's when left out), `tokenMetadata` for a Token Metadata NFT, or `compressed` (after a `proveLeafIx`).
+ * `hold` (anyone may; true for all, or a list of assets): an end that wouldn't fit otherwise (a compressed lot's long
+ * proof, a hooked mint, many shares) makes the NFT lot a hold for whoever it goes to (its hold passed as `order`, no
+ * piece nor proof), and a winning NFT of a bid a hold for `proceeds` (its hold's address in its piece's place); anyone
+ * then delivers each with `releaseIx`, and the end's sender gets the rent back then.
  */
-export declare function endAuctionIx({ signer, project, projectState, id, auction, item, collection, tokenMetadata: tm, compressed, held, reference: ref, nonce, holders, programs, extra }: {
+export declare function endAuctionIx({ signer, project, projectState, id, auction, item, collection, tokenMetadata: tm, compressed, held, hold, reference: ref, nonce, holders, programs, extra, }: {
     auction: any;
     collection: any;
     compressed: any;
     extra?: never[] | undefined;
     held?: never[] | undefined;
+    hold?: boolean | undefined;
     holders: any;
     id: any;
     item?: null | undefined;
@@ -1499,8 +5132,9 @@ export declare function endAuctionIx({ signer, project, projectState, id, auctio
     keys: any[];
     data: Uint8Array<any>;
 };
-/** The hash a taker signs, as the program rebuilds it: sha256(mint | rule | deal | shares), Borsh. `offer` is the decoded Offer. */
-export declare function offerTerms(offer: any): Uint8Array<ArrayBuffer>;
+/** What a taker signs: the offer's bytes but `left`, its last 2 (what a take changes). `offer`: the decoded Offer, or its
+ * account's bytes. */
+export declare const offerTerms: (offer: any) => Uint8Array<ArrayBuffer>;
 /** What one take of a deal pays out of its offer's money: a bid's price, a loan's amount. */
 export declare const dealUnit: (deal: any) => bigint;
 /**
@@ -1541,7 +5175,7 @@ export declare function closeOfferIx({ maker, project, id, offer, programs, extr
  * any kind, as `piece` takes it (`collection`, `hasAuthority` false for a Core asset of another collection,
  * `tokenMetadata`, or `compressed` after a `proveLeafIx`).
  */
-export declare function sellToOfferIx({ seller, project, projectState, id, offer, asset, collection, hasAuthority, tokenMetadata: tm, compressed, holders, programs, extra }: {
+export declare function sellToOfferIx({ seller, project, projectState, id, offer, asset, collection, hasAuthority, tokenMetadata: tm, compressed, holders, programs, extra, }: {
     asset: any;
     collection: any;
     compressed: any;
@@ -1566,7 +5200,7 @@ export declare function sellToOfferIx({ seller, project, projectState, id, offer
  * `pda.hold(asset, due)` until it is repaid (`repayIx`, then `releaseIx` sends it home) or, once due, sent to the
  * lender (`releaseIx` with `to` the lender); the loan goes to the borrower. The NFT is any kind, as `sellToOfferIx` takes it.
  */
-export declare function borrowIx({ borrower, project, id, offer, due, asset, collection, hasAuthority, tokenMetadata: tm, compressed, programs, extra }: {
+export declare function borrowIx({ borrower, project, id, offer, due, asset, collection, hasAuthority, tokenMetadata: tm, compressed, programs, extra, }: {
     asset: any;
     borrower: any;
     collection: any;
@@ -1587,23 +5221,26 @@ export declare function borrowIx({ borrower, project, id, offer, due, asset, col
 /**
  * Anyone (`payer`: the borrower, a friend) repays a loan before it is due (`hold` the decoded Hold, with its debt): the
  * debt's `repay` goes to the lender, and the NFT is the borrower's again. Only money moves: anyone then sends the NFT
- * home with `releaseIx` (in the same transaction, or later: a repaid loan's release has no deadline). Free. `extra`: a
+ * home with `releaseIx` (in the same transaction, or later: a repaid loan's release has no deadline). Free. `repay`: the
+ * debt the payer was shown (`hold.debt.repay` as read): any other amount is refused (`TermsChanged`). `extra`: a
  * transfer hook's accounts.
  */
-export declare function repayIx({ payer, project, hold, payerToken, programs, extra }: {
+export declare function repayIx({ payer, project, hold, repay, payerToken, programs, extra }: {
     extra?: never[] | undefined;
     hold: any;
     payer: any;
     payerToken: any;
     programs: any;
     project: any;
+    repay: any;
 }): {
     programId: string;
     keys: any[];
     data: Uint8Array<any>;
 };
-/** What a taker signs: sha256(maker | asset | mint | Borsh(ListingDeal) | Borsh(shares)). */
-export declare function listingTerms(listing: any): Uint8Array<ArrayBuffer>;
+/** What a taker signs: the listing's bytes but `user`, `until` and `stopped` (bytes 129 to 170, what a rental changes).
+ * `listing`: the decoded Listing, or its account's bytes. */
+export declare const listingTerms: (listing: any) => Uint8Array<ArrayBuffer>;
 /**
  * `maker` (any wallet, signing alone) lists an NFT they hold, of any kind (as `piece` takes it), for sale
  * (`deal: { Sell: { price } }`) or for rent (`{ Rent: { price, lasts, max_periods } }`: `price` a period of `lasts`
@@ -1611,7 +5248,7 @@ export declare function listingTerms(listing: any): Uint8Array<ArrayBuffer>;
  * goes to the project until it is sold or the listing is closed. The listing's address names the NFT
  * (`pda.listing(project, asset)`), so a game finds it, and its renter, with one account read.
  */
-export declare function openListingIx({ maker, project, asset, mint, deal, shares, collection, hasAuthority, tokenMetadata: tm, compressed, extra }: {
+export declare function openListingIx({ maker, project, asset, mint, deal, shares, collection, hasAuthority, tokenMetadata: tm, compressed, extra, }: {
     asset: any;
     collection: any;
     compressed: any;
@@ -1636,7 +5273,7 @@ export declare function openListingIx({ maker, project, asset, mint, deal, share
  * take's own accounts come a sale's compressed NFT's proof, then the shares' accounts, then (in `extra`) Core's
  * transfer adapters and any transfer hook's accounts, which the program finds by address after the shares'.
  */
-export declare function takeListingIx({ taker, project, projectState, listing, periods, collection, hasAuthority, tokenMetadata: tm, compressed, holders, programs, takerToken, extra }: {
+export declare function takeListingIx({ taker, project, projectState, listing, periods, collection, hasAuthority, tokenMetadata: tm, compressed, holders, programs, takerToken, extra, }: {
     collection: any;
     compressed: any;
     extra?: never[] | undefined;
@@ -1659,7 +5296,7 @@ export declare function takeListingIx({ taker, project, projectState, listing, p
  * Its maker closes a listing (`listing` the decoded Listing): the NFT goes home. While a rental runs it only stops (no
  * renter takes it again), and the same call once the rental is over takes it home. Free.
  */
-export declare function closeListingIx({ maker, project, listing, collection, hasAuthority, tokenMetadata: tm, compressed, extra }: {
+export declare function closeListingIx({ maker, project, listing, collection, hasAuthority, tokenMetadata: tm, compressed, extra, }: {
     collection: any;
     compressed: any;
     extra?: never[] | undefined;