Open an account

A margin account is where you hold collateral and borrow USDG from the supply vault. Each address has one cross position, and may open an isolated position for any asset. In this guide you create the account, which costs no ether, and deposit Stock Tokens into it, in the app and then from code.

Before you start#

• A wallet on Robinhood Chain's testnet, chain 46630, that holds a Stock Token. The registry deployments/46630.json lists TSLA and AMZN.
• For the code path, an SDK as in the quickstart and the packages permissionless and viem.

In the app#

Creating the account itself counts nothing. Each smart account then has three sponsored operations, whether or not their calls succeed. After the third, operations are paid from the account's own ether, or you act from your wallet directly (see below). No keeper's, owner's or bidder's call is sponsored.

The margin account is the smart account when the app has a bundler and a sponsor service, and your wallet otherwise.

From code#

The smart account is a SimpleAccount from the registry's factory. The TypeScript SDK reads its address and builds the calls; the sponsor service signs the operations it pays for over ERC-7677, so viem's createPaymasterClient is its client. The bundler and sponsor URLs are the ones your deployment runs, TAPEHOUSE_BUNDLER_URL and TAPEHOUSE_SPONSOR_URL in the app.

import { readFileSync } from 'node:fs'
import { createPublicClient, createWalletClient, defineChain, http, type Hex } from 'viem'
import { createBundlerClient, createPaymasterClient } from 'viem/account-abstraction'
import { privateKeyToAccount } from 'viem/accounts'
import { toSimpleSmartAccount } from 'permissionless/accounts'
import { accounts, CROSS, parseDeployments, sponsorship } from '@tapehouse/sdk'

const deployments = parseDeployments(JSON.parse(readFileSync('deployments/46630.json', 'utf8')))
const rpc = 'https://rpc.testnet.chain.robinhood.com'
const chain = defineChain({
  id: deployments.chainId,
  name: 'Robinhood Chain testnet',
  nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
  rpcUrls: { default: { http: [rpc] } },
})
const client = createPublicClient({ chain, transport: http(rpc) })
const owner = privateKeyToAccount(process.env.PRIVATE_KEY as Hex)
const wallet = createWalletClient({ account: owner, chain, transport: http(rpc) })

const account = await toSimpleSmartAccount({
  client,
  owner,
  factoryAddress: sponsorship.accountFactory(deployments),
  entryPoint: sponsorship.entryPoint(deployments),
})
const bundler = createBundlerClient({
  account,
  client,
  paymaster: createPaymasterClient({ transport: http(process.env.TAPEHOUSE_SPONSOR_URL) }),
  transport: http(process.env.TAPEHOUSE_BUNDLER_URL),
})

const token = deployments.tokens.TSLA
const amount = 10n ** 18n
const deadline = BigInt(Math.floor(Date.now() / 1000) + 600)

const signature = await wallet.signTypedData(
  await sponsorship.permit(client, { token, owner: owner.address, account: account.address, value: amount, deadline }),
)

import { erc20Abi } from 'viem'

const hash = await bundler.sendUserOperation({
  calls: [
    ...sponsorship.pull({ token, owner: owner.address, account: account.address, value: amount, deadline, signature }),
    sponsorship.asCall({
      address: token,
      abi: erc20Abi,
      functionName: 'approve',
      args: [deployments.tapehouse.MarginAccounts, amount],
    }),
    sponsorship.asCall(accounts.deposit(deployments, { position: CROSS, token, amount, account: account.address })),
  ],
})
await bundler.waitForUserOperationReceipt({ hash })

const held = await accounts.collateral(client, deployments, account.address, CROSS, token)
const { equity, requirement } = await accounts.health(client, deployments, account.address, CROSS)

An isolated position is named by the asset's symbol: pass toBytes32('TSLA') as the position instead of CROSS. An asset sits in one position of an account at a time, and an isolated position is margined alone, so it gets no diversification and its loss never reaches the cross position.

From a wallet alone#

Without a smart account, your wallet is the margin account. It approves the token and deposits, or deposits with a permit in one transaction (accounts.depositWithPermit). Ether goes in as WETH: accounts.wrap wraps it for an account first.

const approve = await wallet.writeContract({
  address: token,
  abi: erc20Abi,
  functionName: 'approve',
  args: [deployments.tapehouse.MarginAccounts, amount],
})
await client.waitForTransactionReceipt({ hash: approve })
const deposit = await wallet.writeContract(
  accounts.deposit(deployments, { position: CROSS, token, amount, account: owner.address }),
)

What to expect#

• Deposits and repayments stay open whatever the band, the session and the guardian. A deposit stops at its cap, at the issuer's pause or blocklist, and while USDG is paused.
• Stock Tokens count at the low edge of their band. WETH counts for 80% of its Chainlink price, and USDG at par. A position holding USDG does not borrow: it repays with that USDG first.
• Authorization is separate. accounts.setAuthorization(deployments, address, true) lets another address act for the account, and accounts.setMandate gives an agent a bounded authority. See mandates.

Errors you may hit#

Decode a revert with decodeRevert in TypeScript, sdk.DecodeRevert in Go and Error::Revert in Rust.

Next#

• Borrow with the liquidation price in front of you.
• Sponsor service and the sponsor paymaster.
• The margin accounts.