fix: initail version of sdk

package.json

@@ -89,7 +89,7 @@
     "@commitlint/config-conventional": "^13.1.0",
     "@onflow/fcl": "^1.4.1",
     "@onflow/types": "^1.1.0",
-    "@rarible/api-client": "0.16.5-alpha.13",
+    "@rarible/api-client": "0.18.0-alpha.2",
     "@rarible/eslint-config-react": "~0.10.0-alpha.37",
     "@rarible/eslint-config-ts": "~0.10.0-alpha.37",
     "@rarible/prettier": "~0.10.0-alpha.37",

packages/aptos-sdk/src/common/balance.test.ts

@@ -7,7 +7,7 @@ describe("balance", () => {
 
   const balanceInstance = new AptosBalance(aptos)
 
-  test("get balance", async () => {
+  test.skip("get balance", async () => {
     const randomAccount = Account.generate()
     await aptos.fundAccount({
       accountAddress: randomAccount.accountAddress,

packages/aptos-sdk/src/common/test/index.ts

@@ -1,4 +1,4 @@
-import type { CommittedTransactionResponse, Ed25519Account } from "@aptos-labs/ts-sdk"
+import type { AnyRawTransaction, CommittedTransactionResponse, Ed25519Account } from "@aptos-labs/ts-sdk"
 import { Account, Aptos, AptosConfig, Network, Ed25519PrivateKey } from "@aptos-labs/ts-sdk"
 import { AptosGenericSdkWallet } from "@rarible/aptos-wallet"
 import { isObjectLike } from "@rarible/sdk-common"
@@ -14,13 +14,34 @@ export function createTestAptosState(privateKey: string = DEFAULT_PK): TestAptos
   const config = new AptosConfig({ network: APTOS_NETWORK })
   const envConfig = getEnvConfig(APTOS_NETWORK)
   const aptos = new Aptos(config)
+  const wallet = new AptosGenericSdkWallet(aptos, account)
 
   return {
     aptos,
     account,
-    wallet: new AptosGenericSdkWallet(aptos, account),
+    wallet,
     config: envConfig,
-    transferAPT: transferAPT.bind(null, aptos, account),
+    transferAPT: transferAptosCoins.bind(null, { aptos, wallet }),
+  }
+}
+
+export function generateTestAptosState(): TestAptosState {
+  const account = Account.generate()
+  console.log("pk", account.privateKey.toString())
+  console.log("address", account.accountAddress.toString())
+
+  const APTOS_NETWORK: Network = Network.TESTNET
+  const config = new AptosConfig({ network: APTOS_NETWORK })
+  const envConfig = getEnvConfig(APTOS_NETWORK)
+  const aptos = new Aptos(config)
+
+  const wallet = new AptosGenericSdkWallet(aptos, account)
+  return {
+    aptos,
+    account,
+    wallet,
+    config: envConfig,
+    transferAPT: transferAptosCoins.bind(null, { aptos, wallet }),
   }
 }
 
@@ -29,23 +50,9 @@ export type TestAptosState = {
   account: Ed25519Account
   wallet: AptosGenericSdkWallet
   config: AddressConfig
-  transferAPT: (recepient: string, amount: number) => Promise<CommittedTransactionResponse>
+  transferAPT: (recepient: string, amount: string) => Promise<CommittedTransactionResponse>
 }
 
-async function transferAPT(aptos: Aptos, senderAccount: Ed25519Account, recepient: string, amount: number) {
-  const sendAptTx = await aptos.transferCoinTransaction({
-    sender: senderAccount.accountAddress,
-    recipient: recepient,
-    amount,
-  })
-  const pendingTxn = await aptos.signAndSubmitTransaction({
-    signer: senderAccount,
-    transaction: sendAptTx,
-  })
-  return aptos.waitForTransaction({
-    transactionHash: pendingTxn.hash,
-  })
-}
 //0x484e284d3b98ce736b6b6de27127176bafe30942d949f30b0ab59a17007ccf37
 export const DEFAULT_PK = "0x229eea52e53be5a6fd1ba00e660fc632cdb47ffe8f777a847daa8220553c5511"
 //0xa4576f0bc3f835b5b45b4e49da280779b6352f2083fe28c94386468731b3fd3c
@@ -58,53 +65,146 @@ export async function mintTestToken(
   const mintClass = new AptosNft(state.aptos, new AptosGenericSdkWallet(state.aptos, state.account), state.config)
   const randomId = Math.floor(Math.random() * 1000000)
   const uri = "ipfs://QmWYpMyoaUGNRSQbwhw97xM8tcRWm4Et598qtzmzsau7ch/"
-  let tokenAddress
+  const tokenName = `Mytoken #${randomId}`
+  let mintResult, tokenAddress
   if (!options || (isObjectLike(options) && "collectionName" in options)) {
-    const mintResult = await mintClass.mintWithCollectionName({
+    mintResult = await mintClass.mintWithCollectionName({
       collectionName: options?.collectionName || "Test collection 1016",
-      name: `Mytoken #${randomId}`,
+      name: tokenName,
       description: `Description of Mytoken #${randomId}`,
       uri,
     })
     tokenAddress = mintResult.tokenAddress
   } else if (isObjectLike(options) && "collectionAddress" in options) {
-    const mintResult = await mintClass.mintWithCollectionAddress({
+    mintResult = await mintClass.mintWithCollectionAddress({
       collectionAddress: options?.collectionAddress,
-      name: `Mytoken #${randomId}`,
+      name: tokenName,
       description: `Description of Mytoken #${randomId}`,
       uri,
     })
     tokenAddress = mintResult.tokenAddress
   } else {
     throw new Error("Unexpected options")
   }
-  return tokenAddress
+  return { tokenAddress, tokenName: mintResult.tokenName || tokenName }
 }
 
 export async function createTestCollection(state: TestAptosState) {
   const deploy = new AptosNft(state.aptos, state.wallet, state.config)
   const randomId = Math.floor(Math.random() * 100_000_000)
   const uri = "ipfs://QmWYpMyoaUGNRSQbwhw97xM8tcRWm4Et598qtzmzsau7ch/"
+  const collectionName = `Test collection #${randomId}`
   const { rariDropAddress, aptosCollectionAddress } = await deploy.createCollection({
-    name: `Test collection #${randomId}`,
+    name: collectionName,
     description: "description",
     uri,
   })
   return {
     rariDropAddress,
     aptosCollectionAddress,
+    collectionName,
   }
 }
 
 export async function createTestCollectionAndMint(state: TestAptosState) {
-  const { rariDropAddress, aptosCollectionAddress } = await createTestCollection(state)
-  const tokenAddress = await mintTestToken(state, {
+  const { rariDropAddress, aptosCollectionAddress, collectionName } = await createTestCollection(state)
+  const { tokenAddress, tokenName } = await mintTestToken(state, {
     collectionAddress: rariDropAddress,
   })
   return {
     rariDropAddress,
     aptosCollectionAddress,
     collectionAddress: aptosCollectionAddress,
+    collectionName,
     tokenAddress,
+    tokenName,
+  }
+}
+export async function createV1TokenWithFeePayer(feePayerState: TestAptosState, state: TestAptosState) {
+  const createV1NftTx = await state.aptos.transaction.build.simple({
+    sender: state.account.accountAddress.toString(),
+    withFeePayer: true,
+    data: {
+      function: `0x1cd6ec749dfd85537f41ea6c07c135532c87ba02b13a709286e352a004657c3a::create_nft_with_resource_account::mint_event_ticket`,
+      typeArguments: [],
+      functionArguments: [],
+    },
+  })
+
+  return sendTxWithPayer(feePayerState, state, createV1NftTx)
+}
+
+export async function sendTxWithPayer(
+  feePayerState: TestAptosState,
+  state: TestAptosState,
+  transaction: AnyRawTransaction,
+) {
+  const senderAuthenticator = state.aptos.transaction.sign({
+    signer: state.account,
+    transaction,
+  })
+  const feePayerAuthenticator = state.aptos.transaction.signAsFeePayer({
+    signer: feePayerState.account,
+    transaction,
+  })
+
+  const commitedTx = await state.aptos.transaction.submit.simple({
+    transaction,
+    senderAuthenticator: senderAuthenticator,
+    feePayerAuthenticator: feePayerAuthenticator,
+  })
+  return state.aptos.waitForTransaction({
+    transactionHash: commitedTx.hash,
+  })
+}
+export async function createV1Token(state: TestAptosState) {
+  const rawTx = {
+    function: `0x1cd6ec749dfd85537f41ea6c07c135532c87ba02b13a709286e352a004657c3a::create_nft_with_resource_account::mint_event_ticket`,
+    typeArguments: [],
+    arguments: [],
+  }
+  const pendingTx = await state.wallet.signAndSubmitTransaction(rawTx)
+  const commitedTx = await state.aptos.waitForTransaction({
+    transactionHash: pendingTx.hash,
+  })
+  if (!("events" in commitedTx)) {
+    throw new Error("Mint transaction should consist 'events' field")
+  }
+
+  const collectionEvent = commitedTx.events.find(e => e?.type.includes("0x3::token::MintTokenEvent"))
+  if (collectionEvent) {
+    return {
+      tx: commitedTx,
+      propertyVersion: collectionEvent.sequence_number,
+      collectionName: "Test Collection V1 - Rarible",
+      tokenName: "Crypto Cats N2",
+      creator: "0x1cd6ec749dfd85537f41ea6c07c135532c87ba02b13a709286e352a004657c3a",
+    }
   }
+  throw new Error("Mint event has not been found")
+}
+
+/**
+ *
+ * @param state Sender state
+ * @param to Receipent
+ * @param amount Integer
+ */
+export async function transferAptosCoins(
+  state: {
+    aptos: Aptos
+    wallet: AptosGenericSdkWallet
+  },
+  to: string,
+  amount: string,
+) {
+  const transferData = {
+    function: "0x1::aptos_account::transfer_coins",
+    typeArguments: ["0x1::aptos_coin::AptosCoin"],
+    arguments: [to, amount],
+  }
+  const pendingTx = await state.wallet.signAndSubmitTransaction(transferData)
+  return state.aptos.waitForTransaction({
+    transactionHash: pendingTx.hash,
+  })
 }

packages/aptos-sdk/src/config/index.ts

@@ -3,14 +3,14 @@ import type { SupportedNetwork } from "../domain"
 
 export const CONFIG: Record<SupportedNetwork, AddressConfig> = {
   [AptosNetwork.TESTNET]: {
-    marketplaceAddress: "0x8d67f2ffcb48820474a71dbb128396bbfbb401fdf7b91d2b07d1a7479ccbdfee",
-    feeZeroScheduleAddress: "0xbfb0d6a55cb0839c55bcde77c2852b700d64b3afd00ac8e319679cb31bf99063",
-    raribleDropMachineAddress: "0xba7191af5b1435ccd7a7ee925650b1a0a58f57db4e28345ce48bf12c40b71126",
+    marketplaceAddress: "0x465a0051e8535859d4794f0af24dbf35c5349bedadab26404b20b825035ee790",
+    feeZeroScheduleAddress: "0xae22b0c0beee82ba654c2094c3bbf80706484978d2b5ba29620551a18a7e4b4c",
+    raribleDropMachineAddress: "0xa0cb9758d3b0efb5fa76c4cccea8028b0fc6600226c46f7679d75566570bbf23",
   },
   [AptosNetwork.MAINNET]: {
     marketplaceAddress: "0x465a0051e8535859d4794f0af24dbf35c5349bedadab26404b20b825035ee790",
-    feeZeroScheduleAddress: "0x9db2c77084b1507acb9cb7d16350598b1e9db1cc61ecba1b017c467398d13f03",
-    raribleDropMachineAddress: "",
+    feeZeroScheduleAddress: "",
+    raribleDropMachineAddress: "0xa0cb9758d3b0efb5fa76c4cccea8028b0fc6600226c46f7679d75566570bbf23",
   },
 }
 

packages/aptos-sdk/src/domain.ts

@@ -26,6 +26,15 @@ export interface AptosBalanceSdk {
 
 export interface AptosOrderSdk {
   sell(tokenAddress: string, feeObjectAddress: string, startTime: number, price: string): Promise<string>
+  sellV1(
+    feeObjectAddress: string,
+    creatorAddress: string | undefined,
+    collectionName: string,
+    tokenName: string,
+    propertyVersion: string,
+    startTime: number,
+    price: string,
+  ): Promise<string>
 
   buy(listing: string): Promise<CommittedTransactionResponse>
 
@@ -39,14 +48,40 @@ export interface AptosOrderSdk {
     price: string,
   ): Promise<string>
 
+  collectionOfferV1(
+    creatorAddress: string | undefined,
+    collectionName: string,
+    feeObjectAddress: string,
+    price: string,
+    amount: number,
+    endTime: number,
+  ): Promise<string>
+
   acceptCollectionOffer(offer: string, token: string): Promise<CommittedTransactionResponse>
+  acceptCollectionOfferV1(
+    offer: string,
+    tokenName: string | undefined,
+    propertyVersion: string,
+  ): Promise<CommittedTransactionResponse>
 
   cancelCollectionOffer(offer: string): Promise<CommittedTransactionResponse>
 
   tokenOffer(tokenAddress: string, feeObjectAddress: string, endTime: number, price: string): Promise<string>
 
+  tokenOfferV1(
+    creatorAddress: string,
+    collectionName: string,
+    tokenName: string,
+    propertyVersion: string,
+    feeObjectAddress: string,
+    price: string,
+    endTime: number,
+  ): Promise<string>
+
   acceptTokenOffer(offer: string): Promise<CommittedTransactionResponse>
 
+  acceptTokenOfferV1(offer: string, tokenName: string, propertyVersion: string): Promise<CommittedTransactionResponse>
+
   cancelTokenOffer(offer: string): Promise<CommittedTransactionResponse>
 
   getFeeScheduleAddress: () => string

packages/aptos-sdk/src/nft/burn.test.ts

@@ -1,4 +1,4 @@
-import { createTestAptosState, mintTestToken } from "../common/test"
+import { createTestAptosState, createV1Token, mintTestToken } from "../common/test"
 import { AptosNft } from "./nft"
 
 describe("burn nft", () => {
@@ -7,12 +7,18 @@ describe("burn nft", () => {
   const burnClass = new AptosNft(aptos, wallet, config)
 
   test("burn", async () => {
-    const testTokenAddress = await mintTestToken(state)
+    const { tokenAddress } = await mintTestToken(state)
 
-    await burnClass.burn(testTokenAddress)
+    await burnClass.burn(tokenAddress)
 
     const assets = await aptos.getOwnedDigitalAssets({ ownerAddress: account.accountAddress })
-    const tokenOfNewOwner = assets.find(asset => asset.token_data_id === testTokenAddress)
+    const tokenOfNewOwner = assets.find(asset => asset.token_data_id === tokenAddress)
     expect(tokenOfNewOwner).toBeFalsy()
   })
+
+  test("burn v1 token", async () => {
+    const { propertyVersion, collectionName, tokenName, creator } = await createV1Token(state)
+    const tx = await burnClass.burnV1Token(creator, collectionName, tokenName, propertyVersion, "1")
+    console.log("tx", tx)
+  })
 })

packages/aptos-sdk/src/nft/create-collection.test.ts

@@ -5,11 +5,11 @@ describe("create collection", () => {
   const { aptos, config, wallet } = createTestAptosState()
   const deploy = new AptosNft(aptos, wallet, config)
 
-  test.skip("create collection", async () => {
+  test("create collection", async () => {
     const uri = "ipfs://QmWYpMyoaUGNRSQbwhw97xM8tcRWm4Et598qtzmzsau7ch/"
     const randomId = Math.floor(Math.random() * 100_000_000)
 
-    const { tx, collectionAddress } = await deploy.createCollection({
+    const { tx, collectionAddress } = await deploy.createNativeCollection({
       name: `Test collection #${randomId}`,
       description: "description",
       uri,

packages/aptos-sdk/src/nft/mint.test.ts

@@ -1,14 +1,15 @@
-import { createTestAptosState } from "../common/test"
+import { createTestAptosState, createV1Token } from "../common/test"
 import { AptosNft } from "./nft"
 
 describe("mint nft", () => {
-  const { aptos, config, wallet } = createTestAptosState()
+  const state = createTestAptosState()
+  const { aptos, config, wallet } = state
   const mintClass = new AptosNft(aptos, wallet, config)
 
-  test.skip("mint by mintDigitalAssetTransaction function", async () => {
+  test("mint by mintDigitalAssetTransaction function", async () => {
     const uri = "ipfs://QmWYpMyoaUGNRSQbwhw97xM8tcRWm4Et598qtzmzsau7ch/"
     const { tx, tokenAddress } = await mintClass.mintWithCollectionName({
-      collectionName: "Test collection #42601579",
+      collectionName: "Test collection #3072715",
       name: "Mytoken #4",
       description: "Description of Mytoken #4",
       uri,
@@ -28,4 +29,9 @@ describe("mint nft", () => {
     })
     console.log("tx", JSON.stringify(tx, null, "  "))
   })
+
+  test("mint v1", async () => {
+    const tx = await createV1Token(state)
+    console.log("tx", JSON.stringify(tx, null, "  "))
+  })
 })