# Actions

<details>

<summary>getAccount</summary>

```typescript
const account = getAccount();

export type Account = {
  triaName: string | null;
  evm: {
    address: string;
  };
};
```

</details>

<details>

<summary>disconnect</summary>

```typescript
await disconnect();
```

</details>

<details>

<summary>signMessage</summary>

```typescript
signMessage(
  calldata: SignMessageParams,
  dappDetails?: dappDetails,
  authUrl: string = triaAuthUrl,
  environment: ENV = 'mainnet'
): Promise<StringDataResponse>;

type SignMessageParams = {
  message: string; // eg. Sign in with Tria
  chainName: string; // eg. POLYGON
};

type dappDetails = {
  dappDomain?: string;
  dappLogo?: string;
};

export type StringDataResponse = {
  success: boolean;
  data?: string;
  message?: string;
  error?: any;
};
```

</details>

<details>

<summary>send</summary>

```typescript
send(
  calldata: SendParams,
  dappDetails?: dappDetails,
  authUrl: string = triaAuthUrl,
  environment: ENV = 'mainnet'
): Promise<TxnResponse>

type SendParams = {
  amount: number;
  recepientAddress: string;
  chainName: string;
  tokenAddress?: string;
};

export type dappDetails = {
  dappDomain?: string;
  dappLogo?: string;
};

type TxnResponse {
  success: boolean;
  data?: TxnDataResponse;
  message?: string;
  error?: any;
}

type TxnDataResponse = {
  txnId: string;
  viewInExplorer: string;
  wait?: Function;
};
```

</details>

<details>

<summary>readContract</summary>

```typescript
readContract(
  params: ReadContractParams
): Promise<ReadContractResponse>

type ReadContractParams = {
  chainName: string;
  contractDetails: ContractDetails;
};

type ContractDetails = {
  contractAddress: string;
  abi: Object[];
  functionName: string;
  args: any[];
  value?: number;
};

type ReadContractResponse = {
  success: boolean;
  data?: any;
  message?: string;
  error?: any;
};
```

</details>

<details>

<summary>writeContract</summary>

```typescript
writeContract(
  calldata: WriteContractParams,
  dappDetails?: dappDetails,
  authUrl: string = triaAuthUrl,
  environment: ENV = 'mainnet'
): Promise<TxnResponse>

type WriteContractParams = {
  chainName: string;
  payToken?: {
    tokenAddress: string;
    amount: number;
  };
  contractDetails: ContractDetails;
};

type ContractDetails = {
  contractAddress: string;
  abi: Object[];
  functionName: string;
  args: any[];
  value?: number;
  enableTriaName?: boolean; // true if wanna pass triaName in args[]
};

export type dappDetails = {
  dappDomain?: string;
  dappLogo?: string;
};

type TxnResponse {
  success: boolean;
  data?: TxnDataResponse;
  message?: string;
  error?: any;
}

type TxnDataResponse = {
  txnId: string;
  viewInExplorer: string;
  wait?: Function;
};
```

</details>

<details>

<summary>sendNft</summary>

```typescript
sendNft(
  calldata: SendNftParams,
  dappDetails?: dappDetails,
  authUrl: string = triaAuthUrl,
  environment: ENV = 'mainnet'
): Promise<TxnResponse>;

type SendNftParams = {
  chainName: string;
  recipientTriaName: string;
  nftDetails: {
    type: string;
    tokenAddress: string;
    tokenId: string;
    amount: number;
  };
};

type dappDetails = {
  dappDomain?: string;
  dappLogo?: string;
};

type TxnResponse {
  success: boolean;
  data?: TxnDataResponse;
  message?: string;
  error?: any;
}

type TxnDataResponse = {
  txnId: string;
  viewInExplorer: string;
  wait?: Function;
};
```

</details>

<details>

<summary>encrypt</summary>

```typescript
encrypt(
  calldata: EncryptParams,
  dappDetails?: dappDetails,
  authUrl: string = triaAuthUrl,
  environment: ENV = 'mainnet'
): Promise<StringDataResponse>

type EncryptParams = {
  chainName: string;
  data: string;
  version?: string | 'x25519-xsalsa20-poly1305';
};

type dappDetails = {
  dappDomain?: string;
  dappLogo?: string;
};

type StringDataResponse = {
  success: boolean;
  data?: string;
  message?: string;
  error?: any;
};
```

</details>

<details>

<summary>decrypt</summary>

```typescript
decrypt(
  calldata: DecryptParams,
  dappDetails?: dappDetails,
  authUrl: string = triaAuthUrl,
  environment: ENV = 'mainnet'
): Promise<StringDataResponse>

type DecryptParams = {
  chainName: string;
  encryptedData: string;
};

type dappDetails = {
  dappDomain?: string;
  dappLogo?: string;
};

type StringDataResponse = {
  success: boolean;
  data?: string;
  message?: string;
  error?: any;
};
```

</details>

<details>

<summary>approve</summary>

```typescript
approve (
  config: Config,
  calldata: ApproveParams,
  authUrl: string = triaAuthUrl,
  environment: ENV = "mainnet",
  aa?: AaDetails,
  dappDetails?: dappDetails
): Promise<TxnResponse>;
```

```typescript
type ApproveParams = {
  payload: Approve;
  chain?: ChainData;
};
```

```typescript
type Approve = {
    tokenAddress: string;
    amount: number;
    spender: string;
    infinite?: boolean;
}
```

</details>

<details>

<summary>checkTokenAllowance</summary>

```typescript
checkTokenAllowance ({
  config,
  calldata,
  environment = "mainnet",
}: {
  config: Config;
  calldata: CheckTokenAllowanceParams;
  environment: ENV;
}): Promise<CheckTokenAllowanceResponse>;
```

```typescript
type CheckTokenAllowanceParams = {
  triaName: string;
  payload: Approve;
  chain: ChainData;
};
```

```typescript
type Approve = {
    tokenAddress: string;
    amount: number;
    spender: string;
    infinite?: boolean;
}
```

```typescript
type CheckTokenAllowanceResponse = {
    success: boolean;
    allowance?: boolean;
    message?: string;
}
```

</details>

<details>

<summary>broadcastTransaction</summary>

```typescript
broadcastTransaction (
  config: Config,
  calldata: BroadcastTxnParams,
  authUrl: string = triaAuthUrl,
  environment: ENV = "mainnet",
  aa?: AaDetails,
  dappDetails?: dappDetails
): Promise<TxnResponse>;
```

```typescript
type BroadcastTxnParams = {
    txnObject: Object;
    chain?: ChainData;
};
```

</details>

<details>

<summary>getBridgeQuote</summary>

```typescript
getBridgeQuote (
  calldata: BridgeParams,
): Promise<GetBridgeQuoteResponse>;
```

```typescript
type BridgeParams = {
    src: {
        chain: ChainData;
        token: {
            address: string;
            amountInUnits: string | "auto";
            amount?: number;
            decimals?: number;
        };
        senderAddress: string;
    };
    dest: {
        chainId: number;
        token: {
            address: string;
            amountInUnits: string | "auto";
            amount?: number;
            decimals?: number;
        };
        recipientAddress: string;
        externalCall?: {
            version: "evm_1" | "solana_1";
            fields: {
                to?: string;
                data?: string;
                gas?: number;
                calldata?: string;
            };
        };
    };
};
```

```typescript
type GetBridgeQuoteResponse = {
    success: boolean;
    data?: {
        estimation: {
            srcChainTokenIn: {
                address: string;
                name: string;
                symbol: string;
                decimals: number;
                amount: string;
                approximateOperatingExpense: string;
                mutatedWithOperatingExpense: true;
            };
            srcChainTokenOut: {
                address: string;
                name: string;
                symbol: string;
                decimals: number;
                amount: string;
                maxRefundAmount: string;
            };
            dstChainTokenOut: {
                address: string;
                name: string;
                symbol: string;
                decimals: number;
                amount: string;
                recommendedAmount: string;
                withoutAdditionalTakerRewardsAmount: string;
                maxTheoreticalAmount: string;
            };
            recommendedSlippage: number;
            costsDetails: [string];
        };
        prependedOperatingExpenseCost: string;
        tx: {
            allowanceTarget: string;
            allowanceValue: string;
        };
        order: {
            approximateFulfillmentDelay: number;
        };
        fixFee: string;
        userPoints: number;
        integratorPoints: number;
        actualUserPoints: number;
        actualIntegratorPoints: number;
    };
    message?: string;
};
```

</details>

<details>

<summary>createBridgeTxn</summary>

```typescript
createBridgeTxn (
  calldata: BridgeParams,
): Promise<CreateBridgeTxnResponse>;
```

```typescript
type CreateBridgeTxnResponse = {
    success: boolean;
    data?: {
        estimation: {
            srcChainTokenIn: {
                address: string;
                name: string;
                symbol: string;
                decimals: number;
                amount: string;
                approximateOperatingExpense: string;
                mutatedWithOperatingExpense: true;
            };
            srcChainTokenOut: {
                address: string;
                name: string;
                symbol: string;
                decimals: number;
                amount: string;
                maxRefundAmount: string;
            };
            dstChainTokenOut: {
                address: string;
                name: string;
                symbol: string;
                decimals: number;
                amount: string;
                recommendedAmount: string;
                withoutAdditionalTakerRewardsAmount: string;
                maxTheoreticalAmount: string;
            };
            recommendedSlippage: number;
            costsDetails: [string];
        };
        tx: {
            to: string;
            data: string;
            value: string;
            gasLimit: number;
        };
        orderId: string;
        prependedOperatingExpenseCost: string;
        order: {
            approximateFulfillmentDelay: number;
        };
        fixFee: string;
        userPoints: number;
        integratorPoints: number;
        actualUserPoints: number;
        actualIntegratorPoints: number;
    };
    message?: string;
};
```

</details>

<details>

<summary>cancelBridgeTxn</summary>

```typescript
cancelBridgeTxn (
  calldata: CancelBridgeTxnParams,
): Promise<CancelBridgeTxnResponse>;
```

```typescript
type CancelBridgeTxnParams = {
  orderId: string;
};
```

```typescript
type CancelBridgeTxnResponse = {
  success: boolean;
  data?: {
    to: string;
    data: string;
    value: string;
    chainId: number;
    from: string;
    cancelBeneficiary: string;
  };
  message?: string;
};
```

</details>

<details>

<summary>createSolanaCalldata</summary>

```typescript
createSolanaCalldata (
  instructionsData: PlainInstructionData[]
): Promise<{ data: { calldata: string }, success: boolean }>;
```

Refer [How to create Debridge Solana Calldata](/reference/how-to-create-debridge-solana-calldata.md) to understand better.

```typescript
/**
 * Substitutes amount at offset with `walletBalance(accounts[account_index]) - subtraction`
 */
export type AmountSubstitution = {
  /**
   * big or little endian
   */
  is_big_endian: boolean;
  /**
   * At what offset substitution should be done
   */
  offset: number;
  /**
   * index of account in TransactionInstruction.keys to get balance for
   */
  account_index: number;
  /**
   * Amount to deduct from wallet balance
   */
  subtraction: number;
};

/**
 * Since we don't know submissionAuth at the moment of calldata preparation we can prepare substitution to replace
 * account at `index` with actual ATA(submissionAuth, tokenMint) during execution
 */
export type WalletSubstitution = {
  /**
   * Token mint to calculate ATA for
   */
  token_mint: string;
  /**
   * Account at this index will be replaced with ATA(submissionAuth, tokenMint) during execution
   */
  index: number;
};

/** Please note that all PublicKey are formatted in string (toBase58), expense and reward are also passed in string, and internally we format it back to BigInt, so please pass the values accordingly.*/
export type PlainInstructionData = {
  instruction: {
    keys: { pubkey: string /** base 58*/; isSigner: boolean; isWritable: boolean }[];
    programId: string; // base58
    data: string;
  };
  substitutions?: {
    amountSubstitutions?: AmountSubstitution[];
    walletSubstitutions?: WalletSubstitution[];
  };
  expense?: string; // should be in BigInt value converted to string
  reward?: string; // should be in BigInt value converted to string
  isInMandatoryBlock?: boolean;
};
```

</details>

<details>

<summary>signAndSendTransaction [SOLANA]</summary>

```typescript
signAndSendTransaction = async ({
  chainName,
  transaction,
  authUrl = triaAuthUrl,
}: // dappDetails,
{
  chainName: "SOLANA" | string;
  transaction: any; // Solana web3 Transaction
  authUrl: string;
  dappDetails?: dappDetails;
}): Promise<StringDataRespo
```

</details>

## Types

<details>

<summary>ChainData</summary>

```typescript
type ChainData = {
    chainName?: string;
    customChain?: CustomChainData;
};
```

```typescript
type CustomChainData = {
    type?: "EVM" | "SOL";
    chainId: number;
    rpcUrl: string;
    currencySymbol?: string;
    currencyName?: string;
    chainName?: string;
    chainLogo?: string;
    explorerUrl?: string;
};
```

</details>

<details>

<summary>BridgeParams</summary>

```typescript
type BridgeParams = {
    src: {
        chain: ChainData;
        token: {
            address: string;
            amountInUnits: string | "auto";
            amount?: number;
            decimals?: number;
        };
        senderAddress: string;
    };
    dest: {
        chainId: number;
        token: {
            address: string;
            amountInUnits: string | "auto";
            amount?: number;
            decimals?: number;
        };
        recipientAddress: string;
        externalCall?: {
            version: "evm_1" | "solana_1";
            fields: {
                to?: string;
                data?: string;
                gas?: number;
                calldata?: string;
            };
        };
    };
};
```

</details>

## Steps to integrate bridge:

1. Use the getQuoteBridge function to get the quote for erc20 tokens and their allowance target and value.
2. Use this this allowance target and value, to checkTokenAllowance, and approve for erc20 token
3. Use the createBridgeTxn to get the txn object for the bridge txn
4. Use the broadcastTransaction function to sign and send this txn object on-chain.
5. To cancel a txn, use the cancelBridgeTxn with the orderId returned in the createBridgeTxn response


---

# Agent Instructions: 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:

```
GET https://docs-priv.tria.so/reference/onboarding-and-wallet-sdk/tria-sdk-connect/actions.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.