types#DbState TypeScript Examples

export function onInsantiateFromHash(
  { db, identity }: DbState,
  { accountId, codeHash, name }: InstantiateData,
  onSuccess: InstantiateState['onSuccess']
): OnInstantiateSuccess$Hash {
  return async function ({ contract, status }): Promise<void> {
    if (accountId && codeHash && contract && (status.isInBlock || status.isFinalized)) {
      await createContract(db, identity, {
        abi: contract.abi.json,
        address: contract.address.toString(),
        creator: accountId,
        codeHash,
        name: name,
        tags: [],
      });

      onSuccess && onSuccess(contract);
    }
  };
}

export function onInstantiateFromCode(
  { db, identity }: DbState,
  { accountId, name }: InstantiateData,
  onSuccess: InstantiateState['onSuccess']
): OnInstantiateSuccess$Code {
  return async function (result): Promise<void> {
    try {
      const { blueprint, contract, status } = result;

      if (accountId && contract && (status.isInBlock || status.isFinalized)) {
        await createContract(db, identity, {
          abi: contract.abi.json,
          address: contract.address.toString(),
          creator: accountId,
          codeHash: blueprint?.codeHash.toHex() || contract.abi.info.source.wasmHash.toHex(),
          name: name,
          tags: [],
        });
        onSuccess && onSuccess(contract, blueprint);
      }
    } catch (e) {
      console.error(e);
    }
  };
}

export function DatabaseContextProvider({
  children,
}: React.HTMLAttributes<HTMLDivElement>): JSX.Element | null {
  const { status, endpoint } = useApi();

  const [state, setState] = useState<DbState>(INITIAL);

  useEffect((): void => {
    status === 'READY' &&
      init(endpoint)
        .then(([db, user, identity]): void => {
          setState(state => ({ ...state, db, user, identity, isDbReady: true }));
        })
        .catch(e => {
          console.error(e);
        });
  }, [endpoint, status]);

  const refreshUserData = useCallback(async (): Promise<void> => {
    const user = await getUser(state.db, state.identity);
    const myContracts = await findMyContracts(state.db, state.identity);

    setState(state => ({ ...state, user, myContracts }));
  }, [state.db, state.identity]);

  useEffect((): void => {
    if (state.isDbReady) {
      refreshUserData().then().catch(console.error);
    }
  }, [refreshUserData, state.isDbReady]);

  return <DbContext.Provider value={{ ...state, refreshUserData }}>{children}</DbContext.Provider>;
}

export function useDatabase(): DbState {
  return useContext(DbContext);
}

DbContext: React.Context<DbState> = createContext({} as unknown as DbState)

DbConsumer: React.Consumer<DbState> = DbContext.Consumer

DbProvider: React.Provider<DbState> = DbContext.Provider

INITIAL = { isDbReady: false } as unknown as DbState