@msafe/sui3-sdk 0.0.2-pre-9f39791.0

package/src/globals/const.ts

@@ -0,0 +1,95 @@
+import { ModelConfig } from '@msafe/sui3-model/common';
+
+export enum MSafeEnv {
+  local = 'local',
+  unit = 'unit',
+  dev = 'dev',
+  prev = 'prev',
+  prod = 'prod',
+}
+
+export interface MSafeConfig {
+  suiClient: {
+    url: string;
+  };
+  backend: DBConfig;
+}
+
+export interface MSafeConfigOptions {
+  suiClient?: {
+    url?: string;
+  };
+  backend?: DBConfig;
+}
+
+// Use pseudo backend for now.
+export type DBConfig = ModelConfig;
+
+export const LOCAL_DATABASE_CONFIG: DBConfig = {
+  type: 'mysql',
+  host: '127.0.0.1',
+  port: 3306,
+  username: 'msafe',
+  password: 'msafe',
+  database: 'msafe_sui_local',
+  logging: false,
+};
+
+export const DEV_DATABASE_CONFIG: DBConfig = {
+  type: 'mysql',
+  host: 'msafe-dev-database.cluster-caos3ssocrx6.us-west-1.rds.amazonaws.com',
+  port: 3306,
+  username: 'msafe',
+  password: 'Momentum.Safe2022',
+  database: 'msafe_sui_dev',
+  logging: false,
+};
+
+export const TESTNET_RPC_URL = 'https://sui-testnet.blockvision.org/v1/2Sgk89ivT64MnKdcGzjmyjY2ndD';
+export const MAINNET_RPC_URL = 'https://sui-mainnet.blockvision.org/v1/2Sgk7NPvqkd7mESYkxF01yX15l7';
+
+export const ENV_CONFIGS = new Map<MSafeEnv, MSafeConfig>([
+  [
+    MSafeEnv.unit,
+    {
+      suiClient: {
+        url: TESTNET_RPC_URL,
+      },
+      backend: LOCAL_DATABASE_CONFIG,
+    },
+  ],
+  [
+    MSafeEnv.local,
+    {
+      suiClient: {
+        url: TESTNET_RPC_URL,
+      },
+      backend: LOCAL_DATABASE_CONFIG,
+    },
+  ],
+  [
+    MSafeEnv.dev,
+    {
+      suiClient: {
+        url: TESTNET_RPC_URL,
+      },
+      backend: DEV_DATABASE_CONFIG,
+    },
+  ],
+]);
+
+export function getMSafeConfig(env: MSafeEnv, options?: MSafeConfigOptions) {
+  const config = ENV_CONFIGS.get(env);
+  if (!config) {
+    throw new Error('Unknown environment');
+  }
+  if (options?.suiClient?.url) {
+    config.suiClient.url = options.suiClient.url;
+  }
+  if (options?.backend) {
+    config.backend = options.backend;
+  }
+  return config;
+}
+
+export const AUTH_SIGN_MESSAGE = 'Welcome to MSafe';

package/src/globals/index.ts

@@ -0,0 +1,2 @@
+export * from './const';
+export * from './MSafeGlobals';

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './core';
+export * from './globals';
+export * from './transactions';
+export * from './types';
+export * from './utils';

package/src/transactions/coin-transfer.ts

@@ -0,0 +1,64 @@
+import { SuiClient } from '@mysten/sui.js/client';
+import { TransactionBlock } from '@mysten/sui.js/transactions';
+
+import { Formatter } from '@/utils/format';
+import { getAllCoins, SUI_COIN } from '@/utils/sui';
+
+export interface IntentionCoinTransfer {
+  txType: 'CoinTransfer';
+  recipient: string;
+  coinType: string;
+  amount: string;
+}
+
+export async function buildCoinTransferTxb(input: {
+  suiClient: SuiClient;
+  sender: string;
+  intention: IntentionCoinTransfer;
+}) {
+  if (Formatter.isSuiStructEqual(input.intention.coinType, SUI_COIN)) {
+    return buildSuiCoinTransferTxb(input);
+  }
+  return buildOtherCoinTransferTxb(input);
+}
+
+function buildSuiCoinTransferTxb(input: { sender: string; intention: IntentionCoinTransfer }): TransactionBlock {
+  const txb = new TransactionBlock();
+  const [coin] = txb.splitCoins(txb.gas, [txb.pure(input.intention.amount)]);
+  txb.transferObjects([coin], txb.pure(input.intention.recipient));
+  txb.setSender(input.sender);
+  return txb;
+}
+
+async function buildOtherCoinTransferTxb(input: {
+  suiClient: SuiClient;
+  sender: string;
+  intention: IntentionCoinTransfer;
+}) {
+  const { suiClient, sender, intention } = input;
+
+  const objs = await getAllCoins({
+    suiClient,
+    owner: sender,
+    coinType: intention.coinType,
+  });
+  if (objs.length === 0) {
+    throw new Error('No valid coin found to send');
+  }
+  const totalBal = objs.reduce((sum, coin) => sum + BigInt(coin.balance), 0n);
+  if (totalBal < BigInt(intention.amount)) {
+    throw new Error('Not enough balance');
+  }
+  const txb = new TransactionBlock();
+  const primary = txb.object(objs[0].coinObjectId);
+  if (objs.length > 1) {
+    txb.mergeCoins(
+      primary,
+      objs.slice(1).map((obj) => txb.object(obj.coinObjectId)),
+    );
+  }
+  const [coin] = txb.splitCoins(primary, [txb.pure(intention.amount)]);
+  txb.transferObjects([coin], txb.pure(intention.recipient));
+  txb.setSender(input.sender);
+  return txb;
+}

package/src/transactions/index.ts

@@ -0,0 +1 @@
+export * from './intention';

package/src/transactions/intention.ts

@@ -0,0 +1,63 @@
+import { SuiClient } from '@mysten/sui.js/client';
+
+import { buildCoinTransferTxb, IntentionCoinTransfer } from '@/transactions/coin-transfer';
+import { buildObjectTransferTxb, IntentionObjectTransfer } from '@/transactions/object-transfer';
+import { buildRejectTxb } from '@/transactions/reject';
+
+export type TxIntention = IntentionObjectTransfer | IntentionCoinTransfer;
+
+// TODO: Refactor later
+export class IntentionHelper {
+  static ser(intention: TxIntention) {
+    return JSON.stringify(intention);
+  }
+
+  static de(val: string): TxIntention {
+    const intention = JSON.parse(val);
+    if (typeof intention !== 'object' || !('txType' in intention)) {
+      throw new Error(`Failed to deserialize intention: ${val}`);
+    }
+    return JSON.parse(val);
+  }
+
+  // TODO: Add gas option here.
+  static buildTxb(input: { suiClient: SuiClient; intention: TxIntention; sender: string }) {
+    switch (input.intention.txType) {
+      case 'CoinTransfer':
+        return buildCoinTransferTxb({
+          suiClient: input.suiClient,
+          sender: input.sender,
+          intention: input.intention as IntentionCoinTransfer,
+        });
+      case 'ObjectTransfer':
+        return buildObjectTransferTxb({
+          suiClient: input.suiClient,
+          sender: input.sender,
+          intention: input.intention as IntentionObjectTransfer,
+        });
+      default:
+        throw new Error(`Unknown tx type: ${input.intention}`);
+    }
+  }
+
+  static getTxType(intention: TxIntention) {
+    switch (intention.txType) {
+      case 'CoinTransfer':
+        return {
+          txType: 'CoinTransfer',
+          txSubType: 'CoinTransfer',
+        };
+      case 'ObjectTransfer':
+        return {
+          txType: 'ObjectTransfer',
+          txSubType: 'ObjectTransfer',
+        };
+      default:
+        throw new Error('Unknown intention type');
+    }
+  }
+
+  static buildRejectTransaction(input: { msafeAddress: string; payloadToReject: string }) {
+    return buildRejectTxb({ sender: input.msafeAddress, payloadToReject: input.payloadToReject });
+  }
+}

package/src/transactions/object-transfer.ts

@@ -0,0 +1,66 @@
+import { SuiClient } from '@mysten/sui.js/client';
+import type { SuiObjectResponse } from '@mysten/sui.js/src/client/types';
+import { TransactionBlock } from '@mysten/sui.js/transactions';
+
+import { Formatter } from '@/utils/format';
+
+export interface IntentionObjectTransfer {
+  txType: 'ObjectTransfer';
+  receiver: string;
+  objectId: string;
+  objectType: string;
+}
+
+export async function buildObjectTransferTxb(input: {
+  suiClient: SuiClient;
+  sender: string;
+  intention: IntentionObjectTransfer;
+}) {
+  await validateObjectTransfer(input);
+
+  const txb = new TransactionBlock();
+  txb.transferObjects([txb.object(input.intention.objectId)], txb.pure(input.intention.receiver));
+  txb.setSender(input.sender);
+
+  return txb;
+}
+
+async function validateObjectTransfer(input: {
+  suiClient: SuiClient;
+  sender: string;
+  intention: IntentionObjectTransfer;
+}) {
+  const { suiClient, sender, intention } = input;
+  const obj = await suiClient.getObject({
+    id: intention.objectId,
+  });
+
+  if (obj.data === undefined) {
+    throw new Error('Object not found');
+  }
+  if (!obj.data?.type) {
+    throw new Error('Object type is null');
+  }
+  if (!Formatter.isSuiStructEqual(obj.data.type, intention.objectType)) {
+    throw new Error('Object type not expected');
+  }
+  if (Formatter.isCoinObjectType(obj.data.type)) {
+    throw new Error('Can not transfer coin object in Object Transfer transactions');
+  }
+  const addressOwner = getAddressOwner(obj);
+  if (!Formatter.isSuiAddressEqual(addressOwner, sender)) {
+    throw new Error('Object owner not match');
+  }
+}
+
+function getAddressOwner(object: SuiObjectResponse) {
+  const owner = object.data?.owner;
+  if (!owner) {
+    throw new Error('Object Owner not found');
+  }
+
+  if (typeof owner !== 'object' || !('AddressOwner' in owner)) {
+    throw new Error('Invalid object owner');
+  }
+  return owner.AddressOwner;
+}

package/src/transactions/reject.ts

@@ -0,0 +1,17 @@
+import { TransactionBlock } from '@mysten/sui.js/transactions';
+
+import { HexToUint8Array } from '@/utils/buffer';
+
+export async function buildRejectTxb(input: { sender: string; payloadToReject: string }) {
+  const approveTxb = TransactionBlock.from(HexToUint8Array(input.payloadToReject) as Uint8Array);
+  const gasPayment = approveTxb.blockData.gasConfig.payment;
+  if (!gasPayment) {
+    throw new Error('No gas payment found for approve payload');
+  }
+  // Reject transaction is an empty transaction block with the same gas payment as the
+  // transaction to be rejected.
+  const txb = new TransactionBlock();
+  txb.setGasPayment(gasPayment);
+  txb.setSender(input.sender);
+  return txb;
+}

package/src/transactions/stream.ts

@@ -0,0 +1 @@
+// TODO: Stream related transactions.

package/src/types/creation.ts

@@ -0,0 +1,19 @@
+export interface CreateMSafeAccountInfo {
+  ownerWithWeight: {
+    address: string;
+    weight: number;
+  }[];
+  threshold: number;
+  name: string;
+  description?: string;
+  creationNonce: number;
+}
+
+export interface CreatePermissionInfo {
+  ownerWithWeight: {
+    address: string;
+    weight: number;
+  }[];
+  threshold: number;
+  creationNonce: number;
+}

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from './creation';
+export * from './msafe';
+export * from './wallet';

package/src/types/msafe.ts

@@ -0,0 +1,79 @@
+import { PublicKey } from '@mysten/sui.js/src/cryptography';
+
+import { TxIntention } from '@/transactions/intention';
+
+export interface MSafeAccountInfo {
+  address: string;
+  ownersWithWeightPK: OwnerWithWeightPK[];
+  threshold: number;
+  name: string;
+  description?: string;
+  creationNonce: number;
+}
+
+export type OwnerWithWeightPK = OwnerWithWeight & {
+  publicKey: PublicKey;
+};
+
+export interface OwnerWithWeight {
+  address: string;
+  weight: number;
+}
+
+export interface PendingTx {
+  digest: string;
+  payload: string;
+  msafeAddress: string;
+  isRejectTx: boolean;
+  intention?: TxIntention;
+  creator: string;
+  createdAt: Date;
+  sequenceNumber: number;
+  votes: PendingVote[];
+}
+
+export interface PendingVote {
+  userAddress: string;
+  signature: string;
+  timestamp: Date;
+}
+
+// Transaction sent by the MSafe account.
+export interface HistorySendTx {
+  digest: string;
+  payload: string;
+  msafeAddress: string;
+  sequenceNumber: number;
+  isRejectTx: boolean;
+  status: string;
+  creator: string;
+  createdAt: Date;
+  votes: HistoryVote[];
+}
+
+// TODO: Add ReceiveTransaction in backend code.
+export interface ReceiveTransaction {
+  digest: string;
+  payload: string;
+  txType: string;
+  txSubType: string;
+  timestamp: Date;
+}
+
+export interface HistoryVote {
+  userAddress: string;
+  timestamp: Date;
+}
+
+export interface FutureIntention {
+  intention: TxIntention;
+  sequenceNumber: number;
+  msafeAddress: string;
+  creator: string;
+  txType: string;
+  txSubType: string;
+  rawData: string;
+  status: string;
+  statusRemark?: string;
+  createdAt: Date;
+}

package/src/types/wallet.ts

@@ -0,0 +1,23 @@
+import {
+  ExecuteTransactionRequestType,
+  SuiTransactionBlockResponseOptions,
+  SuiTransactionBlockResponse,
+} from '@mysten/sui.js/client';
+import { SignatureWithBytes } from '@mysten/sui.js/src/cryptography/keypair';
+import { TransactionBlock } from '@mysten/sui.js/transactions';
+
+export interface IWallet {
+  walletType: string;
+
+  address(): Promise<string>;
+
+  signPersonalMessage(input: { messageStr: string }): Promise<SignatureWithBytes>;
+
+  signTransactionBlock(input: { transactionBlock: TransactionBlock | Uint8Array }): Promise<SignatureWithBytes>;
+
+  signAndExecuteTransactionBlock(input: {
+    transactionBlock: TransactionBlock;
+    requestType?: ExecuteTransactionRequestType;
+    options?: SuiTransactionBlockResponseOptions;
+  }): Promise<SuiTransactionBlockResponse>;
+}

package/src/utils/buffer.ts

@@ -0,0 +1,11 @@
+export function stringToBuffer(s: string) {
+  return Buffer.from(s, 'utf-8');
+}
+
+export function Uint8ArrayToHex(b: Uint8Array): string {
+  return `0x${Array.prototype.map.call(b, (x) => `0${x.toString(16)}`.slice(-2)).join('')}`;
+}
+
+export function HexToUint8Array(hex: string): Uint8Array {
+  return Uint8Array.from(Buffer.from(hex.startsWith('0x') ? hex.slice(2) : hex, 'hex'));
+}

package/src/utils/coin.ts

@@ -0,0 +1,64 @@
+import { CoinMetadata, SuiClient, SuiObjectData } from '@mysten/sui.js/client';
+import { normalizeStructTag } from '@mysten/sui.js/utils';
+
+// CoinHelper is the coin helper to query for coin metadata.
+export class CoinHelper {
+  private _client: SuiClient;
+
+  private _coinMetaReg: Map<string, CoinMetadata>;
+
+  constructor(client: SuiClient) {
+    this._client = client;
+    this._coinMetaReg = new Map();
+  }
+
+  async getCoinMeta(coinType: string): Promise<CoinMetadata | undefined> {
+    const normalized = normalizeStructTag(coinType);
+    if (this._coinMetaReg.has(normalized)) {
+      return this._coinMetaReg.get(normalized);
+    }
+    const meta = await this.queryCoinMeta(normalized);
+    if (meta) {
+      this._coinMetaReg.set(normalized, meta);
+    }
+    return meta;
+  }
+
+  private async queryCoinMeta(coinType: string): Promise<CoinMetadata | undefined> {
+    const res = await this._client.getCoinMetadata({ coinType });
+    return res || undefined;
+  }
+}
+
+// Copied from sui/sdk/typescript/src/framework/framework.ts
+
+export const COIN_TYPE_ARG_REGEX =
+  /^0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<(.+)>$/;
+
+export class Coin {
+  static isCoin(type: string | undefined | null): boolean {
+    if (!type) {
+      return false;
+    }
+    return normalizeStructTag(type).match(COIN_TYPE_ARG_REGEX) != null;
+  }
+
+  static getCoinType(type: string) {
+    const [, res] = normalizeStructTag(type).match(COIN_TYPE_ARG_REGEX) ?? [];
+    return res || null;
+  }
+
+  static getBalance(data: SuiObjectData): bigint | undefined {
+    if (!Coin.isCoin(data.type)) {
+      return undefined;
+    }
+    if (data.content?.dataType !== 'moveObject') {
+      return undefined;
+    }
+    const { balance } = data.content?.fields as any;
+    if (balance === undefined) {
+      return undefined;
+    }
+    return BigInt(balance);
+  }
+}

package/src/utils/crypto.ts

@@ -0,0 +1,95 @@
+import {
+  PublicKey,
+  SerializedSignature,
+  SIGNATURE_FLAG_TO_SCHEME,
+  SignatureFlag,
+  SignatureScheme,
+} from '@mysten/sui.js/cryptography';
+import { Ed25519PublicKey } from '@mysten/sui.js/keypairs/ed25519';
+import { Secp256k1PublicKey } from '@mysten/sui.js/keypairs/secp256k1';
+import { Secp256r1PublicKey } from '@mysten/sui.js/keypairs/secp256r1';
+import { verifyPersonalMessage, verifyTransactionBlock } from '@mysten/sui.js/verify';
+
+import { stringToBuffer } from '@/utils/buffer';
+import { Formatter } from '@/utils/format';
+
+export class SignatureVerifier {
+  static async getPublicKeyFromSignature(input: {
+    message: Uint8Array;
+    messageType: 'TransactionBlock' | 'Personal';
+    signature: SerializedSignature;
+  }) {
+    if (input.messageType === 'TransactionBlock') {
+      return verifyTransactionBlock(input.message, input.signature);
+    }
+    return verifyPersonalMessage(input.message, input.signature);
+  }
+
+  static async getPublicKeyFromPersonalSignature(input: { messageStr: string; signature: SerializedSignature }) {
+    const message = stringToBuffer(input.messageStr);
+    return this.getPublicKeyFromSignature({
+      message,
+      messageType: 'Personal',
+      signature: input.signature,
+    });
+  }
+
+  static async verifySignature(input: {
+    message: Uint8Array;
+    messageType: 'TransactionBlock' | 'Personal';
+    signature: SerializedSignature;
+    targetAddress: string;
+  }) {
+    const publicKey = await SignatureVerifier.getPublicKeyFromSignature(input);
+    return Formatter.isSuiAddressEqual(publicKey.toSuiAddress(), input.targetAddress);
+  }
+
+  static async verifyPersonalSignature(input: {
+    messageStr: string;
+    signature: SerializedSignature;
+    targetAddress: string;
+  }) {
+    const message = stringToBuffer(input.messageStr);
+    return this.verifySignature({
+      message,
+      messageType: 'Personal',
+      signature: input.signature,
+      targetAddress: input.targetAddress,
+    });
+  }
+
+  static async verifyTransactionSignature(input: {
+    payload: Uint8Array;
+    signature: SerializedSignature;
+    targetAddress: string;
+  }): Promise<boolean> {
+    return this.verifySignature({
+      messageType: 'TransactionBlock',
+      message: input.payload,
+      signature: input.signature,
+      targetAddress: input.targetAddress,
+    });
+  }
+}
+
+export class PublicKeySerde {
+  static ser(publicKey: PublicKey) {
+    return {
+      publicKey: publicKey.toBase64(),
+      scheme: SIGNATURE_FLAG_TO_SCHEME[publicKey.flag() as SignatureFlag],
+    };
+  }
+
+  static de(input: { publicKey: string | Uint8Array; scheme: SignatureScheme }): PublicKey {
+    switch (input.scheme) {
+      case 'ED25519':
+        return new Ed25519PublicKey(input.publicKey);
+      case 'Secp256k1':
+        return new Secp256k1PublicKey(input.publicKey);
+      case 'Secp256r1':
+        return new Secp256r1PublicKey(input.publicKey);
+      default:
+        throw new Error('Unsupported signature scheme: $input.scheme');
+    }
+  }
+}

package/src/utils/format.ts

@@ -0,0 +1,25 @@
+import { normalizeSuiAddress, normalizeStructTag } from '@mysten/sui.js/utils';
+
+import { Coin } from '@/utils/coin';
+
+export class Formatter {
+  static normalizeSuiAddress(addr: string) {
+    return normalizeSuiAddress(addr);
+  }
+
+  static normalizeStructTag(struct: string) {
+    return normalizeStructTag(struct);
+  }
+
+  static isSuiAddressEqual(addr1: string, addr2: string) {
+    return normalizeSuiAddress(addr1) === normalizeSuiAddress(addr2);
+  }
+
+  static isSuiStructEqual(struct1: string, struct2: string) {
+    return normalizeStructTag(struct1) === normalizeStructTag(struct2);
+  }
+
+  static isCoinObjectType(struct: string) {
+    return Coin.isCoin(struct);
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,6 @@
+export * from './buffer';
+export * from './crypto';
+export * from './format';
+export * from './multi-sig';
+export * from './sui';
+export * from './coin';