@sabaaa1/common 0.0.1

package/src/types/sandbox.types.ts

@@ -0,0 +1,246 @@
+import { MerkleTreeJson } from '../data-structures/merkle-tree/MerkleTree';
+import { TokenAmountInfo } from './activities.types';
+import { type TypedData } from './circom-data.types';
+import { EncryptedOutputWithSign } from './commitments.types';
+import { ExternalActionId } from './external-action.types';
+import { type ApprovedUtxo, type FeeStructure, IntegrationProvider, type ParsedInLogicMetadata } from './hinkal.types';
+import { SubAccount } from './proxy.types';
+import { RelayerTransaction } from './relayer.types';
+import type { ERC20Token, TokenChanges } from './token.types';
+import type { AppMetaData, WCTransactionParameters } from './wc.types';
+import { WithId } from './with-id.types';
+import { AdminTransactionType } from './admin.types';
+
+export enum SandboxRequestType {
+  ReceiveFromShieldedAccount = 'ReceiveFromShieldedAccount',
+  SwapTokens = 'SwapTokens',
+  ShieldTokens = 'ShieldTokens',
+  SignMessage = 'SignMessage',
+  FundApproveAndTransact = 'FundApproveAndTransact',
+  PrivateTransactionFromProxy = 'PrivateTransactionFromProxy',
+  Approve = 'Approve',
+  InsideTransact = 'InsideTransact',
+  FundAndApprove = 'FundAndApprove',
+  ProxySend = 'ProxySend',
+  Send = 'Send',
+  Fund = 'Fund',
+  ProxySwapTokens = 'ProxySwapTokens',
+  BatchTransaction = 'BatchTransaction',
+}
+
+// although we can directly send relayer transaction objects from / to sandbox, we can't send ethers.ContractTransaction
+// this provides consistent transfarable interface
+export interface SandboxTransferableTransaction {
+  hash: string;
+  from: string;
+  to: string;
+  gas: bigint;
+  gasPrice: bigint;
+  value: bigint;
+  isRelayerOff: boolean;
+}
+
+export interface TransferTokenRequest {
+  type: SandboxRequestType.Send | SandboxRequestType.Fund;
+  amounts: bigint[];
+  erc20Tokens: ERC20Token[];
+  to: string;
+  isRelayerOff: boolean;
+  ownerPublicAddress: string;
+  action: AdminTransactionType;
+  feeToken?: string;
+  feeStructure?: FeeStructure;
+}
+
+export interface PrivateTransactionBaseRequest {
+  appMetaData: AppMetaData;
+  ownerPublicAddress: string;
+  feeStructure?: FeeStructure;
+}
+
+export interface FundApproveAndTransactRequest extends PrivateTransactionBaseRequest {
+  type: SandboxRequestType.FundApproveAndTransact;
+  spenderAddress: string;
+  subAccount: SubAccount;
+  tokenChanges: TokenChanges<bigint>[];
+  txParams: WCTransactionParameters;
+  autoDepositBack: boolean;
+  maxGasInDollar?: string;
+}
+
+export interface PrivateTransactionFromProxyRequest extends PrivateTransactionBaseRequest {
+  type: SandboxRequestType.PrivateTransactionFromProxy;
+  subAccount: SubAccount;
+  tokenChanges: TokenChanges<bigint>[];
+  proxyApprovalData?: { approvalToken: ERC20Token; approvalAmount: string };
+  txParams: WCTransactionParameters;
+  autoDepositBack: boolean;
+  maxGasInDollar?: string;
+}
+
+export interface ApproveRequest extends PrivateTransactionBaseRequest {
+  type: SandboxRequestType.Approve;
+  approvalAmount: string;
+  approvalToken: ERC20Token;
+  txParams: WCTransactionParameters;
+}
+
+export interface InsideTransactRequest extends PrivateTransactionBaseRequest {
+  type: SandboxRequestType.InsideTransact;
+  tokenChanges: TokenChanges<bigint>[];
+  parsedInLogicMetadata: ParsedInLogicMetadata;
+  txParams: WCTransactionParameters;
+}
+
+export interface FundAndApproveRequest extends PrivateTransactionBaseRequest {
+  type: SandboxRequestType.FundAndApprove;
+  subAccount: SubAccount;
+  tokenChanges: TokenChanges<bigint>[];
+  txParams: WCTransactionParameters;
+  spenderAddress?: string;
+}
+
+export interface BatchTransactionRequest extends PrivateTransactionBaseRequest {
+  type: SandboxRequestType.BatchTransaction;
+  tokenChanges: TokenChanges<bigint>[];
+  batchCalls: WCTransactionParameters[];
+  subAccount: SubAccount;
+  revokedTokens?: TokenAmountInfo[];
+  autoDepositBack?: boolean;
+  maxGasInDollar?: string;
+}
+
+export interface ReceiveFromSubAccountRequest {
+  type: SandboxRequestType.ReceiveFromShieldedAccount;
+  amounts: bigint[];
+  erc20Tokens: ERC20Token[];
+  subAccount: SubAccount;
+  ownerPublicAddress: string;
+  feeToken?: string;
+  feeStructure?: FeeStructure;
+}
+
+export interface ShieldTokensRequest {
+  type: SandboxRequestType.ShieldTokens;
+  amounts: bigint[];
+  erc20Tokens: ERC20Token[];
+  ownerPublicAddress: string;
+}
+
+export interface SwapTokensRequest {
+  type: SandboxRequestType.SwapTokens;
+  amountChanges: bigint[];
+  erc20Tokens: ERC20Token[];
+  externalActionId: ExternalActionId;
+  swapData: string;
+  ownerPublicAddress: string;
+  integrationProvider: IntegrationProvider;
+  action: AdminTransactionType;
+  feeToken?: string;
+  feeStructure?: FeeStructure;
+  bridgedToken?: ERC20Token;
+  bridgedTokenAmount?: bigint;
+}
+
+export interface ProxySwapTokensRequest {
+  type: SandboxRequestType.ProxySwapTokens;
+  amountChanges: bigint[];
+  erc20Tokens: ERC20Token[];
+  externalActionId: ExternalActionId;
+  swapData: string;
+  isTheSameChainSwap: boolean;
+  ownerPublicAddress: string;
+  integrationProvider: IntegrationProvider;
+  subAccount: SubAccount;
+  action: AdminTransactionType;
+  feeToken?: string;
+  feeStructure?: FeeStructure;
+  bridgedToken?: ERC20Token;
+  bridgedTokenAmount?: bigint;
+  autoDepositBack?: boolean;
+  maxGasInDollar?: string;
+}
+
+export interface SignMessageRequest {
+  type: SandboxRequestType.SignMessage;
+  messageToSign?: string;
+  typedData?: TypedData;
+  subAccount: SubAccount;
+}
+
+export interface SendProxySendRequest {
+  type: SandboxRequestType.ProxySend;
+  amounts: bigint[];
+  erc20Tokens: ERC20Token[];
+  to: string;
+  subAccount: SubAccount;
+  ownerPublicAddress: string;
+  action: AdminTransactionType;
+  feeToken?: string;
+  feeStructure?: FeeStructure;
+}
+
+export interface PrepareHinkalFromSerializedArgs {
+  signature: string;
+  ethereumAddress: string;
+  chainId: number;
+  nullifiers: string[];
+  merkleTreeHinkal: MerkleTreeJson;
+  merkleTreeAccessToken: MerkleTreeJson;
+  encryptedOutputs: EncryptedOutputWithSign<boolean>[];
+  approvals: Record<string, ApprovedUtxo[]>;
+  generateProofRemotely: boolean;
+  serializedCache: Record<string, string>;
+  stealthPairCache: Record<string, string>;
+  stealthAddressCache: Record<string, string>;
+}
+
+export type SandboxRequest = (
+  | TransferTokenRequest
+  | ReceiveFromSubAccountRequest
+  | SwapTokensRequest
+  | ShieldTokensRequest
+  | SignMessageRequest
+  | FundApproveAndTransactRequest
+  | PrivateTransactionFromProxyRequest
+  | ApproveRequest
+  | InsideTransactRequest
+  | FundAndApproveRequest
+  | SendProxySendRequest
+  | ProxySwapTokensRequest
+  | BatchTransactionRequest
+) & {
+  prepareHinkalArgs: PrepareHinkalFromSerializedArgs;
+  isTorRoutingOn: boolean;
+};
+
+export type SandboxRuntimeMessageHandler = (message: WithId<SandboxRequest>) => Promise<
+  | {
+      result: string;
+    }
+  | undefined
+>;
+
+export interface SandboxResponseError {
+  id: number;
+  success: false;
+  error: Error;
+  erroredTx?: RelayerTransaction;
+}
+
+export interface SandboxResponseBase {
+  id: number;
+  success: true;
+}
+
+export interface SandboxResponseTx extends SandboxResponseBase {
+  tx: SandboxTransferableTransaction;
+}
+
+export interface SandboxResponseSignature extends SandboxResponseBase {
+  signature: string;
+}
+
+export type SandboxResponseSuccess = SandboxResponseTx | SandboxResponseSignature;
+
+export type SandboxResponse = SandboxResponseError | SandboxResponseSuccess;

package/src/types/session.types.ts

@@ -0,0 +1,12 @@
+export interface SessionMetadata {
+  name: string;
+  description: string;
+  url: string;
+  icons: string[];
+}
+
+export interface Session {
+  topic: string;
+  metadata: SessionMetadata;
+  fromInjectedConnector?: boolean;
+}

package/src/types/signature.types.ts

@@ -0,0 +1,11 @@
+import { ConfirmationRequestType } from './confirmation-request.types';
+import { AppMetaData } from './wc.types';
+
+export interface SignedMessage {
+  timestamp: string;
+  chainId: number;
+  messageText: string;
+  messageType: ConfirmationRequestType.PERSONAL_SIGN | ConfirmationRequestType.SIGN_TYPE_V4;
+  subAccountAddress: string;
+  appMetaData: AppMetaData;
+}

package/src/types/slippage.types.ts

@@ -0,0 +1,3 @@
+export enum SlippageType {
+  Swap = 'Swap',
+}

package/src/types/snark.types.ts

@@ -0,0 +1,43 @@
+interface ZkBaseInputType {
+  rootHashHinkal: bigint | undefined;
+  shieldedPrivateKey: string;
+  inAmounts: string[];
+  inBlindings: string[];
+  inNullifiers: string[];
+  inCommitmentSiblings: string[][];
+  inCommitmentSiblingSides: string[][];
+  outCommitments: string[];
+  rootHashAccessToken: bigint | undefined;
+  accessTokenSiblings: string[];
+  accessTokenSiblingSides: string[];
+  relayFee: bigint;
+  relay: string;
+}
+
+export interface ZkInputType extends ZkBaseInputType {
+  publicAmount: bigint;
+  recipientAddress: string;
+  erc20TokenAddress: string;
+  outAmounts: string[];
+  outShieldedPublicKey: string[];
+  outBlindings: string[];
+}
+
+export interface ZkExternalInputType extends ZkBaseInputType {
+  inSwapAmount: bigint;
+  inErc20TokenAddress: string;
+  outAmount: bigint;
+  outBlinding: bigint;
+  outSwapAmount: bigint;
+  outErc20TokenAddress: string;
+  outSwapBlinding: bigint;
+  externalActionId: bigint;
+  externalActionMetadataHash: bigint;
+}
+
+export interface ZkResultType {
+  proof: string;
+  publicSignals: string[];
+}
+
+export type NewZkCallDataType = [[string, string], [[string, string], [string, string]], [string, string], string[]];

package/src/types/tenderly.api.types.ts

@@ -0,0 +1,200 @@
+// SEND TRANSACTION TO VIRTUAL NETWORK
+export interface SendTransacrtionBase {
+  blockOverrides?: {
+    number: string;
+    timestamp: string;
+  };
+  stateOverrides?: {
+    nonce: number;
+    code: string; // Bytecode that will override the code associated to the given account..
+    balance: { value: number }; //
+    storage: Map<string, string>; // Overrides of storage slots. In this mapping, the key is variable storage slot, and the value contains the override.
+  };
+}
+
+// SUMULATE TRANSACTION IN ACTUAL NETWORK
+export type SimulateTxBody = {
+  network_id: string; // = '1'
+  from: string;
+  to: string;
+  input: string;
+  gas?: number;
+  block_number?: number;
+  transaction_index?: number; // Index of the transaction within the block.
+  gas_price?: string; // Example:18312000018
+  estimate_gas?: boolean; // Flag that enables precise gas estimation
+  value?: string;
+  save?: boolean; // Flag indicating whether to save the simulation in dashboard UI.
+  save_if_fails?: boolean; // Flag indicating whether to save failed simulation in dashboard UI.
+};
+
+export type SimulateTxResponse = {
+  transaction: {
+    hash: string;
+    block_hash: string;
+    block_number: number;
+    from: string;
+    gas: number;
+    gas_price: number;
+    input: string;
+    nonce: number;
+    to: string;
+    index: number;
+    addresses: string[];
+    contract_ids: string[];
+    network_id: string;
+    timestamp: string;
+    transaction_info: {
+      contract_address: string;
+      method: 'approve';
+      logs: any[] | null;
+      balance_diff: any[] | null;
+      nonce_diff: any[] | null;
+      state_diff: any[] | null;
+      asset_changes: any[] | null;
+      exposure_changes: any[] | null;
+      balance_changes: any[] | null;
+    };
+    call_trace: any[] | null;
+    simulation: {
+      id: string;
+      project_id: string;
+      network_id: string;
+      blocknumber: number;
+      transaction_index: number;
+      block_header: object;
+      nonce: number;
+      contracts: any[];
+    };
+  };
+  simulation: object;
+};
+
+// TENDERLY RPC SIMULATE TRANSACTION
+
+export type RpcTransactionParams = {
+  from: string;
+  to: string;
+  gas: string; // hex
+  gasPrice?: string; // hex
+  value: string | bigint; // hex
+  input: string;
+  maxFeePerGas?: number;
+  maxPriorityFeePerGas?: number;
+};
+
+export type RpcSimulateTransactionBody<T extends RpcTransactionParams | RpcTransactionParams[] = RpcTransactionParams> =
+  {
+    params: [
+      T,
+      string | 'latest' | 'earliest' | 'pending' | 'finalized' | 'safe', // blocknumber here in hex
+      { [key in string]: { balance: string; nonce?: string } },
+    ];
+  };
+
+export type StorageStateChange = {
+  address: string;
+  balance?: {
+    previousValue: string;
+    newValue: string;
+  };
+  nonce?: {
+    previousValue: string;
+    newValue: string;
+  };
+  storage?: {
+    slot: string; // '0x7fd222cc056fa4857102d2d1a53fd49e9a90d1e4b9878255b924ad6029bf790f'
+    previousValue: string; // '0x01000059f000000000000000000000002b2236132def019e86ffffff982d17c8'
+    newValue: string; // '0x01000059f000000000000000000000002b2236132def019e86ffffff982d17c8'
+    ERC20ChangeType?: 'balance' | 'allowance';
+  }[];
+};
+export type RPCSimulationAssetChange = {
+  rawAmount: string; //  '0x6536e2898bd4cbaef'
+  amount: string | null; // '116.692251631319562991'
+  dollarValue?: string; // '116.692251631319562991'
+  from: string;
+  to: string;
+  type: string; // can be 'Mint', 'Burn', 'Transfer'
+  id?: string;
+  assetInfo: {
+    standard: string;
+    type: string; // can be 'ERC20', 'ERC721', 'ERC1155', 'Native
+    contractAddress?: string;
+    symbol?: string;
+    name?: string;
+    logo?: string;
+    decimals?: number;
+    dollarValue?: string;
+  };
+};
+
+export type RPCSimulationExposureChange = {
+  assetInfo: {
+    standard: string;
+    type: string;
+    contractAddress: string;
+    symbol: string;
+    name: string;
+    logo: string;
+    decimals: number;
+    dollarValue: string;
+  };
+  type: string;
+  owner: string;
+  spender: string;
+  rawAmount: string; // '0x0',
+  amount: string; // '116.692251631319562991'
+  dollarValue: string; // '116.692251631319562991'
+};
+
+export interface RpcTrace {
+  type: string;
+  from: string;
+  to: string;
+  gas: string;
+  gasUsed: string;
+  input: string;
+  method?: string;
+  output?: string;
+  subtraces: number;
+  traceAddress: string[];
+  value?: string;
+  error?: string;
+  errorReason?: string;
+}
+
+export type RpcSimulateLog = {
+  name: string;
+  inputs: {
+    value: string;
+    type: string;
+    name: string;
+    indexed: boolean;
+  }[];
+  raw: { address: string; data: string; topics: string[] };
+};
+
+export type RpcSimulateResult = {
+  assetChanges: RPCSimulationAssetChange[];
+  status: boolean;
+  gasUsed: string;
+  cumulativeGasUsed: string;
+  blockNumber: string;
+  type: string;
+  logsBloom: string;
+  logs: RpcSimulateLog[];
+  stateChanges: StorageStateChange[];
+  trace?: RpcTrace[];
+  exposureChanges: RPCSimulationExposureChange[];
+};
+
+export type RpcSimulateTransactionResponse<T extends RpcSimulateResult | RpcSimulateResult[] = RpcSimulateResult> = {
+  jsonrpc: '2.0';
+  id: 0;
+  result: T;
+  error?: {
+    code: number;
+    message: string;
+  };
+};

package/src/types/token-prices.types.ts

@@ -0,0 +1,8 @@
+export const TOKEN_PRICE_STATUS = {
+  INITIAL: 'initial',
+  FETCHING: 'fetching',
+  ERROR: 'error',
+  SUCCESS: 'success',
+} as const;
+
+export type TokenPriceStatus = (typeof TOKEN_PRICE_STATUS)[keyof typeof TOKEN_PRICE_STATUS];

package/src/types/token-with-id.types.ts

@@ -0,0 +1,4 @@
+export interface TokenWithId {
+  erc20TokenAddress: string;
+  tokenId: number;
+}

package/src/types/token.types.ts

@@ -0,0 +1,86 @@
+export interface ERC20Token {
+  chainId: number;
+  erc20TokenAddress: string;
+  wrappedErc20TokenAddress?: string;
+  underlyingErc20TokenAddress?: string;
+  name: string;
+  symbol: string;
+  decimals: number;
+  nftTokenType?: string;
+  logoURI?: string;
+  logoURIs?: string[];
+  whitelisted?: boolean;
+  isCustom?: true;
+  tokenIds?: string[];
+  approvalType?: ApprovalType;
+  isVolatile?: boolean;
+  sharedAddress?: string;
+  isPendleToken?: boolean;
+  isHToken?: boolean;
+  hasHToken?: boolean;
+  aaveToken?: boolean;
+  allowanceStorageOffset?: number;
+  balanceStorageOffset?: number;
+  isVyper?: boolean;
+  isSpam?: boolean;
+}
+
+export enum ApprovalType {
+  Classic,
+  ERC20Permit,
+  DAIPermit,
+}
+
+export interface NFT {
+  tokenId: number;
+  image?: string;
+  name?: string;
+  timestamp?: string;
+}
+
+export interface TokenBalance {
+  token: ERC20Token;
+  balance: bigint;
+  timestamp?: string;
+  nfts?: NFT[];
+}
+
+export interface TokenBalanceWithUsdValue extends TokenBalance {
+  isBalanceLoading?: boolean;
+  usdValue?: number;
+  isUsdValueLoading?: boolean;
+}
+
+export interface PublicTokenBalances {
+  publicTokenBalances: TokenBalance[];
+  isPublicBalancesLoading: boolean;
+}
+
+export interface PublicTokenBalancesWithUsd {
+  publicTokenBalancesWithUSD: TokenBalanceWithUsdValue[];
+  publicTotalUSDBalances: number;
+  isPublicBalancesLoading: boolean;
+  isUsdBalanceLoading: boolean;
+}
+
+export interface TokenChanges<T = number> {
+  token: ERC20Token;
+  amount: T;
+  nftIds?: string[];
+}
+
+export interface GasTokensInfoEntry {
+  token: ERC20Token;
+  balance: string;
+  dollarValue: number;
+  isLoading: boolean;
+  isInsufficientGasBalance: boolean;
+  disabled: boolean;
+}
+
+export type VolatileTokenChange = {
+  tokenAddress: string;
+  amount: string;
+  targetAddress?: string;
+  originalIndex: number;
+};