General

FCTCallParam

type FCTCallParam = 
    | string 
    | number 
    | boolean 
    | FCTCallParam[] 
    | { [key: string]: FCTCallParam };

BatchMultiSigCallConstructor

interface BatchMultiSigCallConstructor {
  chainId?: ChainId;
  options?: Partial<IFCTOptions>;
  defaults?: DeepPartial<ICallDefaults>;
}

IBatchMultiSigCallFCT

interface IBatchMultiSigCallFCT {
  typeHash: string;
  typedData: BatchMultiSigCallTypedData;
  sessionId: string;
  nameHash: string;
  mcall: MSCall[];
  builder: string;
  variables: string[];
  externalSigners: string[];
  computed: {
    variable: string;
    add: string;
    sub: string;
    mul: string;
    div: string;
  }[];
  signatures: SignatureLike[];
}

PartialBatchMultiSigCall

type PartialBatchMultiSigCall = 
    Pick<IBatchMultiSigCallFCT, "typedData" | "signatures" | "mcall">;

MSCallMandatory

interface MSCallMandatory {
  nodeId?: string;
  from?: string | Variable;
  value?: string | Variable;
  options?: CallOptions;
}

IMSCallInput

type IMSCallInput = {
  to: string | Variable;
  params?: Param[];
  method?: string;
  toENS?: string;
} & MSCallMandatory;

IMSCallInputWithNodeId

type IMSCallInputWithNodeId = RequiredKeys<IMSCallInput, "nodeId">;

StrictMSCallInput

type StrictMSCallInput = 
    RequiredKeys<IMSCallInput, "from" | "value" | "nodeId" | "options"> 
    & {
      options: DeepRequired<CallOptions>;
    };

DecodedCalls

interface DecodedCalls extends StrictMSCallInput {
  params?: ParamWithoutVariable[];
}

IWithPlugin

type IWithPlugin = {
  plugin: {
    create(): Promise<IPluginCall | undefined>;
  };
} & MSCallMandatory;

IMSCallWithEncodedData

type IMSCallWithEncodedData = {
  nodeId?: string;
  abi: ReadonlyArray<Fragment | JsonFragment>;
  encodedData: string;
  to: string | Variable;
} & MSCallMandatory;

FCTCall

type FCTCall = IMSCallInput | IWithPlugin | IMSCallWithEncodedData;

MSCall

interface MSCall {
  typeHash: string;
  ensHash: string;
  functionSignature: string;
  value: string;
  callId: string;
  from: string;
  to: string;
  data: string;
  types: number[];
  typedHashes: string[];
}

IFCTOptions

interface IFCTOptions {
  name?: string;
  validFrom: string;
  expiresAt: string;
  maxGasPrice: string;
  blockable: boolean;
  purgeable: boolean;
  builder: string;
  recurrency?: {
    maxRepeats: string;
    chillTime: string;
    accumetable: boolean;
  };
  multisig?: {
    externalSigners?: string[];
    minimumApprovals?: string;
  };
}

RequiredFCTOptions

type RequiredFCTOptions = DeepRequired<IFCTOptions>;

IComputedValue

type IComputedValue = string | Variable;

IComputed

interface IComputed {
  id?: string;
  value: IComputedValue;
  add?: IComputedValue;
  sub?: IComputedValue;
  pow?: IComputedValue;
  mul?: IComputedValue;
  div?: IComputedValue;
  mod?: IComputedValue;
}

ComputedVariables

interface ComputedVariables {
  index: string;
  value: string;
  add: string;
  sub: string;
  pow: string;
  mul: string;
  div: string;
  mod: string;
}

IRequiredApproval

type IRequiredApproval = (
  | {
      protocol: "ERC20";
      method: "approve";
      params: {
        spender: string;
        amount: string;
      };
    }
  | {
      protocol: "ERC721";
      method: "approve";
      params: {
        spender: string;
        tokenId: string;
      };
    }
  | {
      protocol: "ERC1155" | "ERC721";
      method: "setApprovalForAll";
      params: {
        spender: string;
        approved: boolean;
      };
    }
) & {
  token: string;
  from: string;
};

ICallDefaults

type ICallDefaults = Omit<RequiredKeys<MSCallMandatory, "value">, "nodeId"> & {
  options: DeepRequired<CallOptions>;
};