GridClient

import { GridClient } from '@sqds/grid';

const client = new GridClient({
  apiKey: 'your-api-key',
  environment: 'sandbox'
});

const state = client.account.get();
client.account.on('change', (state) => console.log('Changed:', state));

get account(): AccountManager;

client.account.on('change', (account) => {
  console.log('Account updated:', account);
});

const current = client.account.get();
console.log(current.accountAddress, current.isConnected);

client.account.set('account-address', 'grid-user-id');

client.account.disconnect();

getAccount(accountAddress): Promise<GetAccountResponse>;

const account = await gridClient.getAccount('account-address');

updateAccount(
   accountAddress,
   request,
admin?): Promise<TransactionResponse>;

const updateTx = await gridClient.updateAccount(accountAddress, {
  policies: {
    threshold: 2
  }
});

const adminUpdateTx = await gridClient.updateAccount(
  accountAddress,
  { policies: { threshold: 1 } },
  true
);

getTransfers(accountAddress, options?): Promise<TransferResponse>;

const transfers = await gridClient.getTransfers(accountAddress);

getTransactions(accountAddress): Promise<GetTransactionsResponse>;

const response = await gridClient.getTransactions(accountAddress);
if (response.data?.transactions) {
  response.data.transactions.forEach(tx => {
    console.log(tx.signature, tx.status);
  });
}

initAuth(request): Promise<InitAuthResponse>;

const response = await gridClient.initAuth({
  email: 'user@example.com'
});

completeAuth(request): Promise<CompleteAuthResponse>;

const sessionSecrets = await gridClient.generateSessionSecrets();
const response = await gridClient.completeAuth({
  otpCode: '123456',
  user: <user object received from initAuth>,
  sessionSecrets: sessionSecrets
});

completeAuthAndCreateAccount(request): Promise<CompleteAuthAndCreateAccountResponse>;

const sessionSecrets = await gridClient.generateSessionSecrets();
const account = await gridClient.completeAuthAndCreateAccount({
  otpCode: '123456',
  user,
  sessionSecrets
});

refreshSession(request): Promise<RefreshSessionResponse>;

const refreshed = await gridClient.refreshSession({
  kmsPayload: { provider: 'privy', session: currentSession },
  encryptionPublicKey: encryptionKey
});

createAccount(input): Promise<CreateAccountResponse>;

const emailAccount = await gridClient.createAccount({
  email: 'user@example.com'
});

const signerAccount = await gridClient.createAccount({
  signer: 'BKKjHs7kKsWFm8GKuFz3HzNKBjH4K4HhjhwxDHrRfKjj'
});

const signerAccount = await gridClient.createAccount({
  signers: [
    {
      address: 'BKKjHs7kKsWFm8GKuFz3HzNKBjH4K4HhjhwxDHrRfKjj',
      permissions: ['CAN_INITIATE', 'CAN_VOTE']
    }
  ],
  threshold: 1,
  timeLock: null,
  adminAddress: null
});

getConfig(): GridApiConfig;

const config = client.getConfig();
console.log(config.environment, config.baseUrl);

requestKycLink(accountAddress, request): Promise<KycLinkResponse>;

const kycLink = await gridClient.requestKycLink(accountAddress, {
  gridUserId: user.gridUserId,
  type: 'individual',
  email: 'user@example.com',
  fullName: 'John Doe',
  endorsements: [],
  redirectUri: 'your-redirect-uri'
});

getKycStatus(accountAddress, kycId): Promise<KycStatusResponse>;

const kycStatus = await gridClient.getKycStatus(accountAddress, kycId);
if (kycStatus.success) {
  console.log(kycStatus.data.status); / 'pending', 'approved', 'rejected'
  console.log(kycStatus.data.verificationLevel); / Verification tier achieved
}

generateSessionSecrets(): Promise<SessionSecrets>;

const sessionSecrets = await gridClient.generateSessionSecrets();

extractSignableTransaction(transactionData): VersionedTransaction;

const preparedTx = await gridClient.prepareArbitraryTransaction(accountAddress, prepareRequest);
const signableTransaction = gridClient.extractSignableTransaction(preparedTx);

setExternallySignedTransaction(transactionData, externallySignedTransaction): TransactionPayload;

transaction.sign([externalSigner]);

const signedTxData = gridClient.setExternallySignedTransaction(
  originalTxData,
  transaction
);

getAccountBalances(accountAddress, queryParams?): Promise<AccountBalancesResponse>;

const balances = await gridClient.getAccountBalances(accountAddress);

getPasskeys(accountAddress): Promise<GetPasskeysResponse>;

const passkeys = await gridClient.getPasskeys(accountAddress);

addPasskey(
   accountAddress,
   request,
queryParams?): Promise<AddPasskeyResponse>;

const passkeyResponse = await gridClient.addPasskey(accountAddress, {
  passkey: {
    address: "2W6cUhpELHYhTi3Cn6SmHfVhJFKgqmUJLJ5V2DQNcaXE",
    role: "secondary",
    permissions: ["CAN_INITIATE", "CAN_VOTE", "CAN_EXECUTE"]
  }
});

removePasskey(
   accountAddress,
   passkeyAddress,
   transactionSigners?,
queryParams?): Promise<RemovePasskeyResponse>;

const removeResponse = await gridClient.removePasskey(
  accountAddress,
  passkeyAddress
);

createPasskeyCredentials(params): Promise<PasskeyCredentialData>;

const credentialData = await gridClient.createPasskeyCredentials({
  env: 'production',
  challenge: 'base64-encoded-challenge',
  slotNumber: '123',
  sessionKey: 'session-public-key-base58',
  expirationInSeconds: '3600',
  appName: 'My App',
  userId: 'user-identifier',
  redirectUrl: 'your-redirect-url'
});

getPasskeyCredentials(params, credentialData?): Promise<PasskeyAssertionResponse>;

const assertion = await gridClient.getPasskeyCredentials({
  env: 'production',
  challenge: 'base64-encoded-challenge',
  slotNumber: '123',
  sessionKey: 'session-public-key-base58',
  expirationInSeconds: '3600',
  appName: 'My App',
  userId: 'user-identifier',
  redirectUrl: 'your-redirect-url'
});
console.log(assertion.response.signature);

extractPasskeyCreateParams(query): PasskeyRequest;

const urlParams = new URLSearchParams(window.location.search);
const passkeyParams = gridClient.extractPasskeyCreateParams(urlParams);

const credentials = await gridClient.createPasskeyCredentials(passkeyParams);

extractPasskeyAuthParams(query): PasskeyRequest;

const urlParams = new URLSearchParams(window.location.search);
const authParams = gridClient.extractPasskeyAuthParams(urlParams);

const assertion = await gridClient.getPasskeyCredentials(authParams);

createPasskeyAccount(params, environment): Promise<CreatePasskeyAccountResponse>;

const sessionKeyObject = {
  key: sessionKeyPubkey,
  expiration: Date.now() + 900000
};

const account = await gridClient.createPasskeyAccount({
  sessionKey: sessionKeyObject,
  slotNumber: 123,
  authenticatorResponse: webauthnResponse,
  adminAddress: 'admin-public-key',
  memo: 'My passkey account'
}, 'sandbox');
console.log('Smart account address:', account.data.address);
console.log('Passkey account:', account.data.passkey.passkeyAccount);
console.log('Session key:', account.data.passkey.sessionKey);

createPasskeySession(params, environment): Promise<CreatePasskeySessionResponse>;

await gridClient.createPasskeySession({
  action: 'create',
  sessionKey: 'session-public-key-base58',
  env: 'production',
}, 'production');

authorizePasskeySession(params, environment): Promise<AuthorizePasskeySessionResponse>;

const authorization = await gridClient.authorizePasskeySession({
  sessionKey: 'public-key-base58',
  metaInfo: {
    appName: 'My App',
    redirectUrl: 'https:/myapp.com/callback'
  },
  baseUrl: 'base-url'
}, 'sandbox');

submitPasskeySession(params, environment): Promise<SubmitPasskeySessionResponse>;

const result = await gridClient.submitPasskeySession({
  authenticatorResponse: <attestationObject from getPasskeySession>,
  sessionKey: 'public-key-base58',
  ceremonyType: 'auth',
  slotNumber: 123
}, 'sandbox');

findPasskeyAccount(params, environment): Promise<FindPasskeyAccountResponse>;

const account = await gridClient.findPasskeyAccount({
  sessionKey: 'public-key-base58',
  authenticatorResponse: <attestationObject from getPasskeySession>
}, 'sandbox');

getPasskeyAccount(passkeyAddress, environment): Promise<GetPasskeyAccountResponse>;

const account = await gridClient.getPasskeyAccount(
  'passkey-account-address',
  'sandbox'
);
console.log(account.data.relyingPartyId);
console.log(account.data.pubkey);
if (account.data.sessionKey) {
  console.log('Session key:', account.data.sessionKey.key);
  console.log('Expires:', account.data.sessionKey.expiration);
}

createPaymentIntent(accountAddress, request): Promise<CreatePaymentIntentResponse>;

const paymentIntent = await gridClient.createPaymentIntent(accountAddress, {
  amount: "100000",
  source: {
    account: accountAddress,
    currency: "usdc"
  },
  destination: {
    address: "3ciascNndLTBrDQXvs8nzZgWAiaL33tGM6fx3zzM7Fxt",
    currency: "usdc"
  }
});
console.log(paymentIntent.data.paymentUrl);

createProposal(accountAddress, request): Promise<CreateProposalResponse>;

const proposal = await client.createProposal(accountAddress, {
  transaction: 'base64-encoded-solana-transaction',
  signer: 'signer-pubkey',
  rentPayer: 'rent-payer-pubkey'
});

voteProposal(
   accountAddress,
   proposalAddress,
request): Promise<VoteProposalResponse>;

const voteResult = await client.voteProposal(
  accountAddress,
  proposalAddress,
  {
    signers: ['signer-pubkey-1', 'signer-pubkey-2'],
    action: 'approve'
  }
);
console.log('Transaction:', voteResult.data.transaction);
console.log('Signers needed:', voteResult.data.transactionSigners);

executeProposal(
   accountAddress,
   proposalAddress,
request): Promise<ExecuteProposalResponse>;

const executeResult = await client.executeProposal(
  accountAddress,
  proposalAddress,
  { signer: 'executor-pubkey' }
);
console.log('Transaction:', executeResult.data.transaction);
console.log('Signatures:', executeResult.data.transactionSignatures);

createSpendingLimit(smartAccountAddress, request): Promise<CreateSpendingLimitResponse>;

const spendingLimitTx = await gridClient.createSpendingLimit(accountAddress, {
  amount: 10000000,
  mint: '4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU',
  period: 'daily',
  spendingLimitSigners: ['limit-signer-address']
});

updateSpendingLimit(
   accountAddress,
   spendingLimitAddress,
request): Promise<SpendingLimitTransactionResponse>;

const updateTx = await gridClient.updateSpendingLimit(
  amount: "5000000",
  spendingLimitSigners: ['signer-address']
);

deleteSpendingLimit(accountAddress, spendingLimitAddress): Promise<SpendingLimitTransactionResponse>;

const deleteTx = await gridClient.deleteSpendingLimit(
  accountAddress,
  spendingLimitAddress
);

useSpendingLimit(
   accountAddress,
   spendingLimitAddress,
request): Promise<SpendingLimitTransactionResponse>;

const limitTx = await gridClient.useSpendingLimit(
  accountAddress,
  spendingLimitAddress,
  {
    amount: 500000000,
    signerAddress: "signer-address",
    recipientAddress: "recipient-address"
  }
);

getSpendingLimit(accountAddress, spendingLimitAddress): Promise<SpendingLimitResponse>;

const spendingLimit = await gridClient.getSpendingLimit(
  accountAddress,
  spendingLimitAddress
);
console.log(spendingLimit.amount);
console.log(spendingLimit.remainingAmount);

getSpendingLimits(accountAddress): Promise<SpendingLimitsResponse>;

const limits = await gridClient.getSpendingLimits(accountAddress);
limits.forEach(limit => {
  console.log(`Limit: ${limit.amount}, Remaining: ${limit.remainingAmount}`);
});

createStandingOrder(accountAddress, request): Promise<CreateStandingOrderResponse>;

const standingOrder = await gridClient.createStandingOrder(accountAddress, {
  amount: "500000",
  gridUserId: "grid-user-id",
  source: {
    account: "source-address",
    currency: "usdc"
  },
  destination: {
    address: "destination-address",
    currency: "usdc"
  },
  frequency: "weekly",
  startDate: "2024-12-02T10:00:00Z",
  endDate: "2025-12-31T23:59:59Z"
});

getStandingOrders(accountAddress, queryParams?): Promise<StandingOrdersResponse>;

const standingOrders = await gridClient.getStandingOrders(accountAddress);

getStandingOrder(accountAddress, standingOrderId): Promise<StandingOrderResponse>;

const order = await gridClient.getStandingOrder(accountAddress, orderId);

createTradeSmartTransaction(accountAddress, request): Promise<CreateTradeSmartTransactionResponse>;

const response = await client.createTradeSmartTransaction(accountAddress, {
  policies: {
    signers: [{ address: 'XXXxx...', permissions: ['CAN_INITIATE', 'CAN_VOTE', 'CAN_EXECUTE'] }],
    threshold: 1
  },
  rules: {
    allowedInputs: [{
      mint: 'So11111111111111111111111111111111111111112',
      allowance: { amount: '1000000000', cadence: 'Daily' }
    }],
    allowedOutputs: ['EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'],
    maxSlippageBps: 100,
    feesBps: 10,
    venue: 'jupiter'
  }
});

getTradeSmartTransactionQuote(
   accountAddress,
   smartTransactionAddress,
request): Promise<TradeSmartTransactionQuoteResponse>;

const quote = await client.getTradeSmartTransactionQuote(
  accountAddress,
  smartTransactionAddress,
  {
    venue: 'jupiter',
    fromMint: 'So11111111111111111111111111111111111111112',
    toMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
    amount: 100000000,
    slippageBps: 50
  }
);

prepareTradeSmartTransaction(
   accountAddress,
   smartTransactionAddress,
   request,
queryParams?): Promise<PrepareTradeSmartTransactionResponse>;

const tx = await client.prepareTradeSmartTransaction(
  accountAddress,
  smartTransactionAddress,
  {
    tradeArgs: {
      type: 'arguments',
      input: 'So11111111111111111111111111111111111111112',
      output: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
      amount: 100000000,
      slippageBps: 50,
      feeBps: 10
    }
  }
);

getTradeSmartTransaction(accountAddress, smartTransactionAddress): Promise<GetTradeSmartTransactionResponse>;

const result = await client.getTradeSmartTransaction(accountAddress, smartTransactionAddress);

prepareArbitraryTransaction(
   accountAddress,
   request,
queryParams?): Promise<TransactionResponse>;

const preparedTx = await gridClient.prepareArbitraryTransaction(accountAddress, {
  transaction: 'base64-encoded-solana-transaction'
});

const signedTx = await gridClient.sign({
  sessionSecrets: sessionSecrets,
  transactionPayload: preparedTx
});

sign(request): Promise<TransactionResult>;

const authResult = await gridClient.completeAuth(payload);
const preparedTx = await gridClient.prepareArbitraryTransaction(accountAddress, {
  transaction: 'base64-encoded-transaction'
});

const signResult = await gridClient.sign({
  sessionSecrets: sessionSecrets,
  transactionPayload: preparedTx,
  session: authResult.authentication
});

signAndSend(request): Promise<TransactionSubmissionResponse>;

const authResult = await gridClient.completeAuth(payload);
const preparedTx = await gridClient.prepareArbitraryTransaction(accountAddress, {
  transaction: 'base64-encoded-transaction'
});

const result = await gridClient.signAndSend({
  sessionSecrets: sessionSecrets,
  transactionPayload: preparedTx,
  session: authResult.authentication,
  address: accountAddress
});

send(request): Promise<TransactionSubmissionResponse>;

const signedTx = await gridClient.sign({ ... });
const result = await gridClient.send({
  signedTransactionPayload: signedTx,
  address: 'account-address'
});

getSessionKeyObject(sessionKeyString, expirationInSeconds): SessionKey;

const sessionKey = gridClient.getSessionKeyObject(
  'base58-encoded-key',
  '900'
);

getEnvironment(): "sandbox" | "production";

const env = gridClient.getEnvironment();
console.log(env); / 'sandbox' or 'production'

requestVirtualAccount(accountAddress, request): Promise<VirtualAccountResponse>;

const virtualAccount = await gridClient.requestVirtualAccount(accountAddress, {
  gridUserId: 'grid-user-id',
  currency: 'usd' as const
});

getVirtualAccounts(accountAddress, queryParams?): Promise<VirtualAccountsResponse>;

const virtualAccounts = await gridClient.getVirtualAccounts(accountAddress);