@0xtorch/core 0.0.2 → 0.0.3

package/actions/schemas/valuedown/valuedown.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod'
+import { nftSchema } from '../../../assets'
+import {
+  normalAccountActionDefaultSchema,
+  normalActionDefaultSchema,
+  transferInSchema,
+} from '../default'
+
+export const normalActionValuedownSchema = normalActionDefaultSchema
+  .extend({
+    action: z.literal('valuedown'),
+    target: nftSchema,
+    transfers: z.array(transferInSchema),
+  })
+  .transform((v) => ({
+    ...v,
+    comment: v.comment,
+    app: v.app,
+  }))
+
+export const accountActionValuedownSchema = normalAccountActionDefaultSchema
+  .extend({
+    action: z.literal('valuedown'),
+    target: nftSchema,
+    transfers: z.array(transferInSchema),
+  })
+  .transform((v) => ({
+    ...v,
+    comment: v.comment,
+    app: v.app,
+  }))

package/actions/schemas/valueup/index.ts

@@ -0,0 +1,4 @@
+export {
+  accountActionValueupSchema,
+  normalActionValueupSchema,
+} from './valueup'

package/actions/schemas/valueup/valueup.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod'
+import { nftSchema } from '../../../assets'
+import {
+  normalAccountActionDefaultSchema,
+  normalActionDefaultSchema,
+  transferOutSchema,
+} from '../default'
+
+export const normalActionValueupSchema = normalActionDefaultSchema
+  .extend({
+    action: z.literal('valueup'),
+    target: nftSchema,
+    transfers: z.array(transferOutSchema),
+  })
+  .transform((v) => ({
+    ...v,
+    comment: v.comment,
+    app: v.app,
+  }))
+
+export const accountActionValueupSchema = normalAccountActionDefaultSchema
+  .extend({
+    action: z.literal('valueup'),
+    target: nftSchema,
+    transfers: z.array(transferOutSchema),
+  })
+  .transform((v) => ({
+    ...v,
+    comment: v.comment,
+    app: v.app,
+  }))

package/actions/schemas/withdraw/index.ts

@@ -0,0 +1,16 @@
+export {
+  accountActionRemoveLiquiditySchema,
+  normalActionRemoveLiquiditySchema,
+} from './removeLiquidity'
+export {
+  accountActionUnstakeSchema,
+  normalActionUnstakeSchema,
+} from './unstake'
+export {
+  accountActionWithdrawSchema,
+  normalActionWithdrawSchema,
+} from './withdraw'
+export {
+  accountActionWithdrawWithBondSchema,
+  normalActionWithdrawWithBondSchema,
+} from './withdrawWithBond'

package/actions/schemas/withdraw/removeLiquidity.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod'
+import {
+  loanAccountActionDefaultSchema,
+  loanNormalActionDefaultSchema,
+  transferCryptoCurrencyInSchema,
+  transferCryptoCurrencyOutSchema,
+  transferNftInSchema,
+  transferNftOutSchema,
+} from '../default'
+
+export const normalActionRemoveLiquiditySchema = loanNormalActionDefaultSchema
+  .extend({
+    action: z.literal('remove-liquidity'),
+    transfers: z.array(
+      z.union([
+        transferCryptoCurrencyInSchema,
+        transferNftInSchema,
+        transferCryptoCurrencyOutSchema,
+        transferNftOutSchema,
+      ]),
+    ),
+  })
+  .transform((v) => ({
+    ...v,
+    comment: v.comment,
+    app: v.app,
+  }))
+
+export const accountActionRemoveLiquiditySchema = loanAccountActionDefaultSchema
+  .extend({
+    action: z.literal('remove-liquidity'),
+    transfers: z.array(
+      z.union([
+        transferCryptoCurrencyInSchema,
+        transferNftInSchema,
+        transferCryptoCurrencyOutSchema,
+        transferNftOutSchema,
+      ]),
+    ),
+  })
+  .transform((v) => ({
+    ...v,
+    comment: v.comment,
+    app: v.app,
+  }))

package/actions/schemas/withdraw/unstake.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod'
+import {
+  loanAccountActionDefaultSchema,
+  loanNormalActionDefaultSchema,
+  transferCryptoCurrencyInSchema,
+  transferNftInSchema,
+} from '../default'
+
+export const normalActionUnstakeSchema = loanNormalActionDefaultSchema
+  .extend({
+    action: z.literal('unstake'),
+    transfers: z.array(
+      z.union([transferCryptoCurrencyInSchema, transferNftInSchema]),
+    ),
+  })
+  .transform((v) => ({
+    ...v,
+    comment: v.comment,
+    app: v.app,
+  }))
+
+export const accountActionUnstakeSchema = loanAccountActionDefaultSchema
+  .extend({
+    action: z.literal('unstake'),
+    transfers: z.array(
+      z.union([transferCryptoCurrencyInSchema, transferNftInSchema]),
+    ),
+  })
+  .transform((v) => ({
+    ...v,
+    comment: v.comment,
+    app: v.app,
+  }))

package/actions/schemas/withdraw/withdraw.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod'
+import {
+  loanAccountActionDefaultSchema,
+  loanNormalActionDefaultSchema,
+  transferCryptoCurrencyInSchema,
+  transferNftInSchema,
+} from '../default'
+
+export const normalActionWithdrawSchema = loanNormalActionDefaultSchema
+  .extend({
+    action: z.literal('withdraw'),
+    transfers: z.array(
+      z.union([transferCryptoCurrencyInSchema, transferNftInSchema]),
+    ),
+  })
+  .transform((v) => ({
+    ...v,
+    comment: v.comment,
+    app: v.app,
+  }))
+
+export const accountActionWithdrawSchema = loanAccountActionDefaultSchema
+  .extend({
+    action: z.literal('withdraw'),
+    transfers: z.array(
+      z.union([transferCryptoCurrencyInSchema, transferNftInSchema]),
+    ),
+  })
+  .transform((v) => ({
+    ...v,
+    comment: v.comment,
+    app: v.app,
+  }))

package/actions/schemas/withdraw/withdrawWithBond.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod'
+import {
+  loanAccountActionDefaultSchema,
+  loanNormalActionDefaultSchema,
+  transferCryptoCurrencyInSchema,
+  transferCryptoCurrencyOutSchema,
+  transferNftInSchema,
+  transferNftOutSchema,
+} from '../default'
+
+export const normalActionWithdrawWithBondSchema = loanNormalActionDefaultSchema
+  .extend({
+    action: z.literal('withdraw-with-bond'),
+    transfers: z.array(
+      z.union([
+        transferCryptoCurrencyInSchema,
+        transferNftInSchema,
+        transferCryptoCurrencyOutSchema,
+        transferNftOutSchema,
+      ]),
+    ),
+  })
+  .transform((v) => ({
+    ...v,
+    comment: v.comment,
+    app: v.app,
+  }))
+
+export const accountActionWithdrawWithBondSchema =
+  loanAccountActionDefaultSchema
+    .extend({
+      action: z.literal('withdraw-with-bond'),
+      transfers: z.array(
+        z.union([
+          transferCryptoCurrencyInSchema,
+          transferNftInSchema,
+          transferCryptoCurrencyOutSchema,
+          transferNftOutSchema,
+        ]),
+      ),
+    })
+    .transform((v) => ({
+      ...v,
+      comment: v.comment,
+      app: v.app,
+    }))

package/actions/types/action.ts

@@ -0,0 +1,12 @@
+import type { z } from 'zod'
+import type { accountActionSchema, normalActionSchema } from '../schemas'
+
+export type NormalAction = z.infer<typeof normalActionSchema>
+
+export type AccountAction = z.infer<typeof accountActionSchema>
+
+export type ActionType = NormalAction['action']
+
+export type AccountActionType = AccountAction['action']
+
+export type Evidence = AccountAction['evidence']

package/actions/types/addLiquidity.ts

@@ -1,23 +1,13 @@
-import type { CryptoCurrency, CryptoCurrencyPrice, Nft } from '../../assets'
-import type { AccountAction, NormalAction } from './common'
+import type { z } from 'zod'
+import type {
+  accountActionAddLiquiditySchema,
+  normalActionAddLiquiditySchema,
+} from '../schemas'
 
-type Action = 'add-liquidity'
+export type NormalActionAddLiquidity = z.infer<
+  typeof normalActionAddLiquiditySchema
+>
 
-export type NormalActionAddLiquidity<
-  Account = unknown,
-  // TODO crypto 以外の価格にも対応させる
-  Price extends CryptoCurrencyPrice | undefined =
-    | CryptoCurrencyPrice
-    | undefined,
-  Asset extends CryptoCurrency | Nft = CryptoCurrency | Nft,
-> = NormalAction<Action, Account, Price, Asset, 'in' | 'out'>
-
-export type AccountActionAddLiquidity<
-  Account = unknown,
-  Source extends string = string,
-  // TODO crypto 以外の価格にも対応させる
-  Price extends CryptoCurrencyPrice | undefined =
-    | CryptoCurrencyPrice
-    | undefined,
-  Asset extends CryptoCurrency | Nft = CryptoCurrency | Nft,
-> = AccountAction<Action, Source, Account, Price, Asset, 'in' | 'out'>
+export type AccountActionAddLiquidity = z.infer<
+  typeof accountActionAddLiquiditySchema
+>

package/actions/types/approve.ts

@@ -0,0 +1,9 @@
+import type { z } from 'zod'
+import type {
+  accountActionApproveSchema,
+  normalActionApproveSchema,
+} from '../schemas'
+
+export type NormalActionApprove = z.infer<typeof normalActionApproveSchema>
+
+export type AccountActionApprove = z.infer<typeof accountActionApproveSchema>

package/actions/types/atomicArbitrage.ts

@@ -1,30 +1,13 @@
-import type { CryptoCurrency, CryptoCurrencyPrice } from '../../assets'
-import type { AccountAction, NormalAction } from './common'
+import type { z } from 'zod'
+import type {
+  accountActionAtomicArbitrageSchema,
+  normalActionAtomicArbitrageSchema,
+} from '../schemas'
 
-export type NormalActionAtomicArbitrage<
-  Account = unknown,
-  Price extends CryptoCurrencyPrice | undefined =
-    | CryptoCurrencyPrice
-    | undefined,
-> = NormalAction<
-  'atomic-arbitrage',
-  Account,
-  Price,
-  CryptoCurrency,
-  'in' | 'out'
+export type NormalActionAtomicArbitrage = z.infer<
+  typeof normalActionAtomicArbitrageSchema
 >
 
-export type AccountActionAtomicArbitrage<
-  Account = unknown,
-  Source extends string = string,
-  Price extends CryptoCurrencyPrice | undefined =
-    | CryptoCurrencyPrice
-    | undefined,
-> = AccountAction<
-  'atomic-arbitrage',
-  Source,
-  Account,
-  Price,
-  CryptoCurrency,
-  'in'
+export type AccountActionAtomicArbitrage = z.infer<
+  typeof accountActionAtomicArbitrageSchema
 >

package/actions/types/borrow.ts

@@ -0,0 +1,9 @@
+import type { z } from 'zod'
+import type {
+  accountActionBorrowSchema,
+  normalActionBorrowSchema,
+} from '../schemas'
+
+export type NormalActionBorrow = z.infer<typeof normalActionBorrowSchema>
+
+export type AccountActionBorrow = z.infer<typeof accountActionBorrowSchema>

package/actions/types/borrowWithDebt.ts

@@ -0,0 +1,13 @@
+import type { z } from 'zod'
+import type {
+  accountActionBorrowWithDebtSchema,
+  normalActionBorrowWithDebtSchema,
+} from '../schemas'
+
+export type NormalActionBorrowWithDebt = z.infer<
+  typeof normalActionBorrowWithDebtSchema
+>
+
+export type AccountActionBorrowWithDebt = z.infer<
+  typeof accountActionBorrowWithDebtSchema
+>

package/actions/types/bridgeFrom.ts

@@ -1,23 +1,13 @@
-import type { CryptoCurrency, CryptoCurrencyPrice, Nft } from '../../assets'
-import type { AccountAction, NormalAction } from './common'
+import type { z } from 'zod'
+import type {
+  accountActionBridgeFromSchema,
+  normalActionBridgeFromSchema,
+} from '../schemas'
 
-export type Action = 'bridge-from'
+export type NormalActionBridgeFrom = z.infer<
+  typeof normalActionBridgeFromSchema
+>
 
-export type NormalActionBridgeFrom<
-  Account = unknown,
-  // TODO crypto 以外の価格にも対応させる
-  Price extends CryptoCurrencyPrice | undefined =
-    | CryptoCurrencyPrice
-    | undefined,
-  Asset extends CryptoCurrency | Nft = CryptoCurrency | Nft,
-> = NormalAction<Action, Account, Price, Asset, 'out'>
-
-export type AccountActionBridgeFrom<
-  Account = unknown,
-  Source extends string = string,
-  // TODO crypto 以外の価格にも対応させる
-  Price extends CryptoCurrencyPrice | undefined =
-    | CryptoCurrencyPrice
-    | undefined,
-  Asset extends CryptoCurrency | Nft = CryptoCurrency | Nft,
-> = AccountAction<Action, Source, Account, Price, Asset, 'out'>
+export type AccountActionBridgeFrom = z.infer<
+  typeof accountActionBridgeFromSchema
+>

package/actions/types/bridgeTo.ts

@@ -1,23 +1,9 @@
-import type { CryptoCurrency, CryptoCurrencyPrice, Nft } from '../../assets'
-import type { AccountAction, NormalAction } from './common'
+import type { z } from 'zod'
+import type {
+  accountActionBridgeToSchema,
+  normalActionBridgeToSchema,
+} from '../schemas'
 
-export type Action = 'bridge-to'
+export type NormalActionBridgeTo = z.infer<typeof normalActionBridgeToSchema>
 
-export type NormalActionBridgeTo<
-  Account = unknown,
-  // TODO crypto 以外の価格にも対応させる
-  Price extends CryptoCurrencyPrice | undefined =
-    | CryptoCurrencyPrice
-    | undefined,
-  Asset extends CryptoCurrency | Nft = CryptoCurrency | Nft,
-> = NormalAction<Action, Account, Price, Asset, 'in'>
-
-export type AccountActionBridgeTo<
-  Account = unknown,
-  Source extends string = string,
-  // TODO crypto 以外の価格にも対応させる
-  Price extends CryptoCurrencyPrice | undefined =
-    | CryptoCurrencyPrice
-    | undefined,
-  Asset extends CryptoCurrency | Nft = CryptoCurrency | Nft,
-> = AccountAction<Action, Source, Account, Price, Asset, 'in'>
+export type AccountActionBridgeTo = z.infer<typeof accountActionBridgeToSchema>

package/actions/types/buyNft.ts

@@ -1,34 +1,9 @@
+import type { z } from 'zod'
 import type {
-  CryptoCurrency,
-  CryptoCurrencyPrice,
-  FiatCurrency,
-  Nft,
-} from '../../assets'
-import type { AccountAction, NormalAction } from './common'
+  accountActionBuyNftSchema,
+  normalActionBuyNftSchema,
+} from '../schemas'
 
-type Action = 'buy-nft'
+export type NormalActionBuyNft = z.infer<typeof normalActionBuyNftSchema>
 
-export type NormalActionBuyNft<
-  Account = unknown,
-  // TODO crypto 以外の価格にも対応させる
-  Price extends CryptoCurrencyPrice | undefined =
-    | CryptoCurrencyPrice
-    | undefined,
-  Asset extends CryptoCurrency | FiatCurrency | Nft =
-    | CryptoCurrency
-    | FiatCurrency
-    | Nft,
-> = NormalAction<Action, Account, Price, Asset, 'in' | 'out'>
-
-export type AccountActionBuyNft<
-  Account = unknown,
-  Source extends string = string,
-  // TODO crypto 以外の価格にも対応させる
-  Price extends CryptoCurrencyPrice | undefined =
-    | CryptoCurrencyPrice
-    | undefined,
-  Asset extends CryptoCurrency | FiatCurrency | Nft =
-    | CryptoCurrency
-    | FiatCurrency
-    | Nft,
-> = AccountAction<Action, Source, Account, Price, Asset, 'in' | 'out'>
+export type AccountActionBuyNft = z.infer<typeof accountActionBuyNftSchema>

package/actions/types/crossActionBundle.ts

@@ -0,0 +1,4 @@
+import type { z } from 'zod'
+import type { crossActionBundleSchema } from '../schemas'
+
+export type CrossActionBundle = z.infer<typeof crossActionBundleSchema>

package/actions/types/crossReplace.ts

@@ -0,0 +1,13 @@
+import type { z } from 'zod'
+import type {
+  accountActionCrossReplaceSchema,
+  normalActionCrossReplaceSchema,
+} from '../schemas'
+
+export type NormalActionCrossReplace = z.infer<
+  typeof normalActionCrossReplaceSchema
+>
+
+export type AccountActionCrossReplace = z.infer<
+  typeof accountActionCrossReplaceSchema
+>

package/actions/types/crossTrade.ts

@@ -0,0 +1,13 @@
+import type { z } from 'zod'
+import type {
+  accountActionCrossTradeSchema,
+  normalActionCrossTradeSchema,
+} from '../schemas'
+
+export type NormalActionCrossTrade = z.infer<
+  typeof normalActionCrossTradeSchema
+>
+
+export type AccountActionCrossTrade = z.infer<
+  typeof accountActionCrossTradeSchema
+>

package/actions/types/deposit.ts

@@ -1,23 +1,9 @@
-import type { CryptoCurrency, CryptoCurrencyPrice, Nft } from '../../assets'
-import type { AccountAction, NormalAction } from './common'
+import type { z } from 'zod'
+import type {
+  accountActionDepositSchema,
+  normalActionDepositSchema,
+} from '../schemas'
 
-export type Action = 'deposit'
+export type NormalActionDeposit = z.infer<typeof normalActionDepositSchema>
 
-export type NormalActionDeposit<
-  Account = unknown,
-  // TODO crypto 以外の価格にも対応させる
-  Price extends CryptoCurrencyPrice | undefined =
-    | CryptoCurrencyPrice
-    | undefined,
-  Asset extends CryptoCurrency | Nft = CryptoCurrency | Nft,
-> = NormalAction<Action, Account, Price, Asset, 'out'>
-
-export type AccountActionDeposit<
-  Account = unknown,
-  Source extends string = string,
-  // TODO crypto 以外の価格にも対応させる
-  Price extends CryptoCurrencyPrice | undefined =
-    | CryptoCurrencyPrice
-    | undefined,
-  Asset extends CryptoCurrency | Nft = CryptoCurrency | Nft,
-> = AccountAction<Action, Source, Account, Price, Asset, 'out'>
+export type AccountActionDeposit = z.infer<typeof accountActionDepositSchema>

package/actions/types/depositWithBond.ts

@@ -1,23 +1,13 @@
-import type { CryptoCurrency, CryptoCurrencyPrice, Nft } from '../../assets'
-import type { AccountAction, NormalAction } from './common'
+import type { z } from 'zod'
+import type {
+  accountActionDepositWithBondSchema,
+  normalActionDepositWithBondSchema,
+} from '../schemas'
 
-type Action = 'deposit-with-bond'
+export type NormalActionDepositWithBond = z.infer<
+  typeof normalActionDepositWithBondSchema
+>
 
-export type NormalActionDepositWithBond<
-  Account = unknown,
-  // TODO crypto 以外の価格にも対応させる
-  Price extends CryptoCurrencyPrice | undefined =
-    | CryptoCurrencyPrice
-    | undefined,
-  Asset extends CryptoCurrency | Nft = CryptoCurrency | Nft,
-> = NormalAction<Action, Account, Price, Asset, 'in' | 'out'>
-
-export type AccountActionDepositWithBond<
-  Account = unknown,
-  Source extends string = string,
-  // TODO crypto 以外の価格にも対応させる
-  Price extends CryptoCurrencyPrice | undefined =
-    | CryptoCurrencyPrice
-    | undefined,
-  Asset extends CryptoCurrency | Nft = CryptoCurrency | Nft,
-> = AccountAction<Action, Source, Account, Price, Asset, 'in' | 'out'>
+export type AccountActionDepositWithBond = z.infer<
+  typeof accountActionDepositWithBondSchema
+>

package/actions/types/failTx.ts

@@ -0,0 +1,9 @@
+import type { z } from 'zod'
+import type {
+  accountActionFailTxSchema,
+  normalActionFailTxSchema,
+} from '../schemas'
+
+export type NormalActionFailTx = z.infer<typeof normalActionFailTxSchema>
+
+export type AccountActionFailTx = z.infer<typeof accountActionFailTxSchema>

package/actions/types/fee.ts

@@ -0,0 +1,6 @@
+import type { z } from 'zod'
+import type { accountActionFeeSchema, normalActionFeeSchema } from '../schemas'
+
+export type NormalActionFee = z.infer<typeof normalActionFeeSchema>
+
+export type AccountActionFee = z.infer<typeof accountActionFeeSchema>

package/actions/types/freeMintNft.ts

@@ -1,20 +1,15 @@
-import type { Nft } from '../../assets'
-import type { AccountAction, NormalAction } from './common'
+import type { z } from 'zod'
+import type {
+  accountActionFreeMintNftSchema,
+  normalActionFreeMintNftSchema,
+} from '../schemas'
 
 export type Action = 'free-mint-nft'
 
-// TODO crypto 以外の価格にも対応させる
-/** asset transfer */
-export type NormalActionFreeMintNft<Account = unknown> = NormalAction<
-  Action,
-  Account,
-  undefined,
-  Nft
+export type NormalActionFreeMintNft = z.infer<
+  typeof normalActionFreeMintNftSchema
 >
 
-// TODO crypto 以外の価格にも対応させる
-/** transfer from account to others */
-export type AccountActionFreeMintNft<
-  Account = unknown,
-  Source extends string = string,
-> = AccountAction<Action, Source, Account, undefined, Nft, 'in'>
+export type AccountActionFreeMintNft = z.infer<
+  typeof accountActionFreeMintNftSchema
+>

package/actions/types/ignore.ts

@@ -0,0 +1,4 @@
+import type { z } from 'zod'
+import type { accountActionIgnoreSchema } from '../schemas'
+
+export type AccountActionIgnore = z.infer<typeof accountActionIgnoreSchema>

package/actions/types/income.ts

@@ -1,21 +1,4 @@
-import type {
-  CryptoCurrency,
-  CryptoCurrencyPrice,
-  FiatCurrency,
-  Nft,
-} from '../../assets'
-import type { AccountAction } from './common'
+import type { z } from 'zod'
+import type { accountActionIncomeSchema } from '../schemas'
 
-/** income */
-export type AccountActionIncome<
-  Account = unknown,
-  Source extends string = string,
-  // TODO crypto 以外の価格にも対応させる
-  Price extends CryptoCurrencyPrice | undefined =
-    | CryptoCurrencyPrice
-    | undefined,
-  Asset extends CryptoCurrency | FiatCurrency | Nft =
-    | CryptoCurrency
-    | FiatCurrency
-    | Nft,
-> = AccountAction<'income', Source, Account, Price, Asset, 'in'>
+export type AccountActionIncome = z.infer<typeof accountActionIncomeSchema>