TypedData

IComputedVariable

interface IComputedVariable {
  index: string;
  var: string;
  add: string;
  sub: string;
  mul: string;
  div: string;
}

TypedDataRecurrency

interface TypedDataRecurrency {
  max_repeats: string;
  chill_time: string;
  accumetable: boolean;
}

TypedDataMultiSig

interface TypedDataMultiSig {
  signers: string[];
  required_signers: number;
}

TypedDataTypes

type TypedDataTypes = {
  EIP712Domain: MessageTypeProperty[];
  BatchMultiSigCall: MessageTypeProperty[];
  Meta: MessageTypeProperty[];
  Limits: MessageTypeProperty[];
  Call: MessageTypeProperty[];
  Recurrency?: MessageTypeProperty[];
  MultiSig?: MessageTypeProperty[];
} & { [key: string]: MessageTypeProperty[] };

TypedDataDomain

interface TypedDataDomain {
  name: string;
  version: string;
  chainId: number;
  verifyingContract: string;
  salt: string;
}

TypedDataMessageTransaction

type TypedDataMessageTransaction = {
  call: {
    call_index: number;
    payer_index: number;
    call_type: (typeof CALL_TYPE_MSG)[keyof typeof CALL_TYPE_MSG];
    from: string;
    to: string;
    to_ens: string;
    eth_value: string;
    gas_limit: string;
    permissions: number;
    flow_control: string;
    returned_false_means_fail: boolean;
    jump_on_success: number;
    jump_on_fail: number;
    method_interface: string;
  };
} & {
  [key: string]: FCTCallParam;
};

TypedDataLimits

interface TypedDataLimits {
  valid_from: string;
  expires_at: string;
  gas_price_limit: string;
  purgeable: boolean;
  blockable: boolean;
}

TypedDataMeta

interface TypedDataMeta {
  name: string;
  builder: string;
  selector: string;
  version: string;
  random_id: string;
  eip712: boolean;
}

MessageTransaction

type MessageTransaction = 
    Record<`transaction_${number}`, TypedDataMessageTransaction>;

MessageMeta

type MessageMeta = Record<"meta", TypedDataMeta>;

MessageLimits

type MessageLimits = Record<"limits", TypedDataLimits>;

MessageRecurrency

type MessageRecurrency = Record<"recurrency", TypedDataRecurrency>;

MessageMultiSig

type MessageMultiSig = Record<"multisig", TypedDataMultiSig>;

MessageComputed

type MessageComputed = Record<`computed_${number}`, IComputedVariable>;

MandatoryTypedDataMessage

type MandatoryTypedDataMessage = MessageTransaction & MessageMeta & MessageLimits;

OptionalTypedDataMessage

type OptionalTypedDataMessage = 
    MessageRecurrency & MessageMultiSig & MessageComputed;

TypedDataMessage

type TypedDataMessage = 
    MandatoryTypedDataMessage & Partial<OptionalTypedDataMessage>;

BatchMultiSigCallTypedData

interface BatchMultiSigCallTypedData {
  types: TypedDataTypes;
  primaryType: string;
  domain: TypedDataDomain;
  message: TypedDataMessage;
}