sushi 6.0.28 → 6.1.0

package/_types/generic/currency/serialized-currency.d.ts

@@ -2,10 +2,11 @@ import * as z from 'zod';
 import { serializedEvmCurrencySchema } from '../../evm/currency/currency.js';
 import type { serializedEvmTokenSchema } from '../../evm/currency/token.js';
 import type { serializedEvmNativeSchema } from '../../evm/index.js';
+import { serializedKvmTokenSchema } from '../../kvm/index.js';
 import { serializedMvmTokenSchema } from '../../mvm/currency/token.js';
 import { serializedTvmCurrencySchema, type serializedTvmNativeSchema, type serializedTvmTokenSchema } from '../../tvm/index.js';
 import type { CurrencyMetadata } from './currency.js';
-export type SerializedCurrencySchema<TMetadata extends CurrencyMetadata = CurrencyMetadata> = ReturnType<typeof serializedEvmTokenSchema<TMetadata> | typeof serializedEvmNativeSchema<TMetadata> | typeof serializedEvmCurrencySchema<TMetadata> | typeof serializedMvmTokenSchema<TMetadata> | typeof serializedTvmTokenSchema<TMetadata> | typeof serializedTvmNativeSchema<TMetadata> | typeof serializedTvmCurrencySchema<TMetadata> | typeof serializedCurrencySchema<TMetadata>>;
+export type SerializedCurrencySchema<TMetadata extends CurrencyMetadata = CurrencyMetadata> = ReturnType<typeof serializedEvmTokenSchema<TMetadata> | typeof serializedEvmNativeSchema<TMetadata> | typeof serializedEvmCurrencySchema<TMetadata> | typeof serializedMvmTokenSchema<TMetadata> | typeof serializedTvmTokenSchema<TMetadata> | typeof serializedTvmNativeSchema<TMetadata> | typeof serializedTvmCurrencySchema<TMetadata> | typeof serializedCurrencySchema<TMetadata> | typeof serializedKvmTokenSchema<TMetadata>>;
 export declare const serializedCurrencySchema: <TMetadata extends {} = CurrencyMetadata>(opts?: {
     metadata?: z.ZodType<TMetadata>;
 }) => z.ZodUnion<[z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
@@ -198,6 +199,46 @@ export declare const serializedCurrencySchema: <TMetadata extends {} = CurrencyM
     decimals: z.ZodNumber;
     type: z.ZodLiteral<"native">;
     metadata: z.ZodType<TMetadata, z.ZodTypeDef, TMetadata>;
-}>[k_9]; } : never>]>]>;
+}>[k_9]; } : never>]>, z.ZodObject<{
+    chainId: z.ZodEffects<z.ZodNumber, -3, number>;
+    address: z.ZodEffects<z.ZodString, import("../../kvm/index.js").KvmTokenAddress, string>;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    decimals: z.ZodNumber;
+    type: z.ZodLiteral<"token">;
+    metadata: z.ZodType<TMetadata, z.ZodTypeDef, TMetadata>;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    chainId: z.ZodEffects<z.ZodNumber, -3, number>;
+    address: z.ZodEffects<z.ZodString, import("../../kvm/index.js").KvmTokenAddress, string>;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    decimals: z.ZodNumber;
+    type: z.ZodLiteral<"token">;
+    metadata: z.ZodType<TMetadata, z.ZodTypeDef, TMetadata>;
+}>, any> extends infer T_10 ? { [k_10 in keyof T_10]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    chainId: z.ZodEffects<z.ZodNumber, -3, number>;
+    address: z.ZodEffects<z.ZodString, import("../../kvm/index.js").KvmTokenAddress, string>;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    decimals: z.ZodNumber;
+    type: z.ZodLiteral<"token">;
+    metadata: z.ZodType<TMetadata, z.ZodTypeDef, TMetadata>;
+}>, any>[k_10]; } : never, z.baseObjectInputType<{
+    chainId: z.ZodEffects<z.ZodNumber, -3, number>;
+    address: z.ZodEffects<z.ZodString, import("../../kvm/index.js").KvmTokenAddress, string>;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    decimals: z.ZodNumber;
+    type: z.ZodLiteral<"token">;
+    metadata: z.ZodType<TMetadata, z.ZodTypeDef, TMetadata>;
+}> extends infer T_11 ? { [k_11 in keyof T_11]: z.baseObjectInputType<{
+    chainId: z.ZodEffects<z.ZodNumber, -3, number>;
+    address: z.ZodEffects<z.ZodString, import("../../kvm/index.js").KvmTokenAddress, string>;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    decimals: z.ZodNumber;
+    type: z.ZodLiteral<"token">;
+    metadata: z.ZodType<TMetadata, z.ZodTypeDef, TMetadata>;
+}>[k_11]; } : never>]>;
 export type SerializedCurrency<TMetadata extends CurrencyMetadata = CurrencyMetadata> = z.infer<ReturnType<typeof serializedCurrencySchema<TMetadata>>>;
 //# sourceMappingURL=serialized-currency.d.ts.map

package/_types/generic/currency/serialized-currency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serialized-currency.d.ts","sourceRoot":"","sources":["../../../generic/currency/serialized-currency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAA;AAC5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAA;AAC3E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAA;AACnE,OAAO,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAA;AACtE,OAAO,EACL,2BAA2B,EAC3B,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC9B,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAErD,MAAM,MAAM,wBAAwB,CAClC,SAAS,SAAS,gBAAgB,GAAG,gBAAgB,IACnD,UAAU,CACV,OAAO,wBAAwB,CAAC,SAAS,CAAC,GAC1C,OAAO,yBAAyB,CAAC,SAAS,CAAC,GAC3C,OAAO,2BAA2B,CAAC,SAAS,CAAC,GAC7C,OAAO,wBAAwB,CAAC,SAAS,CAAC,GAC1C,OAAO,wBAAwB,CAAC,SAAS,CAAC,GAC1C,OAAO,yBAAyB,CAAC,SAAS,CAAC,GAC3C,OAAO,2BAA2B,CAAC,SAAS,CAAC,GAC7C,OAAO,wBAAwB,CAAC,SAAS,CAAC,CAC7C,CAAA;AAED,eAAO,MAAM,wBAAwB,GACnC,SAAS,SAAS,EAAE,GAAG,gBAAgB,EAEvC,OAAM;IAAE,QAAQ,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;CAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAM5C,CAAA;AAEJ,MAAM,MAAM,kBAAkB,CAC5B,SAAS,SAAS,gBAAgB,GAAG,gBAAgB,IACnD,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,wBAAwB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA"}
+{"version":3,"file":"serialized-currency.d.ts","sourceRoot":"","sources":["../../../generic/currency/serialized-currency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAA;AAC5E,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAA;AAC3E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAA;AACnE,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAA;AAC7D,OAAO,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAA;AACtE,OAAO,EACL,2BAA2B,EAC3B,KAAK,yBAAyB,EAC9B,KAAK,wBAAwB,EAC9B,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAErD,MAAM,MAAM,wBAAwB,CAClC,SAAS,SAAS,gBAAgB,GAAG,gBAAgB,IACnD,UAAU,CACV,OAAO,wBAAwB,CAAC,SAAS,CAAC,GAC1C,OAAO,yBAAyB,CAAC,SAAS,CAAC,GAC3C,OAAO,2BAA2B,CAAC,SAAS,CAAC,GAC7C,OAAO,wBAAwB,CAAC,SAAS,CAAC,GAC1C,OAAO,wBAAwB,CAAC,SAAS,CAAC,GAC1C,OAAO,yBAAyB,CAAC,SAAS,CAAC,GAC3C,OAAO,2BAA2B,CAAC,SAAS,CAAC,GAC7C,OAAO,wBAAwB,CAAC,SAAS,CAAC,GAC1C,OAAO,wBAAwB,CAAC,SAAS,CAAC,CAC7C,CAAA;AAED,eAAO,MAAM,wBAAwB,GACnC,SAAS,SAAS,EAAE,GAAG,gBAAgB,EAEvC,OAAM;IAAE,QAAQ,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;CAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAO5C,CAAA;AAEJ,MAAM,MAAM,kBAAkB,CAC5B,SAAS,SAAS,gBAAgB,GAAG,gBAAgB,IACnD,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,wBAAwB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA"}

package/_types/kvm/chain/chains.d.ts

@@ -0,0 +1,37 @@
+export declare const kvmChains: readonly [{
+    readonly chainId: -3;
+    readonly key: "kadena";
+    readonly shortName: "kda";
+    readonly name: "Kadena";
+    readonly blockExplorers: {
+        readonly default: {
+            readonly name: "Kadena Explorer";
+            readonly url: "https://explorer.chainweb.com/mainnet";
+        };
+    };
+    readonly netType: "mainnet";
+} & {
+    readonly type: "kvm";
+    readonly getTransactionUrl: (input: string) => string;
+    readonly getAccountUrl: (input: string) => string;
+    readonly getTokenUrl: (input: string) => string;
+}];
+export declare const kvmChainIds: -3[];
+export type KvmChainId = (typeof kvmChainIds)[number];
+export declare const KvmChainId: {
+    KADENA: -3;
+};
+export declare function isKvmChainId(chainId: number): chainId is KvmChainId;
+export declare function getKvmChainById<C extends KvmChainId>(chainId: C): Extract<(typeof kvmChains)[number], {
+    chainId: C;
+}>;
+export type KvmMainnetChainId = Extract<(typeof kvmChains)[number], {
+    netType: 'mainnet';
+}>['chainId'];
+export declare function isKvmMainnetChainId(chainId: number): chainId is KvmMainnetChainId;
+export type KvmChainKey = (typeof kvmChains)[number]['key'];
+export declare function isKvmChainKey(key: string): key is KvmChainKey;
+export declare function getKvmChainByKey<C extends KvmChainKey>(key: C): Extract<(typeof kvmChains)[number], {
+    key: C;
+}>;
+//# sourceMappingURL=chains.d.ts.map

package/_types/kvm/chain/chains.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chains.d.ts","sourceRoot":"","sources":["../../../kvm/chain/chains.ts"],"names":[],"mappings":"AAkBA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;EAAoB,CAAA;AAE1C,eAAO,MAAM,WAAW,MAEvB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAA;AAYrD,eAAO,MAAM,UAAU;;CAYtB,CAAA;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,IAAI,UAAU,CAEnE;AAED,wBAAgB,eAAe,CAAC,CAAC,SAAS,UAAU,EAAE,OAAO,EAAE,CAAC,GACE,OAAO,CACrE,CAAC,OAAO,SAAS,EAAE,MAAM,CAAC,EAC1B;IAAE,OAAO,EAAE,CAAC,CAAA;CAAE,CACf,CACF;AAGD,MAAM,MAAM,iBAAiB,GAAG,OAAO,CACrC,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,EAC1B;IAAE,OAAO,EAAE,SAAS,CAAA;CAAE,CACvB,CAAC,SAAS,CAAC,CAAA;AAEZ,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,GACd,OAAO,IAAI,iBAAiB,CAI9B;AAGD,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAA;AAE3D,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,WAAW,CAE7D;AAED,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,WAAW,EAAE,GAAG,EAAE,CAAC,GACJ,OAAO,CAC7D,CAAC,OAAO,SAAS,EAAE,MAAM,CAAC,EAC1B;IAAE,GAAG,EAAE,CAAC,CAAA;CAAE,CACX,CACF"}

package/_types/kvm/chain/define-chain.d.ts

@@ -0,0 +1,14 @@
+import type { BlockExplorers, Chain, NetType } from '../../generic/chain/interface.js';
+import type { KvmChainId, KvmChainKey } from './chains.js';
+export type KvmChainType = 'kvm';
+type KvmChainBase<TChainId extends number, TChainKey extends string> = Chain<KvmChainType, TChainId, TChainKey, Readonly<string>, Readonly<string>, NetType, BlockExplorers, string, string>;
+export type KvmChain = KvmChainBase<KvmChainId, KvmChainKey>;
+type KvmChainInput = Omit<KvmChainBase<number, string>, 'type' | 'getTransactionUrl' | 'getAccountUrl' | 'getTokenUrl' | 'networdId'>;
+export declare function defineKvmChain<const T extends KvmChainInput>(chain: T): T & {
+    readonly type: "kvm";
+    readonly getTransactionUrl: (input: string) => string;
+    readonly getAccountUrl: (input: string) => string;
+    readonly getTokenUrl: (input: string) => string;
+};
+export {};
+//# sourceMappingURL=define-chain.d.ts.map

package/_types/kvm/chain/define-chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-chain.d.ts","sourceRoot":"","sources":["../../../kvm/chain/define-chain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,KAAK,EACL,OAAO,EACR,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAE1D,MAAM,MAAM,YAAY,GAAG,KAAK,CAAA;AAEhC,KAAK,YAAY,CAAC,QAAQ,SAAS,MAAM,EAAE,SAAS,SAAS,MAAM,IAAI,KAAK,CAC1E,YAAY,EAEZ,QAAQ,EACR,SAAS,EACT,QAAQ,CAAC,MAAM,CAAC,EAChB,QAAQ,CAAC,MAAM,CAAC,EAChB,OAAO,EACP,cAAc,EACd,MAAM,EACN,MAAM,CACP,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,YAAY,CAAC,UAAU,EAAE,WAAW,CAAC,CAAA;AAE5D,KAAK,aAAa,GAAG,IAAI,CACvB,YAAY,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,MAAM,GAAG,mBAAmB,GAAG,eAAe,GAAG,aAAa,GAAG,WAAW,CAC7E,CAAA;AAED,wBAAgB,cAAc,CAAC,KAAK,CAAC,CAAC,SAAS,aAAa,EAAE,KAAK,EAAE,CAAC;;wCAIvC,MAAM;oCAEV,MAAM;kCAER,MAAM;EAG9B"}

package/_types/kvm/chain/index.d.ts

@@ -0,0 +1,3 @@
+export * from './chains.js';
+export * from './define-chain.js';
+//# sourceMappingURL=index.d.ts.map

package/_types/kvm/chain/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../kvm/chain/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,mBAAmB,CAAA"}

package/_types/kvm/currency/index.d.ts

@@ -0,0 +1,2 @@
+export * from './token.js';
+//# sourceMappingURL=index.d.ts.map

package/_types/kvm/currency/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../kvm/currency/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA"}

package/_types/kvm/currency/token.d.ts

@@ -0,0 +1,63 @@
+import * as z from 'zod';
+import type { CurrencyMetadata } from '../../generic/currency/currency.js';
+import { Token } from '../../generic/currency/token.js';
+import { type KvmChainId } from '../chain/chains.js';
+export type KvmTokenAddress = `${string}.${string}` | 'coin';
+export declare function isKvmTokenAddress(address: string): address is KvmTokenAddress;
+export type KvmTokenOrigin = 'native';
+export declare class KvmToken<TMetadata extends CurrencyMetadata = Record<string, unknown>> extends Token<KvmChainId, KvmTokenAddress, TMetadata> {
+    readonly origin: KvmTokenOrigin | undefined;
+    constructor({ origin, ...rest }: {
+        origin?: KvmTokenOrigin | undefined;
+    } & ConstructorParameters<typeof Token<KvmChainId, KvmTokenAddress, TMetadata>>[0]);
+    wrap(): KvmToken<TMetadata>;
+    toJSON(): SerializedKvmToken<TMetadata>;
+    static fromJSON<TMetadata extends CurrencyMetadata>(data: Omit<SerializedKvmToken<TMetadata>, 'metadata'> & {
+        metadata?: TMetadata;
+    }): KvmToken<TMetadata>;
+}
+export declare const serializedKvmTokenSchema: <TMetadata extends {} = CurrencyMetadata>({ metadata, }?: {
+    metadata?: z.ZodType<TMetadata>;
+}) => z.ZodObject<{
+    chainId: z.ZodEffects<z.ZodNumber, -3, number>;
+    address: z.ZodEffects<z.ZodString, KvmTokenAddress, string>;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    decimals: z.ZodNumber;
+    type: z.ZodLiteral<"token">;
+    metadata: z.ZodType<TMetadata>;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    chainId: z.ZodEffects<z.ZodNumber, -3, number>;
+    address: z.ZodEffects<z.ZodString, KvmTokenAddress, string>;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    decimals: z.ZodNumber;
+    type: z.ZodLiteral<"token">;
+    metadata: z.ZodType<TMetadata>;
+}>, any> extends infer T ? { [k in keyof T]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    chainId: z.ZodEffects<z.ZodNumber, -3, number>;
+    address: z.ZodEffects<z.ZodString, KvmTokenAddress, string>;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    decimals: z.ZodNumber;
+    type: z.ZodLiteral<"token">;
+    metadata: z.ZodType<TMetadata>;
+}>, any>[k]; } : never, z.baseObjectInputType<{
+    chainId: z.ZodEffects<z.ZodNumber, -3, number>;
+    address: z.ZodEffects<z.ZodString, KvmTokenAddress, string>;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    decimals: z.ZodNumber;
+    type: z.ZodLiteral<"token">;
+    metadata: z.ZodType<TMetadata>;
+}> extends infer T_1 ? { [k_1 in keyof T_1]: z.baseObjectInputType<{
+    chainId: z.ZodEffects<z.ZodNumber, -3, number>;
+    address: z.ZodEffects<z.ZodString, KvmTokenAddress, string>;
+    symbol: z.ZodString;
+    name: z.ZodString;
+    decimals: z.ZodNumber;
+    type: z.ZodLiteral<"token">;
+    metadata: z.ZodType<TMetadata>;
+}>[k_1]; } : never>;
+export type SerializedKvmToken<TMetadata extends CurrencyMetadata = CurrencyMetadata> = z.infer<ReturnType<typeof serializedKvmTokenSchema<TMetadata>>>;
+//# sourceMappingURL=token.d.ts.map

package/_types/kvm/currency/token.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token.d.ts","sourceRoot":"","sources":["../../../kvm/currency/token.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAA;AAC1E,OAAO,EAAE,KAAK,EAAE,MAAM,iCAAiC,CAAA;AAEvD,OAAO,EAAE,KAAK,UAAU,EAAgB,MAAM,oBAAoB,CAAA;AAElE,MAAM,MAAM,eAAe,GAAG,GAAG,MAAM,IAAI,MAAM,EAAE,GAAG,MAAM,CAAA;AAE5D,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,IAAI,eAAe,CAI7E;AAED,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAA;AAErC,qBAAa,QAAQ,CACnB,SAAS,SAAS,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAC5D,SAAQ,KAAK,CAAC,UAAU,EAAE,eAAe,EAAE,SAAS,CAAC;IACrD,SAAgB,MAAM,EAAE,cAAc,GAAG,SAAS,CAAA;gBAEtC,EACV,MAAM,EACN,GAAG,IAAI,EACR,EAAE;QACD,MAAM,CAAC,EAAE,cAAc,GAAG,SAAS,CAAA;KACpC,GAAG,qBAAqB,CACvB,OAAO,KAAK,CAAC,UAAU,EAAE,eAAe,EAAE,SAAS,CAAC,CACrD,CAAC,CAAC,CAAC;IAKY,IAAI,IAAI,QAAQ,CAAC,SAAS,CAAC;IAI3B,MAAM,IAAI,kBAAkB,CAAC,SAAS,CAAC;IAavD,MAAM,CAAC,QAAQ,CAAC,SAAS,SAAS,gBAAgB,EAChD,IAAI,EAAE,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC,GAAG;QACtD,QAAQ,CAAC,EAAE,SAAS,CAAA;KACrB,GACA,QAAQ,CAAC,SAAS,CAAC;CAGvB;AAED,eAAO,MAAM,wBAAwB,GACnC,SAAS,SAAS,EAAE,GAAG,gBAAgB,EACvC,gBAEC;IAAE,QAAQ,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;CAAO;;;;;;;cAUY,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;;;;;;;;cAApB,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;;;;;;;;cAApB,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;;;;;;;;cAApB,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;;;;;;;;cAApB,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;mBACvE,CAAA;AAEJ,MAAM,MAAM,kBAAkB,CAC5B,SAAS,SAAS,gBAAgB,GAAG,gBAAgB,IACnD,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,wBAAwB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA"}

package/_types/kvm/index.d.ts

@@ -0,0 +1,3 @@
+export * from './chain/index.js';
+export * from './currency/index.js';
+//# sourceMappingURL=index.d.ts.map

package/_types/kvm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../kvm/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAA;AAChC,cAAc,qBAAqB,CAAA"}

package/generic/chain/chains.ts

@@ -1,10 +1,16 @@
 import { evmChains } from '../../evm/chain/index.js'
+import { kvmChains } from '../../kvm/index.js'
 import { mvmChains } from '../../mvm/chain/chains.js'
 import { tvmChains } from '../../tvm/chain/chains.js'
 import type { Replace } from '../types/replace.js'
 import type { UnionToIntersection } from '../types/union-to-intersection.js'
 
-export const chains = [...evmChains, ...mvmChains, ...tvmChains] as const
+export const chains = [
+  ...evmChains,
+  ...mvmChains,
+  ...tvmChains,
+  ...kvmChains,
+] as const
 
 // ChainId
 

package/generic/chain/interface.ts

@@ -1,9 +1,14 @@
 import type { EvmChainType } from '../../evm/chain/define-chain.js'
+import type { KvmChainType } from '../../kvm/chain/define-chain.js'
 import type { MvmChainType } from '../../mvm/chain/define-chain.js'
 import type { TvmChainType } from '../../tvm/chain/define-chain.js'
 import type { ChainId, ChainKey } from './chains.js'
 
-export type ChainType = EvmChainType | MvmChainType | TvmChainType
+export type ChainType =
+  | EvmChainType
+  | MvmChainType
+  | TvmChainType
+  | KvmChainType
 
 export type NetType = 'mainnet' | 'testnet'
 

package/generic/currency/currency.test-d.ts

@@ -4,6 +4,7 @@ import * as z from 'zod'
 import type { EvmChainId } from '~/evm/chain/chains.js'
 import type { EvmCurrency } from '~/evm/currency/currency.js'
 import type { EvmID } from '~/evm/types/id.js'
+import { KvmToken } from '~/kvm/index.js'
 import { EvmNative } from '../../evm/currency/native.js'
 import {
   type EvmAddress,
@@ -85,6 +86,18 @@ describe('generic/currency/currency.ts types', () => {
 
       expectTypeOf(tvmMockToken.wrap()).toEqualTypeOf<TvmToken>()
     })
+
+    it('should return the same chaintype - Kvm', () => {
+      const kvmMockToken = new KvmToken({
+        chainId: -3,
+        symbol: 'KVM',
+        name: 'Kvm Token',
+        decimals: 12,
+        address: 'my-namespace.my-token',
+      })
+
+      expectTypeOf(kvmMockToken.wrap()).toEqualTypeOf<KvmToken>()
+    })
   })
 
   describe('isNative/isToken', () => {

package/generic/currency/serialized-currency.ts

@@ -2,6 +2,7 @@ import * as z from 'zod'
 import { serializedEvmCurrencySchema } from '../../evm/currency/currency.js'
 import type { serializedEvmTokenSchema } from '../../evm/currency/token.js'
 import type { serializedEvmNativeSchema } from '../../evm/index.js'
+import { serializedKvmTokenSchema } from '../../kvm/index.js'
 import { serializedMvmTokenSchema } from '../../mvm/currency/token.js'
 import {
   serializedTvmCurrencySchema,
@@ -21,6 +22,7 @@ export type SerializedCurrencySchema<
   | typeof serializedTvmNativeSchema<TMetadata>
   | typeof serializedTvmCurrencySchema<TMetadata>
   | typeof serializedCurrencySchema<TMetadata>
+  | typeof serializedKvmTokenSchema<TMetadata>
 >
 
 export const serializedCurrencySchema = <
@@ -32,6 +34,7 @@ export const serializedCurrencySchema = <
     serializedEvmCurrencySchema(opts),
     serializedMvmTokenSchema(opts),
     serializedTvmCurrencySchema(opts),
+    serializedKvmTokenSchema(opts),
   ])
 
 export type SerializedCurrency<

package/kvm/chain/chains.ts

@@ -0,0 +1,88 @@
+import type { Replace } from '../../generic/types/replace.js'
+import type { UnionToIntersection } from '../../generic/types/union-to-intersection.js'
+import { defineKvmChain } from './define-chain.js'
+
+const kadena = defineKvmChain({
+  chainId: -3,
+  key: 'kadena',
+  shortName: 'kda',
+  name: 'Kadena',
+  blockExplorers: {
+    default: {
+      name: 'Kadena Explorer',
+      url: 'https://explorer.chainweb.com/mainnet',
+    },
+  },
+  netType: 'mainnet',
+})
+
+export const kvmChains = [kadena] as const
+
+export const kvmChainIds = /* @__PURE__ */ kvmChains.map(
+  (chain) => chain.chainId,
+)
+
+export type KvmChainId = (typeof kvmChainIds)[number]
+
+type KvmChainIdMap = UnionToIntersection<
+  (typeof kvmChains)[number] extends infer I
+    ? I extends { key: infer K; chainId: infer C }
+      ? K extends string
+        ? { [key in K as Uppercase<Replace<key, '-', '_'>>]: C }
+        : never
+      : never
+    : never
+>
+
+export const KvmChainId = /* @__PURE__ */ new Proxy<KvmChainIdMap>(
+  {} as KvmChainIdMap,
+  {
+    get: (_: unknown, key: keyof KvmChainIdMap) => {
+      const _key = key.toLowerCase().replace(/_/g, '-') as KvmChainKey
+      const chain = kvmChains.find((chain) => chain.key === _key)
+
+      if (!chain) return undefined
+
+      return chain.chainId
+    },
+  },
+)
+
+export function isKvmChainId(chainId: number): chainId is KvmChainId {
+  return kvmChains.some((chain) => chain.chainId === chainId)
+}
+
+export function getKvmChainById<C extends KvmChainId>(chainId: C) {
+  return kvmChains.find((chain) => chain.chainId === chainId)! as Extract<
+    (typeof kvmChains)[number],
+    { chainId: C }
+  >
+}
+
+// KvmMainnetChainId
+export type KvmMainnetChainId = Extract<
+  (typeof kvmChains)[number],
+  { netType: 'mainnet' }
+>['chainId']
+
+export function isKvmMainnetChainId(
+  chainId: number,
+): chainId is KvmMainnetChainId {
+  return kvmChains.some(
+    (chain) => chain.chainId === chainId && chain.netType === 'mainnet',
+  )
+}
+
+// KvmChainKey
+export type KvmChainKey = (typeof kvmChains)[number]['key']
+
+export function isKvmChainKey(key: string): key is KvmChainKey {
+  return kvmChains.some((chain) => chain.key === key)
+}
+
+export function getKvmChainByKey<C extends KvmChainKey>(key: C) {
+  return kvmChains.find((chain) => chain.key === key)! as Extract<
+    (typeof kvmChains)[number],
+    { key: C }
+  >
+}

package/kvm/chain/define-chain.ts

@@ -0,0 +1,41 @@
+import type {
+  BlockExplorers,
+  Chain,
+  NetType,
+} from '../../generic/chain/interface.js'
+import type { KvmChainId, KvmChainKey } from './chains.js'
+
+export type KvmChainType = 'kvm'
+
+type KvmChainBase<TChainId extends number, TChainKey extends string> = Chain<
+  KvmChainType,
+  // @ts-ignore infinite loop
+  TChainId,
+  TChainKey,
+  Readonly<string>,
+  Readonly<string>,
+  NetType,
+  BlockExplorers,
+  string,
+  string
+>
+
+export type KvmChain = KvmChainBase<KvmChainId, KvmChainKey>
+
+type KvmChainInput = Omit<
+  KvmChainBase<number, string>,
+  'type' | 'getTransactionUrl' | 'getAccountUrl' | 'getTokenUrl' | 'networdId'
+>
+
+export function defineKvmChain<const T extends KvmChainInput>(chain: T) {
+  return {
+    ...chain,
+    type: 'kvm' as const,
+    getTransactionUrl: (input: string) =>
+      `${chain.blockExplorers.default.url}/txdetail/${input}`,
+    getAccountUrl: (input: string) =>
+      `${chain.blockExplorers.default.url}/account/${input}`,
+    getTokenUrl: (input: string) =>
+      `${chain.blockExplorers.default.url}/account/${input}`,
+  } as const satisfies KvmChainBase<number, string>
+}

package/kvm/chain/index.ts

@@ -0,0 +1,2 @@
+export * from './chains.js'
+export * from './define-chain.js'

package/kvm/currency/index.ts

@@ -0,0 +1 @@
+export * from './token.js'

package/kvm/currency/token.ts

@@ -0,0 +1,79 @@
+import * as z from 'zod'
+import type { CurrencyMetadata } from '../../generic/currency/currency.js'
+import { Token } from '../../generic/currency/token.js'
+
+import { type KvmChainId, isKvmChainId } from '../chain/chains.js'
+
+export type KvmTokenAddress = `${string}.${string}` | 'coin'
+
+export function isKvmTokenAddress(address: string): address is KvmTokenAddress {
+  if (address === 'coin') return true
+  // `${string}.${string}` - namespace.name - string parts can include alphanumeric characters, underscores, and dashes
+  return !!address.match(/^([A-Za-z0-9_-]+)\.([A-Za-z0-9_-]+)$/)
+}
+
+export type KvmTokenOrigin = 'native'
+
+export class KvmToken<
+  TMetadata extends CurrencyMetadata = Record<string, unknown>,
+> extends Token<KvmChainId, KvmTokenAddress, TMetadata> {
+  public readonly origin: KvmTokenOrigin | undefined
+
+  constructor({
+    origin,
+    ...rest
+  }: {
+    origin?: KvmTokenOrigin | undefined
+  } & ConstructorParameters<
+    typeof Token<KvmChainId, KvmTokenAddress, TMetadata>
+  >[0]) {
+    super(rest)
+    this.origin = origin
+  }
+
+  public override wrap(): KvmToken<TMetadata> {
+    return this
+  }
+
+  public override toJSON(): SerializedKvmToken<TMetadata> {
+    return {
+      chainId: this.chainId,
+      address: this.address,
+      symbol: this.symbol,
+      name: this.name,
+      decimals: this.decimals,
+      type: this.type,
+
+      metadata: this.metadata,
+    } as const
+  }
+
+  static fromJSON<TMetadata extends CurrencyMetadata>(
+    data: Omit<SerializedKvmToken<TMetadata>, 'metadata'> & {
+      metadata?: TMetadata
+    },
+  ): KvmToken<TMetadata> {
+    return new this(data)
+  }
+}
+
+export const serializedKvmTokenSchema = <
+  TMetadata extends {} = CurrencyMetadata,
+>({
+  metadata,
+}: { metadata?: z.ZodType<TMetadata> } = {}) =>
+  z.object({
+    chainId: z.number().int().refine(isKvmChainId),
+    address: z.string().refine(isKvmTokenAddress),
+    symbol: z.string(),
+    name: z.string(),
+    decimals: z.number().int().nonnegative(),
+    type: z.literal('token'),
+
+    metadata: (metadata ||
+      z.record(z.unknown()).optional().default({})) as z.ZodType<TMetadata>,
+  })
+
+export type SerializedKvmToken<
+  TMetadata extends CurrencyMetadata = CurrencyMetadata,
+> = z.infer<ReturnType<typeof serializedKvmTokenSchema<TMetadata>>>

package/kvm/index.ts

@@ -0,0 +1,2 @@
+export * from './chain/index.js'
+export * from './currency/index.js'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sushi",
   "description": "Sushi",
-  "version": "6.0.28",
+  "version": "6.1.0",
   "type": "module",
   "main": "./_cjs/generic/index.js",
   "module": "./_esm/generic/index.js",
@@ -15,6 +15,7 @@
     "evm",
     "mvm",
     "tvm",
+    "kvm",
     "package.json"
   ],
   "exports": {
@@ -42,6 +43,12 @@
       "require": "./_cjs/tvm/index.js",
       "default": "./_esm/tvm/index.js"
     },
+    "./kvm": {
+      "types": "./_types/kvm/index.d.ts",
+      "import": "./_esm/kvm/index.js",
+      "require": "./_cjs/kvm/index.js",
+      "default": "./_esm/kvm/index.js"
+    },
     "./package.json": "./package.json"
   },
   "typesVersions": {
@@ -54,6 +61,9 @@
       ],
       "tvm": [
         "_types/tvm/index.d.ts"
+      ],
+      "kvm": [
+        "_types/kvm/index.d.ts"
       ]
     }
   },