ic-solana-provider.did

type Account = record {
  executable : bool;
  owner : blob;
  lamports : nat64;
  data : blob;
  rentEpoch : nat64;
};
type Auth = variant { RegisterProvider; Manage };
type HttpRequest = record {
  url : text;
  method : text;
  body : blob;
  headers : vec record { text; text };
};
type HttpResponse = record {
  body : blob;
  headers : vec record { text; text };
  status_code : nat16;
};
type InitArgs = record {
  schnorr_key : opt text;
  managers : opt vec principal;
  demo : opt bool;
};
type Legacy = variant { legacy };
type MessageHeader = record {
  numReadonlySignedAccounts : nat8;
  numRequiredSignatures : nat8;
  numReadonlyUnsignedAccounts : nat8;
};
type Metrics = record {
  cyclesWithdrawn : nat;
  errUnauthorized : vec record { text; nat };
  auths : vec record { text; nat };
  responses : vec record { record { text; text; text }; nat64 };
  errNoPermission : nat64;
  inconsistentResponses : vec record { record { text; text }; nat64 };
  cyclesCharged : vec record { record { text; text }; nat };
  requests : vec record { record { text; text }; nat64 };
  errHttpOutcall : vec record { record { text; text }; nat64 };
  errHostNotAllowed : vec record { text; nat64 };
};
type ParsedAccount = record { space : nat64; parsed : text; program : text };
type ParsedInstruction = record {
  stackHeight : opt nat32;
  programId : text;
  parsed : blob;
  program : text;
};
type RegisterProviderArgs = record {
  id : text;
  url : text;
  auth : opt RpcAuth;
};
type Result = variant { Ok : text; Err : RpcError };
type Result_1 = variant { Ok : opt Account; Err : RpcError };
type Result_2 = variant { Ok : nat64; Err : RpcError };
type Result_3 = variant { Ok; Err : TransactionError };
type Result_4 = variant { Ok : vec opt TransactionStatus; Err : RpcError };
type Result_5 = variant { Ok : UiTokenAmount; Err : RpcError };
type Result_6 = variant {
  Ok : TaggedEncodedConfirmedTransactionWithStatusMeta;
  Err : RpcError;
};
type Reward = record {
  lamports : int64;
  commission : opt nat8;
  pubkey : text;
  reward_type : opt RewardType;
  post_balance : nat64;
};
type RewardType = variant { Fee; Rent; Voting; Staking };
type RpcAuth = variant {
  QueryParam : record { value : text; name : text };
  BearerToken : record { token : text };
  PathSegment : record { segment : text };
  HeaderParam : record { value : text; name : text };
};
type RpcError = variant {
  Text : text;
  ParseError : text;
  RpcResponseError : record { code : int64; data : opt text; message : text };
  RpcRequestError : text;
};
type SendTransactionRequest = record {
  instructions : vec text;
  recent_blockhash : opt text;
};
type TaggedEncodedConfirmedTransactionWithStatusMeta = record {
  transaction : TaggedEncodedTransactionWithStatusMeta;
  slot : nat64;
  blockTime : opt int64;
};
type TaggedEncodedTransaction = variant {
  json : TaggedUiTransaction;
  accounts : UiAccountsList;
  legacyBinary : text;
  binary : record { text; TransactionBinaryEncoding };
};
type TaggedEncodedTransactionWithStatusMeta = record {
  meta : opt TaggedUiTransactionStatusMeta;
  transaction : TaggedEncodedTransaction;
  version : opt TaggedTransactionVersion;
};
type TaggedTransactionVersion = variant { legacy : Legacy; number : nat8 };
type TaggedUiInnerInstructions = record {
  instructions : vec TaggedUiInstruction;
  index : nat8;
};
type TaggedUiInstruction = variant {
  compiled : UiCompiledInstruction;
  parsed : TaggedUiParsedInstruction;
};
type TaggedUiMessage = variant { raw : UiRawMessage; parsed : UiParsedMessage };
type TaggedUiParsedInstruction = variant {
  partiallyDecoded : UiPartiallyDecodedInstruction;
  parsed : ParsedInstruction;
};
type TaggedUiTransaction = record {
  message : TaggedUiMessage;
  signatures : vec text;
};
type TaggedUiTransactionStatusMeta = record {
  err : opt TransactionError;
  fee : nat64;
  status : Result_3;
  preBalances : vec nat64;
  postTokenBalances : opt vec UiTransactionTokenBalance;
  innerInstructions : opt vec TaggedUiInnerInstructions;
  postBalances : vec nat64;
  loadedAddresses : opt UiLoadedAddresses;
  rewards : opt vec Reward;
  logMessages : opt vec text;
  returnData : opt UiTransactionReturnData;
  preTokenBalances : opt vec UiTransactionTokenBalance;
  computeUnitsConsumed : opt nat64;
};
type TransactionBinaryEncoding = variant { Base58; Base64 };
type TransactionConfirmationStatus = variant {
  Finalized;
  Confirmed;
  Processed;
};
type TransactionError = variant {
  InvalidAccountForFee;
  AddressLookupTableNotFound;
  MissingSignatureForFee;
  WouldExceedAccountDataBlockLimit;
  AccountInUse;
  DuplicateInstruction : nat8;
  AccountNotFound;
  TooManyAccountLocks;
  InvalidAccountIndex;
  AlreadyProcessed;
  WouldExceedAccountDataTotalLimit;
  InvalidAddressLookupTableIndex;
  SanitizeFailure;
  ResanitizationNeeded;
  InvalidRentPayingAccount;
  MaxLoadedAccountsDataSizeExceeded;
  InvalidAddressLookupTableData;
  InvalidWritableAccount;
  WouldExceedMaxAccountCostLimit;
  InvalidLoadedAccountsDataSizeLimit;
  InvalidProgramForExecution;
  InstructionError : record { nat8; text };
  InsufficientFundsForRent : record { account_index : nat8 };
  UnsupportedVersion;
  ClusterMaintenance;
  WouldExceedMaxVoteCostLimit;
  SignatureFailure;
  ProgramAccountNotFound;
  AccountLoadedTwice;
  ProgramExecutionTemporarilyRestricted : record { account_index : nat8 };
  AccountBorrowOutstanding;
  WouldExceedMaxBlockCostLimit;
  InvalidAddressLookupTableOwner;
  InsufficientFundsForFee;
  CallChainTooDeep;
  UnbalancedTransaction;
  BlockhashNotFound;
};
type TransactionStatus = record {
  err : opt TransactionError;
  confirmations : opt nat64;
  status : Result_3;
  slot : nat64;
  confirmation_status : opt TransactionConfirmationStatus;
};
type UiAccountsList = record {
  signatures : vec text;
  account_keys : vec ParsedAccount;
};
type UiAddressTableLookup = record {
  accountKey : text;
  writableIndexes : blob;
  readonlyIndexes : blob;
};
type UiCompiledInstruction = record {
  data : text;
  accounts : blob;
  programIdIndex : nat8;
  stackHeight : opt nat32;
};
type UiInstruction = variant {
  Parsed : UiParsedInstruction;
  Compiled : UiCompiledInstruction;
};
type UiLoadedAddresses = record { writable : vec text; readonly : vec text };
type UiParsedInstruction = variant {
  Parsed : ParsedInstruction;
  PartiallyDecoded : UiPartiallyDecodedInstruction;
};
type UiParsedMessage = record {
  addressTableLookups : opt vec UiAddressTableLookup;
  instructions : vec UiInstruction;
  accountKeys : vec ParsedAccount;
  recentBlockhash : text;
};
type UiPartiallyDecodedInstruction = record {
  data : text;
  accounts : vec text;
  stackHeight : opt nat32;
  programId : text;
};
type UiRawMessage = record {
  addressTableLookups : opt vec UiAddressTableLookup;
  instructions : vec UiCompiledInstruction;
  accountKeys : vec text;
  recentBlockhash : text;
  header : MessageHeader;
};
type UiReturnDataEncoding = variant { base64 };
type UiTokenAmount = record {
  decimals : nat8;
  uiAmount : opt float64;
  uiAmountString : text;
  amount : text;
};
type UiTransactionReturnData = record {
  data : record { text; UiReturnDataEncoding };
  programId : text;
};
type UiTransactionTokenBalance = record {
  uiTokenAmount : UiTokenAmount;
  owner : opt text;
  accountIndex : nat8;
  mint : text;
  programId : opt text;
};
type UpdateProviderArgs = record {
  id : text;
  url : opt text;
  auth : opt RpcAuth;
};
service : (InitArgs) -> {
  authorize : (principal, Auth) -> (bool);
  deauthorize : (principal, Auth) -> (bool);
  getAuthorized : (Auth) -> (vec principal) query;
  getMetrics : () -> (Metrics) query;
  getNodesInSubnet : () -> (nat32) query;
  getProviders : () -> (vec text) query;
  http_request : (HttpRequest) -> (HttpResponse) query;
  registerProvider : (RegisterProviderArgs) -> ();
  request : (text, text, text, nat64) -> (Result);
  requestCost : (text, nat64) -> (nat) query;
  sol_address : () -> (text);
  sol_getAccountInfo : (text, text) -> (Result_1);
  sol_getBalance : (text, text) -> (Result_2);
  sol_getLatestBlockhash : (text) -> (Result);
  sol_getSignatureStatuses : (text, vec text) -> (Result_4);
  sol_getTokenBalance : (text, text) -> (Result_5);
  sol_getTransaction : (text, text, opt nat64) -> (Result_6);
  sol_requestAirdrop : (text, text, nat64) -> (Result);
  sol_sendRawTransaction : (text, text) -> (Result);
  sol_sendTransaction : (text, SendTransactionRequest) -> (Result);
  unregisterProvider : (text) -> (bool);
  updateProvider : (UpdateProviderArgs) -> ();
}