@0xkoaj/sdk 0.0.1-beta.1 → 0.0.1-beta.10

package/dist/types.d.ts

@@ -0,0 +1,99 @@
+import { ArrayOneOrMoreReadonly, If, KeysWithValue } from './utility-types';
+import { StringValue } from 'ms';
+export type Address = string;
+export type TokenAddress = Address;
+export type ChainId = number | string;
+export type TimeString = StringValue;
+export type Timestamp = number;
+export type BigIntish = string | number | bigint;
+export type EVMChain = Readonly<{
+    chainId: number;
+    name: string;
+    ids: ArrayOneOrMoreReadonly<string>;
+    nativeCurrency: {
+        symbol: string;
+        name: string;
+    };
+    wToken: Lowercase<Address>;
+    publicRPCs: Readonly<string[]>;
+    explorer: string;
+    testnet?: boolean;
+}>;
+export type SolanaChain = Readonly<{
+    chainId: 'solana';
+    name: string;
+    ids: ArrayOneOrMoreReadonly<string>;
+    nativeCurrency: {
+        symbol: string;
+        name: string;
+        mint: string;
+    };
+    wToken: string;
+    publicRPCs: Readonly<string[]>;
+    explorer: string;
+    testnet?: boolean;
+}>;
+export type Chain = EVMChain | SolanaChain;
+export declare function isEVMChain(chain: Chain): chain is EVMChain;
+export declare function isSolanaChain(chain: Chain): chain is SolanaChain;
+export type InputTransaction = {
+    from: Address;
+    to: Address;
+    data?: string;
+    value?: bigint;
+    nonce?: number;
+    maxPriorityFeePerGas?: bigint;
+    maxFeePerGas?: bigint;
+    gasPrice?: bigint;
+    gasLimit?: bigint;
+    type?: number;
+};
+export type AmountsOfToken = {
+    amount: bigint;
+    amountInUnits: string;
+    amountInUSD?: string;
+};
+export type BuiltTransaction = {
+    to: string;
+    data: string;
+    value?: bigint;
+    nonce?: number;
+    maxPriorityFeePerGas?: bigint;
+    maxFeePerGas?: bigint;
+    gasPrice?: bigint;
+    gasLimit?: bigint;
+    type?: number;
+};
+export type ContractCall = {
+    address: Address;
+    abi: {
+        humanReadable: string[];
+    } | {
+        json: readonly any[];
+    };
+    functionName: string;
+    args?: any[];
+};
+export type SupportRecord<Values extends object> = {
+    [K in keyof Values]-?: undefined extends Values[K] ? 'optional' : 'present';
+};
+export type SupportInChain<Values extends object> = {
+    [K in keyof SupportRecord<Values>]: SupportRecord<Values>[K] extends 'present' ? 'present' : 'optional' | 'present';
+};
+export type FieldRequirementOptions = 'required' | 'best effort' | 'can ignore';
+export type FieldsRequirements<Values extends object> = {
+    requirements?: Partial<Record<keyof Values, FieldRequirementOptions>>;
+    default?: FieldRequirementOptions;
+};
+export type DefaultRequirements<Values extends object> = {
+    requirements: {
+        [K in keyof Values]: SupportRecord<Values>[K] extends 'present' ? 'required' : 'best effort';
+    };
+};
+export type BasedOnRequirements<Values extends object, Requirements extends FieldsRequirements<Values>> = Partial<Values> & Required<Pick<Values, PresentKeys<Values, Requirements>>>;
+type PresentKeys<Values extends object, Requirements extends FieldsRequirements<Values>> = Exclude<KeysWithValue<SupportRecord<Values>, 'present'> | RequiredKeys<Values, Requirements>, CanIgnoreKeys<Values, Requirements>> & keyof Values;
+type UnspecifiedKeys<Values extends object, Requirements extends FieldsRequirements<Values>> = Exclude<keyof Values, undefined extends Requirements['requirements'] ? never : keyof NonNullable<Requirements['requirements']>>;
+type RequiredKeys<Values extends object, Requirements extends FieldsRequirements<Values>> = (undefined extends Requirements['requirements'] ? never : KeysWithValue<NonNullable<Requirements['requirements']>, 'required'>) | If<IsDefault<Requirements, 'required'>, UnspecifiedKeys<Values, Requirements>>;
+type CanIgnoreKeys<Values extends object, Requirements extends FieldsRequirements<Values>> = (undefined extends Requirements['requirements'] ? never : KeysWithValue<NonNullable<Requirements['requirements']>, 'can ignore'>) | If<IsDefault<Requirements, 'can ignore'>, UnspecifiedKeys<Values, Requirements>>;
+type IsDefault<Requirements extends FieldsRequirements<object>, Check extends FieldRequirementOptions> = Requirements['default'] extends Check ? true : false;
+export {};

package/dist/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSolanaChain = exports.isEVMChain = void 0;
+// Type guards
+function isEVMChain(chain) {
+    return typeof chain.chainId === 'number';
+}
+exports.isEVMChain = isEVMChain;
+function isSolanaChain(chain) {
+    return chain.chainId === 'solana';
+}
+exports.isSolanaChain = isSolanaChain;
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;AAqCA,cAAc;AACd,SAAgB,UAAU,CAAC,KAAY;IACrC,OAAO,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ,CAAC;AAC3C,CAAC;AAFD,gCAEC;AAED,SAAgB,aAAa,CAAC,KAAY;IACxC,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ,CAAC;AACpC,CAAC;AAFD,sCAEC"}

package/dist/utility-types.d.ts

@@ -0,0 +1,46 @@
+export type Only<T, U> = {
+    [P in keyof T]: T[P];
+} & {
+    [P in keyof U]?: never;
+};
+export type Either<T, U> = Only<T, U> | Only<U, T>;
+export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+export type ArrayOneOrMore<T> = {
+    0: T;
+} & Array<T>;
+export type ArrayTwoOrMore<T> = {
+    0: T;
+    1: T;
+} & Array<T>;
+export type ArrayOneOrMoreReadonly<T> = {
+    0: T;
+} & Readonly<Array<T>>;
+export type ExcludeKeysWithTypeOf<T, V> = {
+    [K in keyof T]: Exclude<T[K], undefined> extends V ? never : K;
+}[keyof T];
+export type Without<T, V> = Pick<T, ExcludeKeysWithTypeOf<T, V>>;
+export type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+export type PartialOnly<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type KeysWithValue<T extends Record<string, any>, V> = {
+    [K in keyof T]: T[K] extends V ? K : never;
+}[keyof T];
+export type If<Condition extends boolean, IfTrue> = true extends Condition ? IfTrue : never;
+export type UnionMerge<T extends object> = {
+    [k in CommonKeys<T>]: PickTypeOf<T, k>;
+} & {
+    [k in NonCommonKeys<T>]?: PickTypeOf<T, k>;
+};
+export type StringifyBigInt<T extends any> = T extends object ? {
+    [K in keyof T]: bigint extends T[K] ? `${bigint}` : StringifyBigInt<T[K]>;
+} : T;
+type CommonKeys<T extends object> = keyof T;
+type AllKeys<T> = T extends any ? keyof T : never;
+type Subtract<A, C> = A extends C ? never : A;
+type NonCommonKeys<T extends object> = Subtract<AllKeys<T>, CommonKeys<T>>;
+type PickType<T, K extends AllKeys<T>> = T extends {
+    [k in K]?: any;
+} ? T[K] : undefined;
+type PickTypeOf<T, K extends string | number | symbol> = K extends AllKeys<T> ? PickType<T, K> : never;
+export {};

package/dist/utility-types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=utility-types.js.map

package/dist/utility-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility-types.js","sourceRoot":"","sources":["../src/utility-types.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xkoaj/sdk",
-  "version": "0.0.1-beta.1",
+  "version": "0.0.1-beta.10",
   "contributors": [],
   "main": "./dist/index.js",
   "files": [
@@ -11,6 +11,7 @@
     "lint:check": "prettier --check .",
     "lint:fix": "sort-package-json && prettier --write .",
     "prepare": "husky install",
+    "prepublishOnly": "npm run build",
     "script": "ts-node -r tsconfig-paths/register",
     "test": "jest --forceExit --detectOpenHandles --verbose",
     "test:integration": "jest --forceExit --detectOpenHandles --verbose --testPathPattern=test/integration",