GridClient

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

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

createAccount(input): Promise<GridResponse<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,
  time_lock: null,
  admin_address: null
});

getAccount(accountAddress): Promise<GridResponse<GetAccountResponse>>;

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

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

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

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

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

const balances = await gridClient.getAccountBalances(accountAddress);

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

const transfers = await gridClient.getTransfers(accountAddress);

initAuth(request): Promise<GridResponse<InitAuthResponse>>;

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

completeAuth(request): Promise<GridResponse<CompleteAuthResponse>>;

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

completeAuthAndCreateAccount(request): Promise<GridResponse<CompleteAuthAndCreateAccountResponse>>;

const sessionSecrets = await gridClient.generateSessionSecrets();

const account = await gridClient.completeAuthAndCreateAccount({
  otpCode: '123456',
  user: <user object received from createAccount>,
  sessionSecrets: sessionSecrets
});

refreshSession(request): Promise<GridResponse<RefreshSessionResponse>>;

const refreshRequest: RefreshSessionRequest = {
  kms_payload: {
    provider: 'privy',
    session: {
      user_id: 'user-id',
      session: currentSession,
      token: 'jwt-token',
      privy_access_token: 'access-token',
      refresh_token: 'refresh-token'
    }
  },
  encryption_public_key: encryptionKey
};

const response = await gridClient.refreshSession(refreshRequest);
if (response.success) {
  console.log('Session refreshed successfully');
}

getContext(): GridClientContext;

const context = gridClient.getContext();

requestKycLink(accountAddress, request): Promise<GridResponse<KycLink>>;

const kycLink = await gridClient.requestKycLink(accountAddress, {
  grid_user_id: user.grid_user_id,
  type: 'individual',
  email: 'user@example.com',
  full_name: 'John Doe',
  endorsements: [],
  redirect_uri: 'https:/myapp.com/kyc-complete'
});

getKycStatus(accountAddress, kycId): Promise<GridResponse<KycStatusData>>;

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): GridResponse<TransactionPayload>;

transaction.sign([externalSigner]); 

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

getPasskeys(accountAddress): Promise<GridResponse<GetPasskeysResponse>>;

const passkeys = await gridClient.getPasskeys(accountAddress);

addPasskey(
   accountAddress, 
   request, 
queryParams?): Promise<GridResponse<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<GridResponse<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: 'https:/myapp.com/callback'
});

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: 'https:/myapp.com/callback'
});
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);

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<GetPasskeySessionResponse>;

const account = await gridClient.getPasskeyAccount(
  'passkey-account-address',
  'sandbox'
);

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

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

createSpendingLimit(smartAccountAddress, request): Promise<GridResponse<CreateSpendingLimitResponsePayload>>;

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

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

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

deleteSpendingLimit(accountAddress, spendingLimitAddress): Promise<GridResponse<SpendingLimitResponsePayload>>;

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

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

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

getSpendingLimit(accountAddress, spendingLimitAddress): Promise<GridResponse<SpendingLimitData>>;

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

getSpendingLimits(accountAddress): Promise<GridResponse<SpendingLimitData[]>>;

const response = await gridClient.getSpendingLimits(accountAddress);
if (response.success && response.data) {
  response.data.forEach(limit => {
    console.log(`Limit: ${limit.amount}, Remaining: ${limit.remaining_amount}`);
  });
}

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

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

getStandingOrders(accountAddress, queryParams?): Promise<GridResponse<StandingOrder[]>>;

const standingOrders = await gridClient.getStandingOrders(accountAddress);

getStandingOrder(accountAddress, standingOrderId): Promise<GridResponse<StandingOrder>>;

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

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

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

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

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.data,
  session: authResult.data.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.data,
  session: authResult.data.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'
);

requestVirtualAccount(accountAddress, request): Promise<GridResponse<VirtualAccount>>;

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

getVirtualAccounts(accountAddress, queryParams?): Promise<GridResponse<VirtualAccount[]>>;

const virtualAccounts = await gridClient.getVirtualAccounts(accountAddress);