> For the complete documentation index, see [llms.txt](https://nomos-docs.gitbook.io/v1/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://nomos-docs.gitbook.io/v1/nomos-sdk/multisig.md).

# Multisig

## Initialization

#### Init

```typescript
init(provider: SigningCosmWasmClient, multisig: string): Promise<void>
```

This method receives the provider used, and the multisig the user wants to connect to.

#### Create proposal

```typescript
createProposal(args: {
    messages: unknown[];
    description: string;
    manualExecution?: boolean;
    from: string;
}): Promise<{
    proposal: string | undefined;
    transactionHash: string;
    events: readonly Event[];
}>
```

This method creates a new proposal on the multisig. It receives as arguments an object containing the following fields:

* messages: an array of json serializable objects that contain messages to execute by the multisig.
* description: a description for the proposal
* manualExecution: an optional field that when set to true it doesnt execute the proposal once its reached minimum approval.
* from: the provider account that executes the transaction

This method return object contains a field called "proposal" which contains the proposal ID in the multisig.

#### Vote Proposal

```typescript
voteProposal(args: {
    proposal: string;
    vote: VoteOption;
    from: string;
}): Promise<{
    status: string | undefined;
    transactionHash: string;
    events: readonly Event[];
}>
```

This method creates a vote on a proposal. The vote must be made by a member of the multisig. It receives an object with the following parameters:

* proposal: the proposal ID in the multisig
* vote: VoteOption that could be YES or NO, "1" or "0" respectively.
* from: the provider address to send the transaction from

It returns an object with a field called "status" which returns the proposal status.

#### Execute Proposal

```typescript
executeProposal(args: {
    proposal: string;
    from: string;
}): Promise<{
    status: string | undefined;
    transactionHash: string;
    events: readonly Event[];
}>
```

This method is used to execute proposal that were created with the "manualExecution" field set to true. Otherwise, this function will fail. It receives as parameter an object with these fields:

* proposal: Proposal ID to execute
* from: the account used by the provider

#### Propose IBC Transfer

```typescript
proposeIBCTransfer(args: {
    from: string;
    channel: string;
    to: string;
    amount: string;
    description?: string;
    manualExecution?: boolean;
    timestamp?: string;
}): Promise<{
    proposal: string | undefined;
    transactionHash: string;
    events: readonly Event[];
}>
```

This method creates an IBC transfer proposal. Its just like a normal proposal but it abstracts the complexities of the IBC message. The fields it receives are:

* from: account to use by provider
* channel: channel used by the ibc transfer
* to: the account to transfer the funds to
* amount: the amount of funds to transfer (native tokens)
* description: the description of the proposal. If not provided it creates a default description of the action
* manualExecution: see create proposal.
* timestamp: TODO.

#### Propose Add member

```typescript
proposeAddMembers(args: {
    new_members: string[];
    from: string;
    description?: string;
    manualExecution?: boolean;
}): Promise<{
    proposal: string | undefined;
    transactionHash: string;
    events: readonly Event[];
}>
```

This function creates a simple proposal to reconfigure the multisig. It fetches current configuration (members and approval) and adds the new members to the array. If the new members are already on the multisig it throws an error.

* new\_members: array of addresses of members to add.
* from: user account to send the transaction from.
* description: if not set it adds a default description
* manualExecution: see create proposal

#### Propose Remove member

```typescript
proposeRemoveMembers(args: {
    removed: string[];
    from: string;
    description?: string;
    manualExecution?: boolean;
}): Promise<{
    proposal: string | undefined;
    transactionHash: string;
    events: readonly Event[];
}>
```

This function creates a simple proposal to reconfigure the multisig. It fetches current configuration (members and approval) and removes the ones from the previous configuration. If the removed members are not present on the multisig it throws an error.

* removed: array of addresses of members to remove.
* from: user account to send the transaction from.
* description: if not set it adds a default description
* manualExecution: see create proposal

#### Propose Minimum approval

```typescript
proposeMinimumApproval(args: {
    newApproval: number;
    from: string;
    description?: string;
    manualExecution?: boolean;
}): Promise<{
    proposal: string | undefined;
    transactionHash: string;
    events: readonly Event[];
}>
```

This function creates a simple proposal to reconfigure the multisig. It fetches current configuration (members and approval) and adds a new minimum approval. If its larger than the current amount of members it throws an error.

* newApproval: new minimum approval.
* from: user account to send the transaction from.
* description: if not set it adds a default description
* manualExecution: see create proposal

#### Get configuration

```typescript
getConfiguration(): Promise<{
    approval: number;
    members: string[];
}>
```

This function returns the current multisig configuration. It doesn receive parametres. Its return values are:

* members: Current members of the multisig.
* approval: Current minimum approval


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://nomos-docs.gitbook.io/v1/nomos-sdk/multisig.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.