Squads Protocol Multisig

// Create multisig
const multisig = await agent.createSquadsMultisig(
  new PublicKey("creator-address")
);

// Deposit funds
const deposit = await agent.depositToMultisig(
  1.5  // amount in SOL
);

// Transfer from multisig
const transfer = await agent.transferFromMultisig(
  1.0,  // amount
  new PublicKey("recipient")
);

"Create a 2-of-2 multisig with me"

"Deposit 1 SOL to our multisig"

"Transfer 0.5 SOL from multisig to address"

"Approve pending proposal"

{
  "creator": "creator-public-key"
}

{
  "amount": 1.5
}

{
  "amount": 1.0,
  "recipient": "recipient-address"
}

async function create_squads_multisig(
  agent: SolanaAgentKit,
  creator: PublicKey
): Promise<string>

async function deposit_to_multisig(
  agent: SolanaAgentKit,
  amount: number,
  vaultIndex?: number,
  mint?: PublicKey
): Promise<string>

async function create_proposal(
  agent: SolanaAgentKit,
  transactionIndex?: number | bigint
): Promise<string>

async function approve_proposal(
  agent: SolanaAgentKit,
  transactionIndex?: number | bigint
): Promise<string>

async function reject_proposal(
  agent: SolanaAgentKit,
  transactionIndex?: number | bigint
): Promise<string>

async function transfer_from_multisig(
  agent: SolanaAgentKit,
  amount: number,
  to: PublicKey,
  vaultIndex?: number = 0,
  mint?: PublicKey
): Promise<string>

async function execute_transaction(
  agent: SolanaAgentKit,
  transactionIndex?: number | bigint
): Promise<string>

// 1. Create multisig
const multisig = await create_squads_multisig(
  agent,
  new PublicKey("creator")
);

// 2. Deposit funds
const deposit = await deposit_to_multisig(
  agent,
  1.5  // SOL amount
);

// 3. Create transfer
const transfer = await transfer_from_multisig(
  agent,
  1.0,  // amount
  new PublicKey("recipient")
);

// 4. Create proposal
const proposal = await create_proposal(agent);

// 5. Approve proposal
const approval = await approve_proposal(agent);

// 6. Execute transaction
const execution = await execute_transaction(agent);

// Deposit SPL tokens
const tokenDeposit = await deposit_to_multisig(
  agent,
  100,
  0,  // vault index
  new PublicKey("token-mint")
);

// Transfer SPL tokens
const tokenTransfer = await transfer_from_multisig(
  agent,
  50,
  new PublicKey("recipient"),
  0,  // vault index
  new PublicKey("token-mint")
);

// Get current transaction index
const multisigInfo = await Multisig.fromAccountAddress(
  agent.connection,
  multisigPda
);
const currentIndex = Number(multisigInfo.transactionIndex);

// Use specific or current index
const transactionIndex = specificIndex || BigInt(currentIndex);

try {
  const result = await function();
} catch (error) {
  throw new Error(`Operation failed: ${error.message}`);
}

interface MultisigParams {
  threshold: number;        // Always 2 for 2-of-2
  members: {
    key: PublicKey;
    permissions: number;
  }[];
  timeLock?: number;       // Optional timelock
}

interface DepositParams {
  amount: number;          // Amount to deposit
  vaultIndex?: number;     // Optional vault index
  mint?: PublicKey;        // Optional SPL token mint
}

interface TransferParams {
  amount: number;          // Amount to transfer
  recipient: PublicKey;    // Recipient address
  vaultIndex?: number;     // Optional vault index
  mint?: PublicKey;        // Optional SPL token mint
}

const proposal = await agent.createMultisigProposal();

const approval = await agent.approveMultisigProposal(
  proposalIndex  // Optional
);

const execution = await agent.executeMultisigTransaction(
  proposalIndex  // Optional
);

const permissions = multisig.types.Permissions.all();
// Includes:
// - INITIATE
// - VOTE
// - EXECUTE
// - CANCEL

try {
  const tx = await agent.createMultisigProposal();
} catch (error) {
  if (error.message.includes("insufficient approvals")) {
    // Handle approval issues
  } else if (error.message.includes("already executed")) {
    // Handle duplicate execution
  }
}

{
  status: "success",
  message: "Operation completed successfully",
  transaction: "transaction-signature",
  // Additional operation-specific data
}

{
  status: "error",
  message: "Error message",
  code: "ERROR_CODE"
}