Partner Accounts

Create and manage sub-accounts with the Go SDK

The PartnerAccountService creates sub-account profiles linked to the authenticated partner. Requires HMAC authentication with the account_creation scope.

Access

import "github.com/limitless-labs-group/limitless-exchange-go-sdk/limitless"

client := limitless.NewClient(
    limitless.WithHMACCredentials(limitless.HMACCredentials{
        TokenID: tokenID,
        Secret:  secret,
    }),
)

// Use client.PartnerAccounts.*

Server wallet mode

Creates a managed Privy wallet for the sub-account. Enables delegated signing — the partner submits unsigned orders and the server signs them.

createServerWallet := true
account, err := client.PartnerAccounts.CreateAccount(ctx, limitless.CreatePartnerAccountInput{
    DisplayName:        "user-alice",
    CreateServerWallet: &createServerWallet,
}, nil)
if err != nil {
    log.Fatal(err)
}

fmt.Println(account.ProfileID)
fmt.Println(account.Account)

New server wallets should be checked with CheckAllowances before the first delegated trade. If retryable targets are missing or failed, call RetryAllowances and poll again.

Allowance recovery

Server-wallet sub-accounts need delegated-trading approvals before they can trade. The partner allowance helpers use the Partner API only:

• CheckAllowances(ctx, profileID) calls GET /profiles/partner-accounts/:profileId/allowances
• RetryAllowances(ctx, profileID) calls POST /profiles/partner-accounts/:profileId/allowances/retry
• both methods require HMAC credentials with account_creation and delegated_signing
• profileID is the child/server-wallet profile id

allowances, err := client.PartnerAccounts.CheckAllowances(ctx, account.ProfileID)
if err != nil {
    log.Fatal(err)
}

if !allowances.Ready {
    retryable := false
    for _, target := range allowances.Targets {
        if target.Retryable &&
            (target.Status == limitless.PartnerAccountAllowanceStatusMissing ||
                target.Status == limitless.PartnerAccountAllowanceStatusFailed) {
            retryable = true
            break
        }
    }

    if retryable {
        allowances, err = client.PartnerAccounts.RetryAllowances(ctx, account.ProfileID)
        if err != nil {
            var rateLimitErr *limitless.RateLimitError
            var conflictErr *limitless.ConflictError
            switch {
            case errors.As(err, &rateLimitErr):
                fmt.Println("retryAfterSeconds is in rateLimitErr.Data")
            case errors.As(err, &conflictErr):
                fmt.Println("Retry already running; poll CheckAllowances again shortly.")
            default:
                log.Fatal(err)
            }
        }
    }
}

for _, target := range allowances.Targets {
    if target.Status == limitless.PartnerAccountAllowanceStatusSubmitted {
        // A sponsored tx/user operation was submitted by this retry request.
        // Poll CheckAllowances again after a short delay to observe confirmed chain state.
    }
}

Recommended partner flow:

1. Poll CheckAllowances(ctx, profileID).
2. If Ready == true, continue.
3. If targets are missing or failed with Retryable == true, call RetryAllowances(ctx, profileID).
4. If retry returns submitted targets, poll CheckAllowances again after a short delay.
5. If retry returns 429, wait retryAfterSeconds.
6. If retry returns 409, wait briefly and call CheckAllowances again.

EOA mode

Creates a profile for an externally-owned address. The end user manages their own keys and signs orders themselves.

EOA mode requires wallet ownership verification headers:

account, err := client.PartnerAccounts.CreateAccount(ctx, limitless.CreatePartnerAccountInput{
    DisplayName: "user-bob",
}, &limitless.CreatePartnerAccountEOAHeaders{
    Account:        "0x5aAeb6053F3E94C9b9A09f33669435E7Ef1BeAed",
    SigningMessage: "0x...",
    Signature:      "0x...",
})

Validation

• DisplayName is optional, max 44 characters. Defaults to the wallet address if omitted.
• Returns 409 Conflict if a profile already exists for the target address.
• Cannot create a sub-account for the partner’s own address.
• The SDK validates DisplayName length locally before sending the request.