Configuration

Overview

Configuring autosign requires two main steps: setting up Privy for embedded wallet management and configuring autosign permissions in your InterwovenKitProvider. This guide walks you through both processes.

Prerequisites

Before configuring autosign, ensure you have:

• A Privy account and application ID
• InterwovenKit already integrated into your application
• An understanding of which transaction types you need to auto-sign

Setting Up Privy

Autosign requires Privy to manage embedded wallets. Privy provides secure key management and wallet creation for ghost wallets.

1. Create a Privy Account

   1. Visit Privy’s website and create an account
   2. Create a new application in the Privy dashboard
   3. Copy your application ID from the dashboard
2. Install Privy Dependencies

   Install the required Privy packages in your application. This guide assumes InterwovenKit is already installed:

   npm

   npm install @privy-io/react-auth
   
3. Configure Allowed Domains

   Before configuring your application, set up allowed domains in the Privy dashboard to ensure security and proper functionality:

   1. Access Privy Dashboard: Log in to your Privy account
   2. Click Into Application: Click into the application you would like Privy to work with
   3. Navigate to Allowed Domains: Click App settings on the left sidebar and then click on the Domains tab
   4. Add Domains: Under Allowed Origins, add:
      • Your production domain (e.g., app.example.com)
      • Your development domain (e.g., localhost:3000)
      • Any staging domains you use

   Privy services will only work on domains you’ve explicitly allowed. Add all domains where your application will run, including localhost for development.

4. Configure Privy and Integrate with InterwovenKit

   The following configuration wires Privy into InterwovenKit to enable embedded wallets and autosign:

   1. Wrap your app with PrivyProvider to enable authentication and embedded wallet management.
   2. Use Privy hooks (usePrivy, useLoginWithSiwe, useCreateWallet, useWallets) to access wallet and auth state.
   3. Pass those hooks into InterwovenKitProvider via privyContext.
   4. Enable autosign for supported message types using enableAutoSign.

   Required Configuration for Autosign:

   • appId: Your Privy application ID
   • embeddedWallets.ethereum.createOnLogin: "all-users": Required for autosign. Ensures an embedded (ghost) wallet is created at login. Privy’s default behavior may not create an embedded wallet automatically, which will prevent autosign from working.

   providers.tsx

   import {
     PrivyProvider,
     useCreateWallet,
     useLoginWithSiwe,
     usePrivy,
     useWallets,
   } from '@privy-io/react-auth'
   import {
     InterwovenKitProvider,
     PRIVY_APP_ID,
   } from '@initia/interwovenkit-react'
   
   function InterwovenKitWrapper({ children }) {
     const privy = usePrivy()
     const siwe = useLoginWithSiwe()
     const { createWallet } = useCreateWallet()
     const { wallets } = useWallets()
   
     return (
       <InterwovenKitProvider
         privyContext={{ privy, siwe, createWallet, wallets }}
         // Enables autosign only for default contract execution messages
         enableAutoSign
       >
         {children}
       </InterwovenKitProvider>
     )
   }
   
   export default function Providers() {
     return (
       <PrivyProvider
         appId="YOUR_PRIVY_APP_ID"
         config={{
           appearance: {
             theme: 'dark',
           },
           embeddedWallets: {
             ethereum: { createOnLogin: 'all-users' },
             showWalletUIs: false,
           },
           loginMethodsAndOrder: {
             primary: [`privy:${PRIVY_APP_ID}`, 'detected_ethereum_wallets'],
           },
         }}
       >
         <InterwovenKitWrapper>{/* Your app */}</InterwovenKitWrapper>
       </PrivyProvider>
     )
   }
   

Configuring Autosign Permissions

Choose Your Autosign Mode

Before enabling autosign, decide which mode fits your application:

• Boolean (enableAutoSign)

  • Best for simple, single-chain apps
  • Automatically allows default contract execution messages for the chain
  • Does not allow token transfers, staking, or other non-default messages

• Per-Chain Configuration (enableAutoSign: { "chain-id": ["msg.type.Url", ...] })

  • Required if your app sends tokens, delegates, or uses multiple chains
  • You must explicitly list every allowed message type

If your app does more than basic contract execution calls, you should skip the boolean option and use the per-chain permissions in the Advanced Configuration section.

Most production applications will eventually require the per-chain configuration.

Simple Configuration (Limited)

This option only enables autosign for default contract execution messages and is intentionally restrictive.

<InterwovenKitProvider
  privyContext={{ privy, siwe, createWallet, wallets }}
  enableAutoSign
  // ... other config
>
  {children}
</InterwovenKitProvider>

If you later need to support token transfers, staking, or multiple chains, you must switch from the boolean configuration to the per-chain configuration in the Advanced Configuration section.

When using boolean configuration, InterwovenKit automatically:

• Detects your chain’s VM type
• Grants permission for the appropriate message type:
  • MiniEVM: /minievm.evm.v1.MsgCall
  • MiniWasm: /cosmwasm.wasm.v1.MsgExecuteContract
  • MiniMove: /initia.move.v1.MsgExecute

Advanced Configuration (Explicit Permissions)

For multi-chain applications or when you need custom message types, specify autosign permissions per chain:

<InterwovenKitProvider
  enableAutoSign={{
    'interwoven-1': [
      '/cosmos.bank.v1beta1.MsgSend', // native token transfers
      '/cosmos.staking.v1beta1.MsgDelegate', // staking
    ],
    'evm-1': ['/minievm.evm.v1.MsgCall'],
    'wasm-1': ['/cosmwasm.wasm.v1.MsgExecuteContract'],
    'move-1': ['/initia.move.v1.MsgExecute', '/cosmos.bank.v1beta1.MsgSend'],
  }}
  // ... other config
>
  {children}
</InterwovenKitProvider>

Configuration Format:

The enableAutoSign prop accepts an object where:

• Keys: Chain IDs (strings)
• Values: Arrays of message type URLs (strings)

Common Message Types:

• EVM Chains: /minievm.evm.v1.MsgCall
• Wasm Chains: /cosmwasm.wasm.v1.MsgExecuteContract
• Move Chains: /initia.move.v1.MsgExecute
• Bank Module: /cosmos.bank.v1beta1.MsgSend
• Staking: /cosmos.staking.v1beta1.MsgDelegate

Only grant permissions for message types that your application actually needs. Granting overly broad permissions increases security risk.