11 design patterns of the logic required for social implementation.

[xembook]

Hi,
Last year, I put together 11 design patterns of the logic required for social implementation.

https://qiita.com/nem_takanobu/items/cc2aa777ad1fa78d9ede

They are still in Japanese, and I don't know how to express them if I replace them with English.
I hope we can discuss the deletion of what is unnecessary and the addition of what seems even more necessary.

1.Notarization and Apostille
2.Traceability
3.Ownership/Sharing
4. transfer/restoration
5.Cancellation
6.Expiration date
7.Name resolution
8.Timer remittance
9. Authentication
10.Distribution
11.Definitive proof of existence

[xembook]

Description of pseudocode

transaction

Alice.TransactionType{
   [option]
}->Bob

multisig transaction

AssetAccount<-(2-of-3){CosignerAccount1,CosignerAccount2,...}
.TransactionType{}
->RecipientAccount

sign by cosignature

listener.aggregateBondedAdded(Bob)
.subscribe(tx => Bob.signCosignature(tx));

transaction search by hash

TransactionRepo.search({id:hash})
.subscribe(tx=> Alice.publicKey.verify(tx.hash))

[xembook]

sample expression

Transfer Transaction

Alice.Transfer{
  Message:"Hello",
  Mosaic:{xym:10}
}-> Bob

Metadata Transaction

Alice.AccountMetadata{
  Endpoint:http://...,
  PublicKey:asdfada
}->Alice

AccounInfo Search

AccountRepo.search({publicKey:Alice})
.subscribe(accountInfo=> getPublicKey(publicKey))

Metadata Search

MetadataRepo.search({
  sourceAddress:Alice,
  targetAddress:Alice,
  scopedMetadataKey:canceled  
})
.subscribe(meta=> getCancelInfo(meta.value))

[xembook]

1.Notarization and Apostille

Issuer.Transfer{
  Message:hash(Artwork.file)
} -> Holder

//Verifier
TransactionRepo.search({id:hash(Artwork)})
.subscribe(tx => Holder.publicKey.verify(tx.hash))

[xembook]

2.Traceability

Alice.Transfer{
  Message:hash(work1.file),
} -> Alice

Bob.Transfer{
  Message:hash(work2.file),
} -> Alice

Carol.Transfer{
  Message:hash(work3.file),
} -> Alice

[xembook]

3.Ownership/Sharing

//create multisig
Alice.MultisigAccountModification{
  Add:[Bob,Security]
}

//optin
listener.aggregateBondedAdded(Bob)
.subscribe(tx => Bob.signCosignature(tx));

listener.aggregateBondedAdded(Security)
.subscribe(tx => Security.signCosignature(tx));

Alice is owned/shared by Bob and Security Account

[xembook]

4. transfer/restoration

Alice<-(2-of-3){Bob,Security,...}
.MultisigAccountModification{
  Delete:[Bob],
  Add:[Carol]
}

//optin
listener.aggregateBondedAdded(Bob)
.subscribe(tx => Bob.signCosignature(tx));

listener.aggregateBondedAdded(Carol)
.subscribe(tx => Carol.signCosignature(tx));

[xembook]

5.Cancellation

Alice.AccountMetadata{
  canceled:True
}->Alice

//verifier
MetadataRepo.search({
  sourceAddress:Alice,
  targetAddress:Alice,
  scopedMetadataKey:canceled  
})
.subscribe(meta=> getCancelInfo(meta.value))

[xembook]

6.Expiration date

Issuer.AccountMetadata{
  StartBlock:234566
}-> Alice

//Extend expired period
listener.aggregateBondedAdded(Alice)
.subscribe(tx => Alice.signCosignature(tx));

//update expired period
Issuer.Transfer{
  Mosaic:{expired:1}
}-> Alice

//verifier get start block
MetadataRepo.search({
  sourceAddress:Ivan,
  targetAddress:Alice,
  scopedMetadataKey:StartBlock  
})
.subscribe(meta=> getStartBlock(meta.value))

//verifier get expired period
TransactionRepo.search({transferMosaicId:expired})
.subscribe(tx=> getAmount(tx.mosaics) + startBlock)

[xembook]

7.Name resolution

/* regster */

Alice.NamespaceRegistration{
  name:alice_name
}

Alice.AccountMetadata{
  Endpoint:http://aaa.com
}-> Alice

/*　resolve */

//verifier
NamespaceRepo.getNamespace(alice_name)
.subscribe(
  (ns) => getOwnerAddress(ns)
);

MetadataRepo.search({
  sourceAddress:OwnerAddress,
  targetAddress:OwnerAddress,
  scopedMetadataKey:"Endpoint"
})
.subscribe(meta=> getEndpoint(meta.value))